Writing a Good Job Description for Hiring Core Java Developers

As a Development Manager or a Team Lead, you often need to write up Job Descriptions which include a brief description of the Team, and the Role’s responsibilities. Some people also include a description of the company, but I usually don’t find this necessary if you work for a large well known company. However if you are a startup or smaller business you might want to include a short paragraph on your company.

I mostly focus on stating in the description the roles responsibilities and often include the following phrase: “This role requires hands on coding in [LANGUAGE] on a daily basis. This is NOT a Lead, Manager, or Architect position. However you may be required to participate in architectural discussions as needed. This is a [Senior | Mid-Level | Junior] Software Developer Role.”

Often when hiring Senior Developers, you will fine many candidates have already ventured into the leadership or management or architecture roles and do not really want to code on a daily basis, and you need to make it clear to all perspective candidates that you require hard core development.

When hiring you want to ensure you not only get candidates that CAN code, but candidates that WANT to code. I can’t tell you how many times I’ve seen groups hire very smart people who can develop, but just don’t have the drive anymore to code on a daily basis, and when you need developers you have to ensure you hire committed coders.

In addition to Team Description, Role Responsibilities, and potentially a short description on the company, the most important section of the Job Description write up is the required skill set.

When hiring Core Java Developers, which is my preferred developer title to hire for both Back End and Middleware work, I normally use a list of skills that include the following. I added comments to the list for the purpose of this article to help not only hiring managers but help potential candidates as well understand the method behind my madness:

  • Required Skills
    • Core Java (Java Version: 7+ ; or whatever version your organization requires)
    • OOP/OOD in Java
      • Interfaces, Classes, Polymorphism, Inheritance
      • Question I usually ask: Can you have an Empty Interface (Also called a Marker Interface), and what is it used for. What is the most popular Marker Interface that is standard with Java.
      • Design Patterns (GoF Patterns)
        • I always test for the Singleton Pattern.
        • Other common ones I frequently test for: Factory, Observer/Observable, Visitor
        • Less Frequently I’ll test for: Command and Chain of Responsibility
        • There are many other GoF (Gang of Four) Patterns, but I would get a hang of Java first.
        • Note: GoF Patterns are not limited to Java. You can implement these design patterns in any Language. The 4 authors of GoF (where the Four in Gang of Four come from) even state, they really just gave names to Design Patterns programmers have been using for decades, and they are right, a lot of the patterns you will recognize as designs you implemented yourself without even knowing the “official” name.
    • Collections (Lists, Maps, Sets)
      • Also able to code with Arrays directly
      • Able to use Arrays in the place of: Lists, Maps, and Sets efficiently
      • We test deep knowledge of collections. Like how to man a custom key work correctly in a HashMap.
      • Note on Arrays:
        • Because of complex Data Structures I use Arrays are also very important, even though Arrays may seem simpler, they are actually harder to use correctly and to your advantage, which is why collections were invented in the first place.
        • In a traditional Computer Science program you will learn and use Arrays before you even talk about collections.
        • Simple collects can be made from Arrays, which is why I state above, “able to use Arrays in place of the various collections”.
    • Exception Handling
      • Knowing how to handle the different types of Exceptions:
        • Checked (Any Exception that Extends from the class Exception)
        • Unchecked (Any Exception that Extends from the class RuntimeException)
      • What a Throwable is
      • What and Error object is and how it is different from an Exception.
      • Logging of exceptions. It’s a Plus to know: Log4J, but I usually don’t test for it. As long as the person knows why it’s important to log exceptions.
    • Direct JDBC experience
      • Ability to use JDBC to Call Direct SQL Statements for both Query and Updating
      • Ability to use JDBC to Call Stored Procedures
      • Knowledge of Transaction Control using JDBC
      • Basically know what the following classes are and how to use them: DriverManager, Connection, Statement, PreparedStatement, CallableStatement, ResultSet, big plus: ResultsetMetadata.
      • I don’t usually care about ORM (object-relational mapping) Frameworks, such as Hibernate. Actually I hate Hibernate and frameworks like them, even though in some projects they are very popular.
      • Note on Connection Pools:
        • When you are building Web Apps and other applications hosted on an Web Server or more generally an Application Server like WebLogic or WebSphere or JBoss, you will usually use a JDBC Connection Pool. Knowledge of Connection Pools technically fall into the JavaEE space, and not the Core Java space, but in the real world, you will most likely be using connection pools to create your connections and NOT the JDBC DriverManager directly. However besides Connection creation, everything else is the same when doing Direct JDBC or JDBC via a Connection Pool.
        • I state “Direct JDBC Experience” because this is how you can separate the Men from the Boys. A real developer will know how to create Connections directly from the JDBC DriverManager. More junior programmers may be part of a team that hides all the JDBC stuff from them and they just somehow magically get a connection to a Database in their code. Perhaps by using a Utility class a more senior developer on the team created for the team to use. In my projects we always do this, I architected an entire framework called App Resource Manager to handle JDBC connection management, whether it’s using Pools or Direct DriverManager.
    • Strings and I/O
      • Ability to read large raw data files and parse them into usable tokens for DB Loading or other processing
      • String Matching and Manipulation
        • Matching: Basically the String object’s indexOf, startsWith, endsWith, lastIndexOf, plus RegEx (Regular Expressions) ie. the “matches” method.
        • Manipulation: Building of Strings using StringBuffer or StringBuilder, plus the String’s split, substring, trim and replace methods.
        • String Parsing / Tokenizing
          • The String’s “Split” method is used more and more over the StringTokenizer class these days.
          • Basically if you are reading a Delimited Text File, like a “|” Pipe/Vertical Bar or a Comma Delimited File, or anything similar, you will be splitting or tokenizing each line.
          • It’s all about File Parsing or User Input Parsing.
        • Reading and Writing from/to Properties Files, XML, Plain Text Files.
    • Experience with Multi-Threading
      • Synchronization
        • Block Level
        • Method Level
        • Static Method / Class Level
      • Thread creation and control
        • Runnables and the Thread class
          • Creating a Thread using the Runnable Interface verses extending the Thread Class.
        • Wait, Notify, NotifyAll
          • The Class Consumer/Producer Problem.
    • Basic SQL Knowledge is a must.
      • DML: Ability to write Select, Insert, Update, Delete, statements
      • DDL: Ability to Create Tables is a Plus but not required. I usually either do the data modeling and table creation myself or one of a hand full of trusted developers I can trust to design good tables, indexes, and constraints.
      • Stored Procedures – Writing Stored Procs is a plus, but not required, I usually have a good SQL developer on my teams.
    • XML
      • Familiarity with JAXB
      • Knowledge of : SAX, DOM, STAX
    • Knowledge of Java Annotations
      • I used to test for this less often, but Annotations have become so wildly used, I started testing this more.
      • Mostly someone just needs to know how to apply annotations, not create their own annotations. I have created my own annotations in projects before, but most development solutions probably won’t need custom annotations, just use the ones that come with Java or were created for a particular Library

After the Required Skills sections, I usually add a Optional Skills sections that are a Plus, which usually include more JavaEE, Web Services, Linux/Unix Scripting, and Command Line, and depending on what products we are using, a DBMS, Hadoop Ecosystem Components, Workflow Engines, Messaging Services, and whatever else is specific to the project I’m hiring for.

Hope this post helps both hiring managers write better Job Descriptions and Candidates or Students of Programming who are looking for a syllabus to study to get ready to apply to jobs and enter the Software Development Job Market.

Just Another Stream of Random Bits…

– Robert C. Ilardi

This entry was posted in Management. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s