Challenging the Diabolical Developer: A Conversation with JavaOne
Rock Star Martijn Verburg

by Janice J. Heiss

Published October 2012

Editor's Note: Martijn Verburg was just made Java Champion, along with Yara Senger, Agnes Crepet and Lars Vogel. Congratulations, all! Learn more about the Java Champions Project.

Martijn Verburg
Martijn Verburg

Few developers have done more to move and shake the Java community in recent years than Martijn Verburg. He was voted by his peers as a JavaOne Rock Star for his "Diabolical Developer" session at the JavaOne 2011 conference, in which he identified some of the worst practices Java developers are prone to engage in. He is co-leader of the thriving London Java Community (LJC)—a Java User Group (JUG) that has more than 2,500 members and a seat on the Java Community Process (JCP) Executive Committee (EC)—and he leads the global effort for the JUG "Adopt a JSR" and "Adopt OpenJDK" programs. He is a co-organizer of UK Graduate Developers, a moderator on CodeRanch.com, and the community leader for PCGen (one of the world's largest free and open source software [FOSS] projects) and Ikasan (a recently open sourced Enterprise Integration Platform [EIP] framework from Mizuho International).

He is currently CTO at jClarity, a startup focusing on automating optimization for Java and Java Virtual Machine (JVM)–related technologies, and he is a product advisor at ZeroTurnaround. He co-authored, with Ben Evans, The Well-Grounded Java Developer, published by Manning and, as a leading authority on technical team optimization, he is in high demand at major software conferences.

Verburg was born in Holland, grew up and received his education in New Zealand, and currently resides in London.

Oracle Technology Network: You were voted by your JavaOne peers as a JavaOne Rock Star for your session on the diabolical developer, in which you identified some "diabolical" practices that Java developers engage in. Tell us about some of the bad practices.

Verburg: I'll refrain from going overboard, but here are the ones that have left me shaking my head in disbelief most often:

“Software development is far more a social activity than a technical one; most projects fail because of communication issues and social dynamics, not because of a bad technical decision.”

Martijn Verburg
JavaOne Rock Star
  • A lack of communication: Software development is far more a social activity than a technical one; most projects fail because of communication issues and social dynamics, not because of a bad technical decision. Sadly, many developers never learn this lesson.
  • No source control: Some developers simply store code in local file systems and e-mail the code in order to integrate their changes; yes, this still happens.
  • Design-driven design: Some developers are inclined to cram every design pattern from the Gang of Four (GoF) book into their projects. Of course, by that stage, they've actually forgotten why they're building the software in the first place.

Oracle Technology Network: If these practices are so bad, why do developers engage in them?

Verburg: I've seen a wide range of reasons:

  • They were never taught at their high school or university that their bad habits were harmful.
  • They weren't mentored in their first professional roles.
  • They've lost passion for their craft.
  • They think software development is a technical activity and not a social one.
  • They think that they'll be able to tidy it up later.
  • They're deliberately being malicious!

Oracle Technology Network: Can you identify any core confusions, assumptions, or misconceptions that lead Java developers to engage in bad practices?

Verburg: With Java and the JVM, in particular, I've seen a couple of trends. One is that developers think that the JVM is a magic box that will clean up their memory and make their code run fast, as well as make them cups of coffee. The JVM does help in a lot of cases, but bad code can and will still lead to terrible results!

The other trend is to try to force Java (the language) to do something it's not very good at, such as rapid Web development. So you get a proliferation of overly complex frameworks, libraries, and techniques trying to get around the fact that Java is a monolithic, statically typed, compiled, OO environment. It's not a Golden Hammer!

Oracle Technology Network: Kirk Pepperdine wrote in 2006 that, "violating design principles or writing overly complex code is often the stumbling block to achieving good performance."

In a similar vein, Oracle's Brian Goetz recommends that developers write "dumb code," by which he means straightforward, clean code that follows the most obvious object-oriented principles, in order to get the best compiler optimization. He argues that clever, hacked-up, bit-banging code will get poorer results. Your thoughts?

Verburg: I agree with them completely! With a managed runtime, you can get huge benefits by writing algorithmically simple code. In Java's case, it allows the JVM to very easily detect hotspots and make intelligent optimizations based on some fine empirical research done in the 1980s.

A commonly cited example of this is that a server-class JVM will, by default, try to inline methods that are less than 35 byte codes in size (after 10,000 calls). So if you have lots of small, simple methods, the JVM can inline those, which provides a great opportunity to apply even more optimizations, such as dead-code elimination.

The Java Hotspot VM just-in-time (JIT) compiler is simply amazing—something like more than 1,000 person-years of effort have been put into it. So my advice to Java developers is to help it do the heavy lifting and clever optimizing for you.

Keys to a Good JUG

Oracle Technology Network: What are the keys to a good JUG?

Verburg: You need to have a "why." Many user groups know "what" they do (typically events) and "how" they do it (the logistics), but what really drives users to join your group and to stay is to give them a purpose. Within the LJC, we constantly talk about the "why," and there actually turn out to be several whys:

  • Reignite the passion that developers have for their craft.
  • Raise the bar of Java developers in London.
  • Enable developers to have a voice in deciding the future of Java.
  • Inspire the next generation of technology leaders.
  • Bring the disparate technology groups in London together.
  • Learn from each other.

We believe that the Java ecosystem forms an important cornerstone of our society today, and we want to protect that for the future.

There are lots of other "what" and "how" factors that you should think about as well. I covered them in a recent talk with Ben Evans at OSCON.

Oracle Technology Network: What are some mistakes that you see JUGs making?

Verburg: Not listening to their members, for example, putting on events that sponsors want but the members don't want; not being inclusive enough (as with any social group, you can get cliques); and having a single point of failure (the sole leader takes a break and the group simply collapses).

"Adopt a JSR" Program

Oracle Technology Network: Tell us about the "Adopt a JSR" program.

Verburg: People should check out the "Adopt a JSR" home page for this initiative. It's an effort to get day-to-day developers more involved in Java standards, especially through providing early feedback and helping with practical tasks. Oracle was actually the major instigator behind JSR 348 (JCP.next.1), which lowered barriers to entry. Naturally, we and the other JCP EC members were all fully supportive of that JSR and are now working to lower barriers even further.

We work with the JUGs worldwide to encourage them to adopt a JSR (or several) and help that particular standard evolve into the sort of high-quality, developer-friendly specification that will stand the test of time.

Some success stories include helping ensure that JSR 310 (Date and Time) makes it in to Java SE 8 (lots of practical hacking and workshops there) and helping Brian Goetz and the Lambda (JSR 335) expert group with some of their tough decisions by providing empirical evidence on how day-to-day developers would use this major new Java SE 8 feature.

Oracle Technology Network: You and Ben Evans are giving a JavaOne 2012 session (BOF6283) titled "101 Ways to Improve Java: Why Developer Participation Matters." Share with us a few of your favorite ways to improve Java.

Verburg: Readers might check out the "Adopt OpenJDK" home page. Getting involved in the OpenJDK itself is the best way to improve Java! For the "Adopt OpenJDK" program, we hold regular bugathons, test the latest features, provide feedback, and generally try to gather empirical evidence on how Java and the JVM are used in order to improve Java going forwards.

A couple of other things that people can do are to simply battle some of the fear, uncertainty, and doubt (FUD) going on around Java (for example, "Java is dead") and to continue to build out the massive FOSS ecosystem we have today. There's nothing like making a cool technology idea accessible to most of the world by providing a Java API for it.

Oracle Technology Network: Tell us about bugathons and their importance to the London JUG.

Verburg: They're a very popular, practical, hands-on focal point for our user group. As a Java developer, there's almost nothing better than fixing bugs in Java itself! It also gives developers the chance to look beyond just themselves and understand the massive impact Java has on society today. We're very grateful to Cecilia Borg, Stuart Marks, Artem Ananiev, Jonathan Gibbons, and a whole host of other Oracle and OpenJDK folks who have been supporting us with these bugathons.

Oracle Technology Network: What do you want Java developers to understand about the JCP?

Verburg: That it's no longer a lofty standards body out of the reach of mere mortals! All of the changes that have been pushed recently mean that the technical, legal, and community barriers are now very low (and we're working on lowering them further). The JCP wants your participation and actually needs your help to keep Java, Java EE, and Java ME moving in the right direction.

Life as a Java Programmer

Oracle Technology Network: Where in the process of programming do you have the most fun?

Verburg: I love the modeling part; I'm an absolute stickler for naming and domain modeling, and I get a real kick out of seeing a well-modeled domain represented in Java backed by tests.

Oracle Technology Network: Can you describe the process of writing code?

"Writing code is one of the most amazing, creative things you can do in life—many programmers actually get the same euphoric feeling when completing some piece of functionality that others get from exercise or music."

Martijn Verburg
JavaOne Rock Star

Verburg: I think it's a very personal thing. I tend to do a fair amount of modeling and white boarding before I sit down at the keyboard and do the physical coding. I tend to try to test drive my design and my code because I like to be able to refactor rapidly without fear. All in all, writing code is one of the most amazing, creative things you can do in life—many programmers actually get the same euphoric feeling when completing some piece of functionality that others get from exercise or music.

Oracle Technology Network: The Java class that you couldn't live without is...?

Verburg: Collections. There are lots of useful utility methods in that one. That said, I'll move to Google's Guava Collections2 class, if need be.

Oracle Technology Network: What recent changes to the platform have made your life more complicated?

Verburg: Well, it's not really recent, but some of the corner cases around Generics, Collections, and inheritance have made writing concise code very difficult. At our startup (jClarity), we'll occasionally throw our hands up in the air and write a small bit in, say, a language like Scala to get around the verbosity.

Oracle Technology Network: What are some things you would like to accomplish using Java?

Verburg: I'd like to see the story of the JVM completed; I believe that the JVM and analytics around it can be intelligent enough to detect problems at runtime and self-heal them. At our startup, we're looking to complete that very story. I work with some amazing people including Ben Evans, Kirk Pepperdine, and a few other amazing developers (Dr. Richard Warburton and Dr. John Oliver) who constantly show up my programming skills!

Oracle Technology Network: What technical insights into the Java programming language have been most important to you?

Verburg: Understanding how the JVM really works, which is something I'm still learning a good deal about! Knowing how the Java Memory Model (JMM), garbage collectors, and the Java Hotspot VM JIT compiler work completely changes how you think about writing good, clean Java code that works with the JVM. It's been a real eye-opener for me in the last few years on this front.

Oracle Technology Network: What has surprised you the most about the evolution of the Java platform?

Verburg: Probably the ability of the Java Hotspot VM, JIT compiler, and garbage collection (GC) folks to continue making the JVM the relevant, flexible VM it is today. Adding functionality such as invokedynamic is very, very difficult on what is arguably a fairly venerable platform now. A secondary surprise has been the rise of polyglot programming on the JVM—it's what will help keep the Java platform around for a very, very long time.

Oracle Technology Network: What are you most excited about in Java SE 8?

"I cannot wait for Lambdas—Brian Goetz and his group are doing a great job, especially given some of the backwards compatibility that they have to maintain."

Martijn Verburg
JavaOne Rock Star

Verburg: I cannot wait for Lambdas—Brian Goetz and his group are doing a great job, especially given some of the backwards compatibility that they have to maintain. It's going to remove a lot of boilerplate and yet maintain readability, plus enable parallel scaling for those who need it.

Oracle Technology Network: What do you do when you are stumped?

Verburg: If it's something small, I usually call for another set of eyes (we pair often anyhow) or call out to Twitter or Stack Exchange. Otherwise, I go for a walk or do anything that gets me away from thinking directly about the problem for a good 20 minutes. It almost always works.

Oracle Technology Network: What would you like to see in Java EE 7?

Verburg: More collaboration with the existing cloud providers who've led the way and deserve some input and kudos, plus less-rigid definitions of what the experts think people's roles are with cloud technology.

See Also

About the Author

Janice J. Heiss is the Java acquisitions editor at Oracle and a technology editor at Java Magazine.

Join the Conversation

Join the Java community conversation on Facebook, Twitter, and the Oracle Java Blog!