What skills should a Core Java Developer have?


I have been trying to put together a list of basic skills a Java developer should have to move on to being an advanced Core Java programmer.


  • can write code on paper which has a good chance of compiling.
  • can use a debugger to debug programs and profile an application.
  • are familiar all the primitives types and operators in Java.
  • understands the class loading process and how class loaders work
  • can use multiple threads both correctly and can prove this improve performance or behaviour. e.g. wait/notify/notifyAll, SwingUtils.invokeLater, the concurrency library
  • can use checked exceptions, generics and enums
  • can time a small benchmark and get reproducible results
  • can write a very simple client server TCP service
  • have an understanding of garbage collection, when is it triggered, what can you do to minimise it
  • understand when to use design patterns such as Singleton, Factory, Fly-weight, Builder, Object Pool, Iterator, Strategy, Visitor, Composite

Suggestions on how to get these skills

  • read Java Concurrency in Practice (http://jcip.net/)
  • write a simple client server TCP service such as chat
  • read up on Design Patterns and try to use them. http://www.oodesign.com/ so you can learn when they help and don't help


  1. Profiling item is very interesting for me as I want to be advanced Java programmer. Are there any good resources about real world profiling techniques and what you should care of ( ex. how to do warm-up properly and etc)?

  2. sounds a bit funny - advanced Core Java programmer have to avoid debugger usage which could lead to another behavior and results on multithreaded application.
    Could you imagine core java developer who doesn't pay attention to threads ? I'm not.

  3. Vladimir : An advanced core java programmer know the limitation of those tools and use it with care... Not using those tools when needed is absurd

  4. @Egor, I would start with VisualVM doing CPU profiling and Memory profiling with a program you wrote. As @Thibault suggests, what does the profiler do well and what is its limitations. BTW: If you try a commercial profiler you may find it doesn't have these limitations.

    @Vladimar, I don't see why an advanced programmer would avoid using the debugger when trying to solve a bug. I have seen developers who always run their application in debug mode, which could be excessive. Your program should behave correctly with or without the debugger.

    I will add your suggestions about multi-threading.

  5. I'd add:
    - Understand class loading process and how classloaders work.
    Besides, I have to say that I've found a lot of people who have really problems with the concepts of classpath and working directory.
    - It reminds me that practice with Java IO and NIO would be a good requirement.
    - Knowledge of SPI architechture: from providing an implementation of an existing SPI to creating your own SPI.
    - Java Security. The topics cover in the Scott Oaks' book from O'reilly (Java Security 2nd edition), specially the security manager and access controller.

    You already mentioned, but I like to insist:
    - Concurrency. A core programmer must have read Java Concurrency in Practice (http://jcip.net/)
    - Network programming: sockets, URL connections and so on (yes, I used to love the O'Reilly books from the early 2000, like Java Network Programming, 3rd Edition)

    Additionally, some knowledge of JVM internals (garbage collection, bytecode generation, java memory model implementation...)

    I slightly disagree with the first two points. But it's difficult to provide an alternative.

    I mean, everybody can write code which compiles and debug it.

    But to become an advanced Core Java programmer I'd ask they can write "clean" OO Java Code. It includes a good management of Exceptions (including the use of unchecked exceptions, as the programmers from Springframework decided)

    [Apologize for all this speech, but I'm currently working in a project from 2002 that seems to use a SOP approach: Step Oriented Programming. Instead of creating objects to be called with messages/functions, the program is a sequential steps of the things that the programmers thought they need at each moment]

  6. The SPI Architecure terminology is a bit specific to the cryptography library. I would prefer to put this in more general terms such a design patterns.

  7. I thought the same as you, but lately I've found SPI in a lot of topics.

    According wikipedia (http://en.wikipedia.org/wiki/Service_provider_interface): "In the Java Runtime Environment, SPIs are used in JDBC, JCE, JNDI, JAXP, JBI, Java Sound and Java Image I/O."

    But it's used elsewhere. Lately, I have needed to take a look to the Springframework's Converter SPI: http://static.springsource.org/spring/docs/current/spring-framework-reference/html/validation.html#core-convert

    That is what I meant with SPI. If you need to build some kind of system, SPI could be a good approach.

  8. Most important skill which Java programmer need is programming and design ability. Java developer are mostly not very good on recursion,algorithms and basic datastructure concept as comapred to C or C++, may be rich Java API to blame for and on design they are little better.

    2 Solution of OutOfMemoryError in Java


Post a Comment

Popular posts from this blog

Java is Very Fast, If You Don’t Create Many Objects

System wide unique nanosecond timestamps

Comparing Approaches to Durability in Low Latency Messaging Queues