Go Ahead: Next Generation Java Programming Style

Many companies and developers move away from Java to new languages: Ruby, Python, Groovy, Erlang, Scala. You might be trapped with Java.

Even if you've trapped, you can change your programming style and reap some of the benefits of those new languages. In the last 15 years Java programming style has changed significantly:

  1. Final is your new love: More and more Java developers in the teams I've worked with, started to use final. Making variables final prevents changing those values. Most often, if you reasign a value, it's a bug or you should use a new variable. Final prevents bugs and makes code easier to read and understand. Make everything immutable.
    final Foo bar = new Foo();

    I've written more about this topic in "All variables in Java must be final".

  2. No setters. Many Java developers automatically - sometimes with the evil help of an IDE - write setters for all fields in their classes. You should not use setters. Think about each setter you want to write, are they really necessary for your fields? Better create new copies of your objects if values change. And try to write code without getters either. Tell, don't ask tells you more about the concept.
  3. Do not use loops for list operations. Learning from functional languages, looping isn't the best way to work on collections. Suppose we want to filter a list of persons to those who can drink beer. The loop versions looks like:
    List<Person> beerDrinkers = new ArrayList<Person>();
    for (Person p: persons) {
        if (p.getAge() > 16) {

    This can - even in Java - be rewritten to a more a functional programming style. For example using Google collections filter:

    Predicate<HasAge> canDrinkBeer = new Predicate<HasAge>() {
        public boolean apply(HasAge hasAge) {
            return hasAge.getAge() > 16;
    List<Person> beerDrinkers = filter(persons, canDrinkBeer);

    As remarked by Dave Jarvis, I should have dropped the getter, and he's right 😉

    Predicate canDrinkBeer = new Predicate() {
         public boolean apply(HasAge hasAge) {
             return hasAge.isOlderThan( 16 );

    which would lead to better code down the road:

    Predicate canDrinkBeer = new Predicate() {
        public boolean apply( HasAge hasAge, HasAge otherAge ) {
            return hasAge.isOlderThan( otherAge );

    The predicate version is slightly larger, but consists of two parts. Each one is easier to understand. While the loop version gets unreadable fast with new requirements, the functional version can easily be combined,

    List beerDrinkers = filter(filter(persons, canDrinkBeer), isMale);

    More on this at the Metaphysical Developer.

  4. Use one liners: Write concise code. Java is a noisy language. But don't make it noiser as it needs to be. Instead of
    public int add(int a, int b) 
      int result = a + b;
      return result;


    public int add(int a, int b) { return a + b; }

    IDEA and possibly other IDEs can keep oneliners formatted as oneliners, if you tell them so.

  5. Use many, many objects with many interfaces. Domain driven design currently makes a big splash. A class should be splitted into many roles, implementing many interfaces. This way the class is reusable.
    public class Person implements Nameable, Hireable, LivesAt {
    public interface Nameable {
      String getName();

    Methods should be written to only work on roles, not classes. This way methods can work on more objects. Another benefit is lower coupling.

    public void print(Nameable name) {

    I've written more about that in "Never, never, never use String in Java ".

  6. Use Erlang-Style Concurrency. The Java concurrency primitives like locks and synchronized have been proven to be too low level and often to hard to use. There are better ways to write concurrent code. Erlang Style concurrency is one of them - in Java there are many ways to achive this in Java - I've written about them here. Newer ones are Akka and Actorom. You can also use Join/Fork or the myriad of data structures in java.util.concurrent.
  7. Use Fluent Interfaces. Fluent interfaces can make your code much more readable and shorter. A very good example is the MapMaker API in Google Collections:
     ConcurrentMap graphs = new MapMaker()
           .expiration(30, TimeUnit.MINUTES)
               new Function() {
                 public Graph apply(Key key) {
                   return createExpensiveGraph(key);
  8. Data Transfer Objects without setters and getters. If you have simple data holders or data transfer objects, don't write boiler plate code with getters and setters. I know this is heresy in Java, but just use public fields. Instead of

    public class Point {
       private int x;
       private int y;
       pulic Point(int x, int y) {
          this.x = x;
          this.y = y;
       public int setX(int newX) {
          x = newX;
       public int getX() {
         return x;
    int x = p.getX();
    int y= p.getY();


    public class Point {
       public final int x;
       public final int y;
       pulic Point(int x, int y) {
          this.x = x;
          this.y = y;
    int x = p.x;
    int y = p.y;

    Refactoring is easy, should you need it. If you do not control all the code and it's usage, you might need to be more careful though.

This tips lead to better Java code. Try them in your next Java class. What do you think? I'd like to hear how your Java coding style has changed in the last 10 years.

Uodate: Some thoughts to Cedrics thoughts.

As the author of the post, your thoughts are appreciated, some of mine:

"Besides, it's convenient to be able to mutate object if you want to use pools."

No setters doesn't mean you can't mutate objects, it's just that plain setters are not object oriented thinking. How about stop() vs. setStop(true);

"I think the first example is more readable than the second one that uses Predicates."

I think your assumptions are wrong. Loops are procedural code, while Predicates are, encapsulated, reusable, understandable objects. Nothing to do with functional programming, plain OO - it's only ursurped by functional programming, therefor I refer to it as FP.

Want Erlang concurrency but are stuck with Java: 4 Alternatives (+1)

You've by now have read a lot about Erlang style concurrency. In Erlang actors are sending messages to inboxes of other actors and react to messages in their own inbox. The advantage of this approach with immutable messages is that you can't get as easily in a deadlock as with basic Java concurrency with synchronized and threads. A simple ping pong example looks like this:

ping(N, Pong_PID) ->
    Pong_PID ! {ping, self()},
        pong ->
            io:format("Ping received pong~n", [])
    ping(N - 1, Pong_PID).

pong() ->
        finished ->
            io:format("Pong finished~n", []);
        {ping, Ping_PID} ->
            io:format("Pong received ping~n", []),
            Ping_PID ! pong,

Two actors sending each other ping and pong messages with the ! symbol and acting on those with receive. Although there is more to concurrency than Erlang style message passing, as I've written lately in a post, for some problems it's best and easiest to use message passing.

Is Erlang the next Java, but you are stuck with Java and can't use Erlang style concurrency? Wrong.

There are concurrency solutions for Java which mimic Erlang style concurrency:

Update: "One clarification: ActorFoundry just uses Kilim’s weaver and therefore is not built on top of Kilim." (see comments, thanks)
Update 2: Another option sugested by Diego Martinelli is to use Functional Java

Sujit Pal has written a comprehensive post comparing the performance of those frameworks with lots of example code:

Over the past few weeks, I've been looking at various (Java and Scala based) Actor frameworks. In an attempt to understand the API of these frameworks, I've been porting the same toy example consisting of three pipelined Actors responding to a bunch of requests shoved down one end of the pipe. To get a feel for how they compare, performance-wise, to one another, I've also been computing wallclock times for various request batch sizes.

And as Kilim has been shown to be as fast as Erlang - I've written about the fact here - these Java solutions do indeed look comparable to Erlang in the concurrency space.

What does this mean to your Java Enterprise?

Don't worry about the multi-core future, Java has plenty to give for your multi-core platforms. And if you're only stuck to the Java VM but not the Java language, you could go for Scala and gain some functional programming capabilities on top.

Thanks for listening. Hope you’ve learned something. As ever, please do share your thoughts and additional tips in the comments below, or on your own blog (I have trackbacks enabled).

Concurrency Rant: Different Types of Concurrency and Why Lots of People Already use ‘Erlang’ Concurrency

People talk a lot about concurrency. With the rise of multi-core processors, concurrency becomes more important. It's sad that developers don't know much about concurrency - and most of them just parrot what they have read in other blogs. I wanted to write this post for quite some time to shed more light into concurrency.

There are mainly two different types of concurrency

  • One Task, many workers: For example parallel Fibonacci Numbers
  • Many Tasks, many workers: For example web requests

They have two different characteristics:

  • First: Need to share data
  • Second: No need to share data (or "not to share in real time")

Most people think of the first kind, when they discuss concurrency. Although most applications are of the second kind. I wish people would not confuse those two and try to fix the second problem with their solutions, because the second problem is solved sufficiently (think FaceBook). So this post will only discuss the first type of concurrency.

The breakthrough for concurrency of the first kind came with threads and the synchronizd keyword in Java 15 years ago. Before that concurrency was an esoteric topic for niches, with Java it became a topic for every developer. Today most people recognize that threads and synchronized are too low level though and create quite some problems if you don't know what you do. One half of the blogosphere damns Java for this and favors Erlang style concurrency: Message passing between objects, each object has an inbox (a queue) of messages which it works through and objects send messages to the inbox of other objects, where messages are immutable. The benefits are clear: No shared state, no need to regulate the access to shared state and the freedom to implement the scheduler of the objects the way it works best (not being limited to thread libraries).

This half proposing Erlang over everything usually doesn't know what the other half does and think they still use synchronized. But this is only the most basic technique (and not even the best basic one with the advent of atomics). Surprise, enterprise Java developers don't use threads (directly) and synchronized. I'll tell you what they do.

There are lots of better methods for concurrency nowadays like Futures, Executor Services and especially Doug Leas Fork/Join framework in Java JSR 166y. The FJ framework splits a task into subtasks, distributes them, solves them and joins the result (in a very clever way with queues which are written on one side and read on the other and tasks which can steal work from others). The algorithm for forking and joining looks like this:

Result solve(Problem problem) {
  if (problem is small)
    directly solve problem
  else {
    split problem into independent parts
    fork new subtasks to solve each part
    join all subtasks
    compose result from subresults

As an example to calculate Fibonacci numbers:

class Fib extends FJTask {
  static final int threshold = 13; 
  volatile int number; // arg/result
  Fib(int n) { number = n; }
  int getAnswer() {
    if (!isDone())
      throw new IllegalStateException();
    return number;

  public void run() {
    int n = number;
    if (n <= threshold) // granularity ctl
      number = seqFib(n);
    else {
      Fib f1 = new Fib(n − 1);
      Fib f2 = new Fib(n − 2);
      coInvoke(f1, f2);
      number = f1.number + f2.number;

(you can use threads or a different scheduler for this to work)

A similar approach to concurrent work is MapReduce as implemented by Hadoop. It also splits work into sub tasks, does a mapping step for transforming data and then reduces the result. It works best for data crunching and reducing input data to output data.

Other techniques developers often use instead of concurrency primitives are communication abstractions, like communicating over concurrent access queues, for example java.util.concurrent.ArrayBlockingQueue (ah queues again! or call them inboxes).

Threads talk to each other by adding (hopefully immutable) messages to a queue. Sounds familiar? Those can even be distributed (also see Hazelcast for distributed queues). This is very similar to Erlang concurrency, just imagine input queues for all your workers, aka actors.

Scala has an Erlang like message passing actor concurrency implementation. When looking into the Scala code, Scala uses the Fork/Join Framework of Java, the cirlce closes. And Scala uses different schedulers for it's implementation with one thread per actor only being one option.

We can abstract concurrency even more. Jonas writes an excellent piece about abstractions on top of actors in a piece about fault tolerant, Asynchronous concurrency but misses one crucial point:

Actors can simplify concurrent programming and reasoning immensely and I believe that Scala Actors is a key piece in the future Java concurrency puzzle. However, programming with actors and with explicit message passing and message dispatch loops can feel a bit unnatural and unnecessary verbose for Java developers that are used to regular OO method invocations and synchronous control flow.

As pointed out before, people use queues and are used to work with asynchronous flows. Java enterprise developers in particular as they use Enterprise Service Buses (ESBs). There are many implementations like ServiceMix, OpenESB, Camel, OpenMQ, ActiveMQ, Mule and others. They range from pure message buses to routing and integration solutions. Because ESBs are fault-tolerant, asynchronous concurrency, the developers who use them know about asynchronous flows. Companies like LinkedIn uses ESBs to distribute tasks in a fault tolerant and parallel way. Nothing new there. Java developers think in asynchronous messaging already.

Stand back a thousand feet and ESBs look like the Erlang model. Worker cling to the bus and wait for work. Each is listening to different messages, the waiting messages for each worker are a virtual input queue similar to Erlang. There isn't as much difference between concurrency in different languages as people want you to believe there is!

As a final word: It's interesting that the first and second kind of concurrency start to merge. With applications like Twitter or identi.ca, the second type is sometimes becoming the first type of concurrency because different requests need to share data with each other (hopefully you don't use the database for this as Twitter did in the beginning). One can argue that more and more applications need to share data between sessions. You can use an actor model for this (Lift does this). You could use ESBs. Or you could go a very different way with distributed method calls and objects - Terracotta to the rescue.

Thanks for listening. Hope you've learned something. I did by writing this post. As ever, please do share your thoughts and additional tips in the comments below, or on your own blog (I have trackbacks enabled).

Update: Actors Guild for Java looks also interesting

Update 2: If you find this post offending, go back read it again without you favorite programming language in mind which you need to defend. There is nothing to defend. You've chosen the programming language to the best of your knowledge, as have others (and if they haven't but just chose the language because of some hype or others told them to, well, not a good idea). Spread your knowledge, don't feel offended. Be happy if others find solutions to their problems. This is not some kind of football game which you win if you gain enough points against a different language. If the other one is better, use it. If not then don't. Sounds awfully common sense, but we sometimes seem to forget this. Merry xmas.

TIOBE Index: Java on top, Python up, Ruby down and no longer in Top 10

Looked at the current November 2008 TIOBE programming language index, found via Cedrics Twitter. Java still on top, very slow slide, Ruby down by 2 places, no longer under the Top 10, C++, C# and especially Python up, PHP still 5th, Erlang at 31st, Scala at 43rd 😉 F# not listed in Top 100.

Other interesting tidbits:
"The object-oriented paradigm is at an all time high with 57.9%. The popularity of dynamically typed languages seems to be stabilizing."

Object-Oriented Languages  57.9%  +1.6%
Functional Languages       2.6%   +0.4%

Statically Typed Languages 	60.0% 	+1.2%
Dynamically Typed Languages 	40.0% 	-1.2% 

(after some big increases for dynamically typed languages since 2002)