How to become a better developer!

The fast and constant change in technology made it inevitable for developers to always improve their skills through continuous learning. It is a fact now that developers with outdated skills will be left behind!
Learning isn’t the same for everyone. Some people may learn well by themselves; some may need instruction and example. In the programming world, many resources can meet those particular needs.
And using skills on projects that aren’t all imaginary is key too. Real world projects equal real world experience that translates into adapting more efficient, effective programming language.
What else helps to improve programmers’ skills and help them continue to move into the next wave-whatever that may be? I found this graphic that explains tactics, solutions, and ideas to pursue.
Personally, I have been following some of those for the past couple of years to improve my technical and soft skills!

Click to Enlarge Image

’8

My takeaways from a TDD debate between Cope & Uncle Bob

As a developer, there is a high chance that you had a debate on the value of TDD in building software, especially if you apply it!

I had a lot of those debates!

A couple of months ago, I came across such a debate between Jim Coplien and Robert Martin (Uncle Bob). I found this discussion kind of interesting especially that it involves two leaders in software engineering.

You can watch the debate here:

Takeaways

Here are my takeaways from the discussion:

Three Rules of TDD

Uncle Bob defines the following three rules for applying TDD:

  1. Don’t write a line of production code without having a corresponding failing test
  2. Don’t write too many failing tests without writing production code
  3. Don’t write more production code than is sufficient to pass the currently failing test

Architecture is Important

Jim points out that he has no problem with those rules, his concerns are more architecture related. Jim and Uncle Bob would argue for more than ten minutes to finally reach an agreement on the importance of architecture. The below five points summarizes what they agreed on:

  1. Architecture is very important
  2. It is entirely wrong to assume that the code will assemble itself magically just by writing a lot of tests and doing quick iterations
  3. Design evolves with time and should be assembled one bit at a time
  4. An Object should have properties to give it meaning. At the beginning, those properties should be minimal.
  5. Architecture shouldn’t be created based on speculation

TDD and Professionalism

Probably the only disagreement you can sense from this debate is what defines a professional software engineer. For Uncle Bob, it is irresponsible for a software engineer to deliver a single line of code without writing a unit test for it. Jim, on the other hand, considers ‘Design by Contract’ to be more powerful than TDD.

My Point of View!

Personally, I have been applying TDD since I joined my team three years ago. After experiencing the benefits of this practice, we got to a point where we don’t write or refactor any line of code without having a corresponding unit test!

In addition to that, I had the chance to coach other developers by running coding dojo sessions at work.

All that makes me say that I agree more with Uncle Bob on the topic of professionalism!

References
  1. Coplien and Martin Debate TDD, CDD and Professionalism

An agile approach to defining your product vision!

‘What is your team working on?’

Of course, you’ve heard this question many times before and probably your answer will slightly differ from your teammates’. But, with the help of two agile team-building activities, you can eliminate such a difference and reach an alignment with your teammates on a description for your team and product. Those activities are ‘Collaborative Product Vision‘ and ‘Defining the Team Vision Statement.’

In this post, I will only be covering the product vision activity.

How to run the activity?

Here is the template of the product vision:

FOR (1. target customer)
WHO (2. statement of the need or opportunity)
THE (3. product name) IS A (4. product category)
THAT (5. key benefit, compelling reason to buy)
UNLIKE (6. primary competitive alternative)
OUR PRODUCT (7. statement of primary differentiation)

Here are the steps to simulate the activity:

  1. Write the statement on a board for all to see.
  2. Split your team into groups of two or three
  3. Give the groups 5-10 minutes to fill in the seven blanks
  4. Ask each group to present and explain (if needed) the vision they came up with
  5. For each blank, ask the team members to individually vote for their favorite replacement
  6. Replace each blank with the phrase of highest votes
  7. Read the new statement out loud
  8. With the team apply some changes if needed

The Benefits

I am writing this blog because I think this is a nice activity for any team! So far, I have played it with three different teams, existing and newly established ones.

Here are some benefits of playing this activity:

  1. Good activity for team bonding especially new ones
  2. Aligns all team members on one vision of the product they are building
  3. Aligns all team members on what is considered as in and out of scope of the product
  4. Helps teams in identifying their main competitors
  5. Highlights the major difference between the product and its competitors
  6. A short but meaningful description of the product for upper management, visitors, and newcomers

Example

FOR Outlook Users 
WHO want to keep track of time spent in meetings
THE MeetingReporter IS An outlook-addin
THAT generates time reports from the calendar 
UNLIKE existing tools where you have to manually insert time spent
OUR PRODUCT will parse the calendar and automatically generate different reports based on meeting category

Above is an example!

It is the vision of the tool I am writing on my free time! From this short statement and without any further explanation, anyone should understand purpose and major feature of this tool!

Finally

Some people consider such activities as a waste of time. Obviously, I disagree! This is an occasional activity that takes between 15 to 20 minutes depending on the team’s size. Thus, it is an excellent candidate for the first activity of the team’s retrospective!

I encourage teams to try it. For those who do, I am pretty sure you will be posting the outcome on your team’s home page, just as we did!

Resources:
  1. Fun Retrospectives
  2. Collaborative Product Vision
  3. Defining the Team Vision Statement

How to handle Java exceptions in clean code? – Part 2

In my previous post, I explained the different types of exceptions in Java and left two questions for this post!

Which exception to use?

Java documentation and Uncle Bob’s book (Clean Code) were my references when preparing this tutorial. I noticed a slight difference between what is recommended in each!

Java Documentation

While reading the Java documentation, you sense a preference for Checked Exceptions. The documentation states that the usage of UnChecked Exceptions should be restricted to the case where crashing the system is intentional if an exception occurs. In other cases where recovery is still possible, Checked Exceptions should be used.

Robert Martin’s opinion

Uncle Bob has a different opinion!  He argues that although Checked Exceptions might have some benefits and can be useful in some special cases like writing critical libraries, they are not a necessity to have a robust software.

Breaking the ‘Open/Closed Principle‘ and ‘Encapsulation‘ are the main two reasons that make using Checked Exceptions a bad idea!

Let’s see how!

In the below example, the MainBookReader.main method is calling the method MainBookReader.readJsonObject to get the book’s description from a JSON file. And since readJsonObject throws an exception we had to add throws FileNotFoundException clause to the signature of the main method and the interface JsonLoader!

import java.io.FileNotFoundException;

public class MainBookReader {
    public static void main(String[] args) throws FileNotFoundException {
        BookJsonLoader jsonLoader = new BookJsonLoader();
        Book bookFromJson = jsonLoader.readJsonObject("books.json");
        System.out.println(bookFromJson.name());
    }
}
import com.google.gson.Gson;
import java.io.FileNotFoundException;
import java.io.FileReader;

public class BookJsonLoader implements JsonLoader {
    public Book readJsonObject(String fileName) throws FileNotFoundException {
        FileReader jsonFile = new FileReader(fileName);
        Gson gson = new Gson();
        return transformToBook(gson.fromJson(jsonFile, JsonBook.class));
    }

    private Book transformToBook(JsonBook jsonBook) {
        return new Book(jsonBook.getName());
    }
}
import java.io.FileNotFoundException;

public interface JsonLoader {
    Book readJsonObject(String fileName) throws FileNotFoundException;
}

Adding the throws clause to most of our methods means two things!

  1. Our top methods & classes had to know a lot about the lower methods & classes!
  2. If any change is to be applied to the lower methods, this change has to be replicated to all above methods!

This is a violation of the ‘Open/Closed Principle‘ and ‘Encapsulation‘!

Is there a better way?

No matter how careful we are, things can still go wrong. Thus we still need to deal the exceptions when they occur! The alternative to the code above is writing clean code!

In this section, I will refactor the above code to make the code look better, although it might involve more code!

Wrap the Exception

The first step is to wrap the exception in one place! In our case, we can replace the throws clause with a try-catch!

In the catch clause, I’m throwing a JsonFileNotFoundException (UncheckedException) that I have created based on the needs of this system (i.e. providing an informative message to the user).

public class BookJsonLoader implements JsonLoader {
    public Book readJsonObject(String fileName){
        try {
            FileReader jsonFile = new FileReader(fileName);
            Gson gson = new Gson();
            return transformToBook(gson.fromJson(jsonFile, JsonBook.class));
        } catch (FileNotFoundException e) {
            throw new JsonFileNotFoundException("Can't find the file " + fileName + ". Please make sure it exists!", e);
        }
    }

    private Book transformToBook(JsonBook jsonBook) {
        return new Book(jsonBook.getName());
    }
}

The benefits of this refactoring are:

  • Remove all ‘throws clauses.’
  • Hide the logic and information of our class from the outer classes
  • Send an informative message to the user in case the file was not found
  • Minimize the dependency (remove imports from other classes)

Don’t return null

In some cases, developers don’t want to throw an UnCheckedException, so they tend to return a ‘null’ instead! That is a bad practice because it will eventually result in a NullPointerException later.

So, what to do? The answer is simple, return a SPECIAL CASE!

The below class ‘MissingBook‘ is our special case!

public class MissingBook extends Book {

    private MissingBook(String name) {
        super(name);
    }

    public static MissingBook aMissingBook() {
        return new MissingBook("MISSING BOOK");
    }
}

This allows us to return an instance of the MissingBook in the catch instead of throwing an exception!

public class BookJsonLoader implements JsonLoader {
    public Book readJsonObject(String fileName){
        try {
            FileReader jsonFile = new FileReader(fileName);
            Gson gson = new Gson();
            return transformToBook(gson.fromJson(jsonFile, JsonBook.class));
        } catch (FileNotFoundException e) {
            return MissingBook.aMissingBook();
        }
    }

    private Book transformToBook(JsonBook jsonBook) {
        return new Book(jsonBook.getName());
    }
}

Don’t pass null

In your code, you shouldn’t pass null as parameters and instead use the Special Cases as before. But, it gets harder to prevent your clients from passing nulls thus you might need to assert some function parameters before proceeding with your code execution!

Finally

Doing the refactoring for the simple example above might look like over-engineering! But, it becomes beneficial when writing more complex code!

I think that the excessive usage of CheckedExceptions will pollute the code and thus should be avoided! For me, the benefits of CheckedExceptions can still be achieved through:

  1. Following the rules of Clean Code
  2. Increase test coverage of the code by following the TDD practice! With the use of TDD, all the edge cases should be covered and thus eliminating the possibility of having unexpected exceptions during execution!

To understand better the importance and how to write clean code, it is highly recommended that you read the book Clean Code by Robert Martin!

References:

  1. Clean Code: A Handbook of Agile Software Craftsmanship
  2. Unchecked Exceptions — The Controversy
  3. Java Exceptions
  4. The Clean Code Blog

How to handle Java exceptions in clean code? – Part 1

Reading the chapter ‘Error Handling‘ from the book ‘Clean Code‘ made me think whether developers follow the clean code rules when writing production code. It also appeared to me that the difference between the Java exception types might not clear be for some!

The purpose of this short tutorial is to clarify those two points. And to make it clearer, I will be dividing it into two posts. In the first one, I will explain the different types of Java exceptions. Whereas in the second one, I will show how to write clean exception code!

Java Exceptions

In Java, the class Throwable is at the top of the class hierarchy of all exceptions. The classes Error and Exception directly extend Throwable. All the subclasses of Error and Exception are grouped into two types ‘Checked Exceptions‘ and ‘UnChecked Exceptions‘as displayed in the image below.

javaexceptiondiagram

What is the difference between Checked and UnChecked Exceptions?

UnChecked Exceptions

UnChecked Exceptions extend the classes ‘Error‘ or ‘RuntimeException‘. In this case, developers don’t have to worry about catching or handling the exceptions at compile time as the compiler won’t report any error. But, as they are not caught, those exceptions may result in complete failure of the application when thrown during execution.

Below are two examples of UnChecked Exceptions!

1. Runtime Exception

The below method simply divides two numbers:

private static int divide(int numerator, int denominator) {
    return numerator / denominator;
}

The code is fine and will compile with no errors! So what is the problem?

The problem might occur at runtime if we try to call the method while passing zero as the denominator. Since this exception is not caught, our system will crash throwing the below arithmetic exception:

Exception in thread "main" java.lang.ArithmeticException: / by zero
 at MainUnCheckedException.divide(MainUnCheckedException.java:7) ...
2. Error

The below method compiles, but since I missed writing the base cases calling the method will crash the system and throw a StackOverflowError (as shown below) will throw an Error!

private static int fibonacci(int number) {
    return fibonacci(number - 1) + fibonacci(number - 2);
}
Exception in thread "main" java.lang.StackOverflowError
 at MainUnCheckedException.fibonacci(MainUnCheckedException.java:10)...

Checked Exceptions

On the other hand, all other classes extending the ‘Exception‘ class are considered to be Checked Exceptions. In this case, the code will not compile if the developer doesn’t explicitly handle the exception.

This adds a level of security to your code, as you are forced to specify how your code should behave when an exception occurs and thus decreases the chance of having an unrecoverable failure in the system.

Let’s see an example!

public class MainCheckedException {
    public static void main(String[] args) {
        FileInputStream fileInputStream = new FileInputStream("foo.txt");
    }
}

Error:(6, 43) java: unreported exception java.io.FileNotFoundException;
must be caught or declared to be thrown

In the above code, we are trying to read a file ‘foo.txt’, but our compiler complains that we need to handle the FileNotFoundException.

Solving this compilation error can be done in two ways:

  1. Try Catch: The first solution requires surrounding the code with a try-catch.
    private static void readFileTryCatch() {
        try {
            FileInputStream fooFile = new FileInputStream("foo.txt");
        } catch (FileNotFoundException e) {
            System.out.println(e.getMessage());
        }
    }

    Even if the file was not there, this code would not break thanks to the try-catch. As shown in the below code and output, the system will print out the exception and continue execution!

    public static void main(String[] args) {
        readFileTryCatch();
        System.out.println("Done");
    }
    ------------Output------------
    foo.txt (No such file or directory)
    Done
  2. Throw an exception: The other solution is adding a ‘throws FileNotFoundException‘ to the method signature.
    private static void readFileThrow() throws FileNotFoundException {
        new FileInputStream("foo.txt");
    }

    Using this solution will propagate handling the exception to the calling methods as illustrated in the two options below:
    Option 1: Adding throws to all methods signatures 

    public static void main(String[] args) throws FileNotFoundException {
        readFileThrow();
        System.out.println("Done");
    }
    ------------Output------------
    Exception in thread "main" java.io.FileNotFoundException: foo.txt (No such file or directory)
    at java.io.FileInputStream.open0(Native Method) ...

    Option 2: Catching the exception in one of the methods in the call stack

    public static void main(String[] args)  {
        try {
            readFileThrow();
        } catch (FileNotFoundException e) {
            System.out.println(e.getMessage());
        }
        System.out.println("Done");
    }
    ------------Output------------
    foo.txt (No such file or directory)
    Done

 

I hope this post gave you a better understanding of Java exceptions! In the 2nd part, I will be sharing more details on how to properly write exceptions in clean code and which of the two exception types to use!

XP Days Benelux

On the 24th and the 25th of November, I was (with ten of my colleagues) in Heeze, Kapellerput in the Netherlands attending the two days conference ‘XP Days – Benelux‘!

The sessions at the conference were categorized as “Technology and Technique,” “Customer and Planning,” “Team and Individual” and “Process and Improvement.” And some of which were game based sessions!

In this blog, I will be sharing my feedback on two games I participated in!

LeanStartup board game

Led by: Sven Dill and Frederik Vannieuwenhuyse

The purpose of this game is to introduce participants to the practices and principles of Lean-Startup by simulating a business where each group has to produce a product and sell it to customers.

board

Game Rules

In the beginning, the game seemed a bit complex or vague, but things started to get clearer after the second iteration. Here are some of the game rules:

  • Split the participants into four teams (ideally three per team)
  • Each team is a functional company responsible for building a product
  • The board represents the market, where each is a customer requesting some features
  • At each turn, the team can distribute their resources on building features, investing in their company, experimenting or selling a feature
  • Through experimenting, the team can flip a tile to learn the requirements to sell the feature.
  • At each experiment, all the participants get the chance to learn new vocabulary from the lean-startup!
  • The team who reaches the red tile (in the middle of the board) first wins the game.

LeanStartup Vocabulary

During the session, we came across many lean-startup vocabularies, but here I will only be mentioning five of them!

  1. Pivot or Preserve: Certain challenges might force entrepreneurs to make a major change in their strategy. That change is called a Pivot!
  2. Idea Theft: Finding a compromise between the fear of idea theft (someone stealing your idea) and gaining knowledge is not an easy task. But, it is more important to gain knowledge than being afraid of spreading your idea!
  3. Concierge MVP: In some cases, you might need to create a fake processing MVP. That means what is happening in the background is not what it looks!
  4. Startup Machine: Put your idea to test by going to streets and asking people what they think about the product
  5. Startup Weekend: This is an activity where people of different backgrounds (dev, marketing, designers, etc.) meet to start building the first version

Take Aways

This game can be played by startups or even teams at large enterprises! And at the end, players should have got an idea of what Lean-Startup is. And more importantly, they will learn some of the factors that can play a role in any team’s failure or success such as competition, luck, technical excellence, failing and successful experiments, etc.

Agile Self-Assesment Game

Organized byBen Linders

As the name indicates, this game helps teams to assess how agile they are.

The game can be played by either an existing or a new team. In the case of an existing team, the results can be a base for a plan to change or improve their agile process. Whereas, for a new team this activity can be considered a futurespective activity as it defines the team’s first iteration.

Instructions

The game consists of 52 cards, where each card holds a sentence on applying an agile practice. To play the game you should follow the below instructions:

  1. Place the cards on the table
  2. Each member picks a card and reads it out loud
  3. The team discusses the card then place it under one of the following categories:
    • Not or inconsistently done

    • Consistently done, but value can be increased
    • Consistently done, valuable practice for the team
  4. After all the cards are visited, pick the ones under the 1st and 2nd category
  5. Have a discussion how to improve, change or remove those practices from your process
  6. If the cards to be discussed are too many, you can use voting to pick the most important ones for the team

AgileSelfAssesment.jpg

Cards

Below are statements taken from five cards:

  1. The team is empowered to make decisions
  2. The team is self-organized and doesn’t rely on management to set and meet its goals
  3. Software is tested and working at the end of each sprint/iteration
  4. All code changes are reversible, and it is possible to make a release at any time
  5. The team has a Definition of Done which defines their way of working and is used to check if a user story is ready

To know more about this game, you can check Ben’s blog on this session!

Until next time

I recommend those games to agile teams. Personally, I will be organizing two sessions with my team soon at Murex!

Finally, thanks to the organizers for setting up such an amazing and successful conference! See you next year! Probably as a speaker 😉