Even if the StringBuilder was around for a while now, many people still use StringBuffer in single threaded applications... So StringBuilder is supposed to be faster. But how much faster? Let’s see…

Most of the time code reviews are a meaningless ritual. Everybody pays lip service to the importance of code reviews and a lot of people, especially in the management, are convinced that code reviews very effectively reduce the number of shipped bugs. The problem is… most developers hate code reviews and avoid them like the plague. If they can’t avoid them, then they show up and act their part like in a play at the theater of the absurd.

Oldies but goldies: Gathering famous quotes on computers, programs, users and programmers. Have fun!

This tutorial shows how you can script a Scala application using the Java 6 scripting engines features (JSR 223 Scripting APIs). It also proves the level of power Scala gets from running on the JVM and from being able to use Java APIs. Along with a syntax that tries hard not to alienate Java and C# programmers this power gives Scala a jump start in the race for wining a place in programmers’ minds.

Lately I seem to find everywhere lots of articles about the imminent dismissal of Java and its replacement with the scripting language of the day or sometimes with other compiled languages. No, that is not gonna happen. Java is gonna die eventually of old age many many years from now. I will share the reasoning behind my statement. Let’s first look at some metrics.

Designing the error path in the code is not the most entertaining part of a programmer’s job. We are focused on coding the solution, the success path, and the damn exceptions stand in the way pretending to be handled. What makes it even harder and murkier is the lack of well established rules for what constitutes an exception and how to decide what kind of exception each one is: checked vs unchecked. And this decision is haunting because whatever you decide will influence the handling policy in the client code.

While developing complex systems lots of failure situations require handling and without proper planning chaos can conquer your code. A number of simple principles can create order and reduce complexity.

Good exception handling doesn’t happen by chance. It is designed and planned and when done properly it is one of the main roads to the software “Holy Grail” - quality and reliability. But leave it to chance and soon all hell breaks loose.

UML lost the programmers. There is no doubt about it… in my mind. And when a software design technology loses the programmers it fades away no matter what the academia thinks. This happened because UML was pushed in a direction that most code writers don’t like: it started to look a lot like bureaucratic paper work.

The fact that I find flaws in the design of the Java exceptions class hierarchy doesn’t mean I think there is no value in the whole system. Checked exceptions have a positive impact in development. The positive comes from the proactive nature of checked exceptions. They demand attention!

Let’s imagine a very simple scenario. You are writing an application which would benefit from some user specific customization after deployment. Maybe some of your customers have specific algorithms to be executed in the context of your application. Maybe your application doesn’t solve just one problem but it is designed to solve a class of problems but the number of variants is too high for you to capture at development time.

One more nice touch in the Java 6 offensive to the desktop is giving Java applications the ability to add icons to the system tray in a pretty consistent way across platforms.

Java 6 tries hard to make Java applications easier to integrate in the desktop environment of various platforms. One of such welcome attempts is the new java.awt.Desktop class adapted from JDIC (JDesktop Integration Components).

As I said before, I am a supporter of checked exceptions in Java. I think they are a great idea that supports serious software development in the real world. I also think Java’s huge success can be attributed in part to checked exceptions. But this doesn’t mean I like everything about how the Java’s exception handling system was implemented.

A resource is a file situated somewhere in the class path. It can be a file in a package folder, in the classes folder or in a jar file. Resources are usually needed at runtime and they can be properties files, images and so on. The ClassLoader and Class classes provide methods to find the desired resources but a little bit of attention has to be payed to the quirks of this API.

An easy low cost method to check the activity of the garbage collector in the JVM is to tell the JVM to create an activity log.

In Java 6 a better way of interacting with the command prompt was introduced, the java.io.Console class. Together with the utility class java.util.Scanner introduced in Java 5 this new API can be used to develop more advanced Java console applications.

Is there something wrong with Java exceptions? Does Java need a fundamental change in this area? Is the proposal to make all exceptions in Java runtime exceptions a solution to a real problem? What if this proposal is the solution to the wrong problem?

Many times it is useful to be able to get programmatically information about the network interfaces present on a host. Java standard library include a number of classes designed to provide access to this information. The most important is java.net.NetworkInterface which suffered a major face lifting in Java 6.

Due to a number of differences between various platforms it is very difficult to present system specific information in a consistent manner. When getting closer to system specific details, like file system information, a Java programmer has to become aware of the operating system hosting his program in order to make sense of the information returned by some of the Java APIs.

Introduced in Java 6 is the option of displaying a splash screen when an application starts. The splash image file can be specified on the command line with the new splash option

Every project that aspires to glory has some kind of regular build process that takes the code out of the code repositories (CVS and the like), compiles it and, hopefully, goes as far as possible towards creating a deliverable entity like an installation kit.