Pragmatic Programmer Issues – pietrowski.info

CMMI level 3 is huge challenge for us. Some time ago I was using findbugs just for fun, now it’s time to use it on all projects I’m involved in.

Findbugs is a project started in TheUniversity of Maryland as a result of research on static code analysis. There are three bug categories:

• Correctness bug : this is probably an error.
• Bad Practice: this is violation of good practice.
• Dodgy: this is simple dodgy code.

There are over two hundred bugs with description, which I suggest you to read. You can also write your own bug detector and there is for example a project called fb-contrib which has some bug detectors.

The usage of this tool is very simple. We can use it from eclipse, as eclipse plugin, standalone or as a maven plugin.

You can also simple install eclipse plugin by adding findbugs eclipse update site. After eclipse restart you should see in menu findbugs submenu. You can run findbug analyzis.

You can also add automatically checking for project, and of course choosing detector suitable for you by entering in project properties and next to findbugs options.

After that in code view you have additional pointers which shows you the line with problem. You can view description of the violation, which can help you to choose if this is a problem or false warning.

There are also bugs tree view, which groups similar bugs and leafs are source code position. My suggestion is to use findbug with your build tool. In my situation it is maven. There are two possibilities to use findbug with maven. First is simple and you can run it without any setup. You can simply write mvn findbugs:findbugs and after few seconds you have report in target directory.

>mvn findbugs:findbugs
[INFO] Scanning for projects…
[INFO] Searching repository for plugin with prefix: ‘findbugs’.
[INFO] org.apache.maven.plugins: checking for updates from artifactory
[INFO] org.codehaus.mojo: checking for updates from artifactory
[INFO] artifact org.codehaus.mojo:findbugs-maven-plugin: checking for updates from artifactory
[INFO] ————————————————————————
[INFO] Building Synergy Portal Platform
[INFO] task-segment: [findbugs:findbugs]
[INFO] ————————————————————————
[INFO] Preparing findbugs:findbugs
….
[INFO] [findbugs:findbugs]
[INFO] No effort provided, using default effort.
[INFO] Using FindBugs Version: 1.2.0
[INFO] No threshold provided, using default threshold.
[INFO] Debugging is Off
[INFO] No bug include filter.

The best option is to use findbugs as report, which is added to site projection. To do this you should simple add findbugs report to maven reports.

<project>
  [...]
  <reporting>
    [...]
    <plugin>
      <groupId>org.codehaus.mojo</groupId>
      <artifactId>findbugs-maven-plugin</artifactId>
      <configuration>
      [...]
      </configuration>
    </plugin>
    [...]
  </reporting>
  [...]
</project>

After that always you run mvn site and your findbugs report will be attached to project site.

Good Luck with Findbugs

Pedro

BTW: See here to see some sample with all known projects status

I read this book twice, and I suggest every java developer two read it twice or more. Some time ago I passed SCJP before this exam I thought that I know Generics but I didn’t. So when I saw this book in Roche Library I knew I should read it.

The book has two parts, one of them is about Generics (was read by me more than twice), second part is about java collections.

First at all we must know that generics are implemented by erasure. So once code is compiled there is no more information about Generics. Second important thing to remember is that List<Integer> has no relation with List<Number>. This one helps us to understand everything else. So once again List<Integer> is not subclass of List<Number> nor List<Number> is subclass of List<Integer>. This types are different, repeat with me D I F F E R E N T.

Once again:

• Erasure
• No parent-child relation

Ok so you ask what if I want a List with Integer and Float types. The answer is magical “? extends E” called wildcard, which means that it is legal to have type E and any type that is a subtype of E. For exampe Collection class have method

public boolean addAll(Collection<? extends E> collection);

which allows add all class and sublcass of type E. The second magic literal is “? super T” which simply means that it represents any type that is supertype of T.

This construction compared to arrays behavior makes three different subtyping.

We can’t use wildcards in :

• instance creation : List<? extends Integer> list = new List<? extends Integer>();
• supertype declaration: MyClass extends List<? extends Integer>
• generic method call: Collections.<? extends Integer>emptyList();

Important note is that List<? extends Integer> is a wildcard but List<List<? extends Integer>> is NOT.

One thing to mention is that parametrized type is reificated, so in runtime List<Number> and List<String> is simple raw List. Hence we can’t use instanceof with parametrized type. The only one generic type is <?> wildcard.

There are more advanced topics related to generics including tips how to migrate from no generic code to generic one.

Second part of the book is about java collections. There are full characterization of class hierarchy and the most important thing is that all implementation has comparison of performance. So everyone can choose suitable implementation for task.

Principles to remember:

Cast-iron guarantee: the implicit casts added by the compilation of generics never fail.

The Get and Put Principle: use an extends wildcard when you only get values out of a structure, use a super wildcard when you only put values into structure, and don’t use a wildcard when you do both get and put.

The Principle of Truth in Advertising: the reified type of an array must be a subtype of the erasure of its static type.

Summary
In my opinion all java programmers should have this book on his shelf and I assure you I will get my own.

Read more on Java Generics, there is a generic tutorial.