WONTFIX

Erlang Project Ideas

2014-12-20T17:04:00.001+00:00

Probability of Project Success

2014-11-12T22:44:00.001+00:00

Erlang Dev Environment

2013-07-27T14:31:00.001+01:00

I have started a tutorial on how to setup a professional development environment for erlang coding. The github page below has better formatting.

https://gist.github.com/andytill/6094931

South Park Software License

2013-03-30T21:47:00.000+00:00

If you have ever watched the show South Park then you will have probably read the disclaimer that is flashed at the start. Here is my software license tribute:

Remember that software development can often be much like an episode of South Park; constant swearing, youthful naivety and surprise endings.

Memories of Visual Basic 6

2013-03-22T21:36:00.001+00:00

In the UK it is typical to study for two years and then have a placement year where you actually get a job before the final fourth year of study. In 2006 I took on several small projects over the placement year and pushed VB6 to it's limits. VB6 has so many quirks, it is impossible not to use hacks to get things done. Here are some of mine.

One tool required a DSL for interacting with phones, it would read a list of phone numbers and a file containing commands and run them over each of the numbers. For example it would make a call to the phone and configure it using DTMF* tones. I had no idea at that time how a compiler could be properly implemented so the resulting code was a complete mess and the DSL was looked like assembly for telephones. Despite the hideous code, the program saved a lot of time. To do this manually would have taken days instead of a couple of hours and be impossibly error prone. One key missing feature was error handling, which is problematic in telecommunications. Inevitably one of the calls would go wrong and the program would crash, the operator would then have to delete the completed phones numbers from the list and run the program again. No problems!

Another project provided a UI for editing INI file configuration. The program was great, except that VB does not allow more than 256 controls on a single form. My 'ingenious' solution was to put each INI section in a tab pane which also had its own window. When the user clicked a new tab, it hid the current window and showed a new window for that tab.

VB6 also comes with it's own TCP control which you must drag onto the UI to instantiate. The problem is that it had almost the same API as a serial connection control, meaning it only dealt with 1 to 1 connections. This meant it was impossible to write a TCP server. That is, until I worked out that an array of TCP controls waiting for connections worked pretty much like a TCP server. This is OK except that an array has a finite capacity, I was again limited by the number of controls so the server could only ever handle a certain number of connections.

I remember the year, the work and the company fondly and hope that some of my work is still in use. Looking back, I don't know why I used VB6 for everything. It's just so easy to get started and then keep typing, I was young and naive, that's all I can say...

* DTMF tones are those strange sounds you hear when you press a number on a phone key pad. Pieces of hardware such as phones and switches can interpret a sequence of tones as commands.

EstiMate, a software estimation tool

2012-12-25T23:18:00.000+00:00

I have just open sourced a software application that I have been working on in my spare time for the past few months called EstiMate. This is my attempt to create some software which improves the way I can estimate a task and make what that estimate includes more transparent so that it is clear to others and Myself in the future. Areas which I feel are particularly important are:

Task complexity, how complex it the task and how confident is the assignee with that technology.
Quickly documenting what a task consists of and breaking it into smaller tasks
Having a history of past estimates and how they worked out.

There are many many more factors which affect estimation but these are the things that I want to implement first.

So, what does it do? At the moment it has some characteristics of an ERP application. You are able to add some projects, tasks and people to implement them. Tasks can be estimated and the sum of estimates are calculated for a project.

Complexity is taken into account which I think is a huge factor in any task. Tasks can be assigned "skill requirements" such as Java, SQL or anything you think you need and then can be rated out of ten. People can assign skills to themselves and rate themselves. If a task has skill requirements greater than those possessed by the assigned person then the estimate for a task is increased. I plan to improve this calculation by allowing the estimate to be increased by a percentage set in the project, instead of by a fixed number. Other factors affecting the time that a task can take will also be added.

Tasks can also be "templated", this means that the information entered for this task can be recreated. This is great for reoccurring tasks like builds, deployments or coding tasks that are very similar. It will allow these tasks to look similar and have a consistent base for estimation but be flexible and allow changes as needed. I plan to improve this to capture best practices such as including sub-tasks for testing or bug fixing that are percentages of the task estimate or perhaps even complexity.

EstiMate uses JavaFX for the frontend GUI and neo4j for data storage. It allows the user to keep a local database, to use a shared neo4j server or a neo4j database hosted on the Heroku platform. It is pure java and shouldn't need any set-up once I create an installer. At the moment, you can download the code from bitbucket and run it from your favourite IDE or command line (there might be a Maven hack there right now so be warned!).

It is licensed under GPLv3. I have blogged about some of the code I have written for this project so assume any code in this blog is free for you to use in any way you see fit without recourse to Me if it doesn't work of course!

If you have an idea or opinion or would like to contribute that would be great, feel free to comment here or tweet me @andy_till.

Dragging to resize a JavaFX Region

2012-12-24T15:56:00.000+00:00

Here is another handy JavaFX utility to allow you to drag the bottom edge of a JavaFX Region to resize it. Layout containers inherit from Region although controls do not even though they both have a minHeight property so Controls cannot be resized using this class :(

Features I would like to see in FXML

2012-11-04T13:58:00.002+00:00

I really enjoy using FXML, it is robust, simple and well supported by the Scene Builder tool but there are some features I would really like to see.

Controllers allowed on arbitrary nodes

Large controls usually have many action methods, many controls injected with the @FXML annotation and typically other objects like DAOs which can get quite messy. Sometimes handling code for a single control such as a combo box can get quite large, creating an FXML for a small control seems like overkill.

To tackle this, it would be useful to allow the fx:controller attribute on any FXML element specifying a node that is loaded into the scene graph. This 'sub-controller' would have controls injected with @FXML annotations in the same way as root controller except that the it would not be able have it's parent controls injected. Only the element it is declared on or that element's children could be injected.

Allow effects to be created in Scene Builder and then injected into a controller

It is much easier to create effects in Scene Builder than it is in Java code because I can get instant feedback and fine tune much easier. It would be great if I could create an effect in FXML and have it injected into the controller using an @FXML annotation.

Support 'Actions'

One of the things that I miss from Swing is the javax.swing.Action interface. This was used to encapsulate action logic of a button in a single class instead of having many action listeners in one class. I could create a class implementing EventHandler and set it on the button in the controller class, but it would be nice to specify it under the code tab in the same as you would specify a method to handle an event.

Specify some validations on TextField controls

For Me, FXML is all about productivity so it makes sense that it could support common requirements such as validations on TextField controls. For example, a TextField might only allow numeric input up to a maximum number. If you google "javafx numeric textfield" there are already many varied implementations. It would be great to see this in Scene Builder, even better if it could be tested in preview mode.

JUnit Rule for JavaFX Controller Testing

2012-10-04T20:53:00.000+01:00

Testing JavaFX controllers is relatively easy although you do have to jump through a couple of hoops. Firstly, JavaFX must be initialised and secondly JavaFX controls must only be mutated on the JavaFX thread created internally during initialisation. The JUnit rule below will setup JavaFX once and run all tests on the FX thread. All you need to do is create it as a field in your test case class and annotate it with @org.junit.Rule. You will need to be running JUnit 4.9 to use the rule API.

Reusable FXML Controls with Guice

2012-09-04T13:16:00.000+01:00

Update:
This code is now integrated into the fx-guice project where it will be maintained. I am not intending to modify the GitHub gists so this post now only serves to document the code as seen here.

It is very simple to inject controllers into an FXML control using Guice but once the UI starts to get bigger it is likely that we will need to split it out into smaller files. I wanted to do this with a list builder control simple to that in SceneBuilder used to build a list of CSS classes.

In my UI the controller of the parent control (called parent controller from now on) would tell the list builder control what items it could add to the list and what items were already in the list using the list builder's controller (the child controller). Getting this to work this is far from simple.

It is not possible to get or set a controller on an arbitrary control node. I fired up VisualVM to see where the list builder controller was referenced and the only incoming references were to the event handlers I had set up. If there were no event handlers it looks like the controller would get garbage collected. It was also not possible to set a Guice singleton scope on the controller as there may be several list builders in the user interface at the same time.

Here is a run down of my final solution although it is not altogether as simple as I would have liked it. This tutorial is much more complex than my previous FXML/Guice post, I had to look up my own tutorial on Guice scopes to work it out. Please let me know if anything is not clear

1. Add the Guice Module

Add the following Guice module to your Injector. This example also assumes that you are using the same Injector to inject controllers when loading FXML, this is detailed on my previous Guice/FXML post.

The module uses the following Guice scope to track all injected controllers.

2. Use a scope annotation on the controller

Reusable controllers are annotated with the custom @FXMLLoadingScope.

3. Implement the IdentifiableController interface in the controller

Reusable controllers must implement the IdentifiableController interface which has one method, #getId(). #getId() must return a non-null String containing the ID of the parent of the root pane of the control. If this ID is null then return the second parent-parent's ID. Keep going until a non-null ID is found.

4. Set an ID on the parent

When importing one FXML file into a parent, set the container ID to the ID you want for the controller.

5. Retrieve the child controller

In our parent controller (the one that that will tell the list builder what to do) we need to retrieve the list builders controller to populate options and so on. To do this, Inject an instance of ControllerLookup into the parent controller.
In the parent controller, make sure you implement the Initializable interface. In the initialise method of the parent controller call ControllerLookup#lookup(String) on the instance you have injected to retrieve the child controller. The ID that is passed in should be the ID that is returned by IdentifiableController#getId(). This could be hard coded but in this example it is using the FXML ID of the parent control, "factorsList" in this case. This allows several list builders to be used in the same parent control.

I am using this in my own JavaFX project and although the implementation was not simple I have found it quite easy to use.

JavaFX CSS Styling

2012-08-20T13:23:00.001+01:00

I've been working on a light grey look and feel for JavaFX with square corners, inspired by the Swing Substance (Business Grey) Look and Feel. Here are the results so far:

And just as a reminder as to the default JavaFX look and feel:

This is a work in progress and not all of the controls are styled. This skin has now become the first entrant in the jfxtras-styles project hosted on github or click here if you just want to grab source.

The extra space is to show the drop shadows on the titled panes which I use quite a lot in my own application.

Update:
Just to show the different a little CSS styling can do, below is a recent screenshot of EstiMate, the JavaFX project I have been working on. It's come a long way! You can take a look at the CSS here.

Creating JavaFX Controllers Using Guice

2012-07-01T19:03:00.001+01:00

I really like Guice Dependency Injection so was pleased to hear that some work has been done to make this interact with JavaFX. The solution presented though, was less than ideal. It had some duplication of configuration where the class name of the controller needed to specified in the FXML as you would expect but also when loading it. After a brief fumble through FXMLLoader's methods I found #setControllerFactory. By passing this wafer thin adapter below as a parameter to #setControllerFactory, any controllers will be instantiated via Guice.

JScrollPane Repainting Problems

2012-06-04T01:07:00.000+01:00

I was having some problems with the JScrollPane not repainting my custom component properly when scrolling. The results were that the area that was now visible because of the scroll was painted unevenly and looked blurred. This seems to happen when a component is doing some custom rendering inside a JScrollPane and using the clip to find out what area it should paint. To fix this call the following methods on your JScrollPane:

scrollpane.getViewport().setScrollMode(JViewport.SIMPLE_SCROLL_MODE);

In the modern swing implementation there is some 'clever' caching of the content view to improve performance which seems to be the problem. Setting SIMPLE_SCROLL_MODE will force the scroll pane to repaint it's entire contents while scrolling. Although this is less performant, it at least shows the correct results with minimum fuss.

Safely Removing an Element While Iterating a List

2012-04-06T19:00:00.000+01:00

If you want to remove an element while you're iterating a Java ArrayList then you have some problems. First off, if you use an iterator then the list will most likely throw a ConcurrentModificationException. If you use a classic style for loop then when you remove an element the list will no longer be the same size or have it's other elements at the same position as when you started iterating which might cause an error, logical or otherwise.

The simplest way to do this is to iterate backwards over the list. This means when you remove an element, the other elements will not get reordered. The method below demonstrates:

    public void iterateBackwards()
    {
        List list = new ArrayList(Arrays.asList(1,2,3,4,5));
        
        for (int i = list.size() - 1; i >= 0; --i) 
        {
            System.out.println(list.remove(i));
        }
    }

This prints....

5

4

3

2

Fastest Way to Delete a Directory In Windows

2012-03-22T21:48:00.000+00:00

I had a load of large directories (several GBs) which I needed to delete so that I could meet the minimum free space requirement for Windows to run the defragmentation tool. Unfortunately, Windows Explorer is unusably slow for this as it first scans the whole directory so that it can show the estimate and then copies everything into the recycle bin or not if the directory is too big.

Below is some batch script to delete a directory very fast. The code is on stack overflow here where the commenter Hugo bench marked it at 3 times faster than rmdir which itself is a hell of a lot faster than deletion via Windows Explorer.

bestrmdir.bat

rem to use, drop in your c:/windows/system32 directory for this to be usable anywhere

rem in then command line type 'bestrmdir MyDirectory' to delete MyDirectory

del /f/s/q %1 > nul 

rmdir /s/q %1

Typed Integers

2012-02-29T23:03:00.000+00:00

I really like the idea of typed integers. For example, if you a number representing the number of cats and a number representing a number of dogs it is possible to add these together. In a typed integer world it would not be possible and throw an error upon compilation. I think this would be a big improvement for API safety and also a method of documentation. There is nothing worse than a method with a structure like #foo(int, int) which is difficult to understand without reading or documentation every time.

In general use this would be suicide in a managed language where the overhead of an object for every int could mean a huge jump in memory usage and GC wouldn't be worth the improvements. The actual implementation in Java would also be extremely ugly, for example:

class EventID {

  private final int id;

  public EventID(int anID) {

    id = anID;

}

}

The class doesn't even contain basic methods like a way to get the ID, compare or hash it which with an int you get for free and it is still a fair wedge of code. Lombok's @Data annotation can really improve classes like this and make the language feel more declarative.

I have found the best language to implement this is c++, the following is my proof of concept implementation:

template  
class TypedInt
{
public:
  const int value;

  TypedInt(int v) : value(v) {};

  TypedInt operator + (TypedInt num)
  {
    TypedInt result(value + num.value);

    return result;
  }

  TypedInt  operator = (const int other)
  {
    TypedInt result(other);

    return result;
  }
};

This allows the following usage:

struct eventid {};

typedef TypedInt EventId;

EventId i = 2, j = 3;

EventId result = i + j;

Overall this feels natural to use. If I was actually using class then the other operators such as == could be implemented without problems.

One of the benefits of c++ is that an object wrapping an int does not take more memory than an int would, during compilation this abstraction is apparently stripped away.

Compatible Images

2012-02-26T21:23:00.000+00:00

A couple of weeks ago I was tasked with improving the performance on a legacy java swing application that was really crawling. It would repaint the whole screen on any event, which it could receive a lot of, and painting the whole screen was really slow. By using compatible images instead of the default kind of image read by ImageIO, the painting code was sped up by a factor of 70 and the event frequency was a non-issue. The whole change was about 10 lines of code, much less than that to make the software use the graphics clip.

If you are having an issue with graphics performance make sure you try compatible images before trying anything else since it is so easy to introduce.

Before deploying to site I was worried that the speed up I was seeing was in some way down to my dev machine working well with compatible images so I wrote the tool below to test if the improvement was the same which it was. Some notes:

The tool requires an image. When I attempted to create an in-memory image there was no difference in run times.
Results are printed on the command line so remember to use java.exe and not javaw.exe
I went to some effort so that this program was a single class to make it easy for the support guys to run. I don't usually like to implement Runnable on a class that isn't just a Runnable.

How Much Architecture is Enough?

2012-02-26T21:03:00.001+00:00

In the past I have often wondered if I have provided enough architecture for the software team to work to. Conversely I always like to leave enough room to maneuver for the guys to do design for their own parts of the software, I would really hate it if I was working on a project where everything was defined and all I needed to do was "code in the blanks".

The idealist in me wants to provide just enough architecture to start work at all, and emergency design will do the rest. I have found this is not how great software is made. When everyone is left somewhat to their own devices, the code starts to lose coherence. Everyone will code their own mini framework that will not interact well with other stories or allow extension for all requirements. This is natural as everyone might not be aware of all requirements for the project.

The answer to this is pretty simple in practice, whenever two or more stories meet the following criteria you need some architecture:

1. Other code interacts with the product of a story.
For example some kind of remote or local service or data. In my current work we do a lot of inter-process communication. This is really a technical detail, web services or in-process framework meets the same criteria. Whatever it is, it needs some documented architecture. The documentation part here is important, it should be simple to find look-up the exposed interfaces with arguments including valid values, errors etc. This rule tends to reduce errors and confusion (more errors) occurring from not knowing about or not understanding .

2. Two or more stories are similar

For example, two kinds of message or input that could be handled in the same way or are similar enough to be categorised together. Polymorphism and/or inversion of control can be used to have a central mechanism handle these in a reusable way. This rule tends to reduce the overall amount of code and improve code quality.

These two scenarios are sum up pretty much of every time where I had wished I had provided some architecture before work commenced

Some of My Coding Habits

2011-12-12T20:17:00.000+00:00

This is a brief description of my coding habits including indentation, new lines and other things that I don't usually see although I think it makes code clearer.

Variable declaration and assignment on separate lines
Example:

JLabel nameLabel;

 nameLabel = new JLabel("Name:");

nameLabel.setBackground(Color.RED);

Although I didn't take up SmallTalk seriously I did come away with, among other things a new coding habit. SmallTalk variables are always declared in pipes i.e. | myVar | before use. In Java I use this, especially when the object needs one or more method calls after it is created. It is almost like a paragraph header and allows the code on the left hand side to match up which I find quite easy to read.

Static imports

No need for an example here, I just really like static imports... in moderation. They are particularly effective for enums where the enum name might be repeated over and over again. It is also quite safe to use enums in this way because type safety will not allow you to do anything silly such as EnumA.RED == EnumB.RED without giving a compilation error.

Static imports are quite bad for importing primitive constants, it is much easier to make a mistake without the context of the class name from where it came. For example, two different integers might mean very different things. A number of cats and a number of dogs which should not be added together.

It is quite rare for me to write static methods so this isn't usually an issue.

Returning new
Example:

public String findDayName(int dayIndex)

{

  assert dayIndex >= 1 && dayIndex <= 7;

  switch(dayIndex)

{

    case 1: 

      return "monday";

    case 2: 

      return "tuesday";

    default: 

      return null; 

}

  // and when using an if statement

  if(dayIndex == 1)

    return "monday";

  else if(dayIndex == 2)

    return "tuesday";

  else

    return null;

}

When using a reasonable size switch or if statement I typically bring this out into a separate method with no variables other than the data needed to perform the switch. Even this is not necessary if the data is a class field. There is no variable that gets assigned to so no need to worry about a name, or maintain the name and the method name make sense together. If statements also do not have brackets to cut down on needless lines and white space which in this case would just make the code more bulky and difficult to read.

The if statement is reminiscent of Erlang guarded methods.

Resolving Bugs

2011-10-15T18:31:00.000+01:00

There are at least three roles in a bug report. The first two are the bug reporter or owner of the bug who is equivalent to the Customer or Product Owner and the Software Engineer responsible for the bug. An Architect, Technical Lead or Project Manager may exist who has more direct access to the customer, this is called QA in Bugzilla. In certain cases the Engineer may need to escalate issues if they cannot resolve it themselves. This can happen all the time, the Customer might raise a bug stating that functionality is missing when it is not in the requirements. If this is not dealt with in a way that includes all stake holders, it could cause issues immediately or later on in the project at demo time.

Below is a table of resolutions and the circumstances in which they can be applied and by who. The only possible option for the software engineer is to fix the bug or agree another resolution with the customer, or team lead. This means that the bug will always be fixed or dealt with in a final way where the specification will be updated to reflect the new behaviour (or new understanding of behaviour) or at least a resolution agreed which should be traceable in the bug comments. If the bug is not fixed and not agreed then it is bound to come back in the future starting with the line “I reported this months ago and it is still NOT FIXED”!

Fixed	Only the Software Engineer can set.
Invalid	Only the Customer can set.
Won’t Fix	Architect, Technical Lead or Project Manager can set based on agreement with customer. Should be extremely rare.
Later	Never set
Remind	Never set
Duplicate	Software Engineer can set in the interest of efficiency. Be careful that this is truly a duplicate and the customer is in fact not describing some other behaviour.
Works For Me	Never. Negotiate with the Customer for them to set the bug to Invalid instead.

Detangling Dependencies Between Guice Injected Services

2011-09-25T13:59:00.002+01:00

It is very easy to allow services to depend on each other, even when they are in different modules. In fact Guice explicitly supports this behaviour with the AbstractModule#requiredBindings method. I think this is very bad and in my experience has led to some complex interactions and strict requirements on order of creation. Even worse, in some cases you may require a cyclic relationship to fulfill what you want to do which means you can't fully initialise the services via constructors.

Instead of a clever technical solution, I believe it is the software design that is incorrect. The issue can be resolved using SOLID principles to identify and rectify the issue.

The services require the dependencies because they are trying to do too much, this is violating the Single Responsibility Principle (SRP). I often think of SRP as a DON'T whereas the Interface Segregation Principle (ISP) is a DO: to fix an SRP issue apply ISP and move that behaviour out into new classes.

This still hasn't fixed the issue yet because those dependencies still have to be wired up in the modules, except you don't. The new classes with dependencies can be instantiated via Guice when required with injected dependencies, the code to wire them up in the modules can be removed altogether.

In this way, layers of objects are being created. The bottom layer of services are injected into the next layer of composite services which are then injected into the application. This is the Open Closed Principle (OCP) where classes should be open for extension but closed for modification. In other words, prefer to building on top of existing classes instead of modifying them.

I do suggest that all layers can talk to each other unless the software is huge enough to justify such abstraction. Also, be sceptical of composite services which simply provide a layer over another service and perhaps wrap exceptions or even provide a something useful. In this case a new API has been created to replace a more universal one. Ask if the new API is actually better than what it is truly wrapping and it is worth the new layer being imposed.

Guice Custom Scopes

2011-09-25T13:26:00.000+01:00

Guice custom scopes are, for some reason badly explained in almost all web documentation that I was able to find. All implementations cover extra Guice concepts or muddy the code with concurrency handling while not describing the main concept which is surprisingly simple once realised.

A scope is a condition for reusing injected objects, instead of creating a new one each time. For example, if a network connection was being injected then the scope would be while the network connection was open, reuse the object. When it is closed, open and inject a new one.

The implementation for this is to basically provide a factory object, implementing the Scope interface. This has one method:

Provider scope(Key<T> key, Provider<T> unscoped)

The Key object defines the injected type, the unscoped Provider can be used to create a new instance. Typically the returned Provider implementation will create the required object using the unscoped Provider and keep a reference to it while in scope. When the object is requested again the stored object is returned if still in scope. This example usage above is how I needed to use custom scopes but it is flexible enough to do all kinds of weird things.

Here is the Scope implementation. It is a bit more complex than necessary because for this example I wanted to allow objects to be created out of scope.

Here is out annotation which we will use on classes that can be stored within the scope.
The interface to inject:
The class that implements that interface to be injected. Note that we have annotated this with our @BookScoped annotation. The constructor will display new objects being created.
Now our Guice module. The scope annotation is bound to an EnterableScope instance which we'll keep a hold of.
Finally the main class to demo the scope.
When the main class is run it outputs the following to the command line:

entering scope

created customscopes.Hobbit@12a54f9

exiting scope

created customscopes.Hobbit@30e280

created customscopes.Hobbit@16672d6

created customscopes.Hobbit@fd54d6

created customscopes.Hobbit@1ccb029

When within scope the four calls to #getInstance only create one instance, when not in scope a new instance is created each time. That's a whole lot of code although it is all fairly simple. From a maintainability viewpoint I do see some issues with this, scopes are so arcane to anyone not experienced with Guice that it would be quite easy to misuse a scope which could cause all kinds of issues with retained state and possibly memory leaks. All I can suggest is document everything and get this over to the team.

Checked Exceptions Part 3

2011-08-30T22:39:00.001+01:00

I found a bug last week that was caused by a checked exception anti-pattern or maybe code smell. I name this smell "foo() throws Exception". The premise is that a method throws Exception, Throwable or any other exception which is low enough down in the class tree to capture the exceptions which may be thrown by the code that is being worked on. The software engineer happily beavers away without realising that the code is throwing all kinds of exceptions that are not being handled correctly. The handler is higher up the method chain and detached from what the code is actually doing so cannot reliably act, most likely it is simply logging exceptions. Once handled and logged nothing more is done possibly leaving the thread and/or application in an invalid state.

This can be caused by the programmer wanting the exception handling to go away perhaps because exceptions were used too liberally and now there is more exception handling than business logic. Maybe handling the exception is too uncomfortable since there is no plan B, there is only failure, but the application is long running and cannot be restarted so a catch-all was a last resort for an error that supposedly could not happen.

The application in question simulates a GSM-R application and calls are made to get the active call which the application is currently dealing with. The other party could end the call at any time and the system is completely asynchronous and multi-threaded and it is highly likely that no call could exist the next time you check for it. The exception being thrown was part of the null-checking strategy which has proved highly effective in reducing NPEs. Instead of a null being returned from a method, a checked exception is returned: CallDoesNotExistException. So this exception could happen in normal application flow and must be handled by application logic.

As it turned out the fix was remarkably elegant once the functionality as a whole was understood (read remembered). A catch for CallDoesNotExistException was added to the catch-all handler which would navigate the user out of the process they were in to one of the two possible application states fixing similar issues in the entire application. This change was helped by the fact that CallDoesNotExistException is task specific and other parts of the application could easily identify the issue in the code, as opposed to a generic exception which would be almost impossible to identify whether it was checked or not.

Using Method Handles

2011-08-03T00:14:00.001+01:00

A few weeks ago I ran some tests pitting method handles against typical reflection to see what was faster. The result was that reflection was faster although since it was a quick test I don't have the result data or what run configuration I used. Now that I'm tasked with looking into porting our core systems to Java 7 I thought I'd take a more critical look.

Below is the source code I used to run the test. It calls a method on a class called Incrementer a million times. I didn't notice any difference when running the methods several times when running the test several times before timing values to "warm up" server mode.

Note that this code throws an exception when run from eclipse. I had to use the javac/java executables from the command line for this to work. When running the class in mixed mode I got the following results:

java -verbose:gc MethodHandleTest
[GC 4416K->141K(15872K), 0.0011714 secs]
[GC 4557K->141K(15872K), 0.0006216 secs]
[GC 4557K->141K(15872K), 0.0006387 secs]
reflection took 515ms, result is 1000000
method handles took 16ms, result is 1000000

There is plenty of garbage collection happening but not enough to account for the huge time difference. When running in server mode I got the following results:

java -verbose:gc -server MethodHandleTest
reflection took 47ms, result is 1000000
method handles took 15ms, result is 1000000

java -verbose:gc -server MethodHandleTest
reflection took 32ms, result is 1000000
method handles took 31ms, result is 1000000

All runs of the test gave almost identical results to the above where method handles would be twice as fast as reflection or equal with no garbage collection. Interestingly, if I comment out the increment of the long value the same result as with the increment is produced:

java -verbose:gc MethodHandleTest
[GC 4416K->141K(15872K), 0.0011488 secs]
[GC 4557K->141K(15872K), 0.0006595 secs]
[GC 4557K->141K(15872K), 0.0006482 secs]
reflection took 500ms, result is 0
method handles took 31ms, result is 0

This makes me think that incrementing the long is a very small proportion of the time it takes for the reflection example to run and the majority is for calling the method through reflection. In server mode the reflection call is JITted and almost identical results are produced. This is mostly conjecture since it is quite difficult to work out what the Hotspot compiler is doing.

In conclusion, method handles consistently performs as good as, or better than reflection no matter what run configuration you are using. Stability is an issue with the current tools, eclipse will have to support Java 7 before I could use method handles in our systems.

An Immutable List in the JDK

2011-05-07T17:41:00.001+01:00

It's quite strange that there is no immutable list class in the JDK, immutability is most likely the biggest part of any concurrent design. It's well understood that an immutable object can be safely passed or accessed by other threads meaning that it is not necessary to lock.

It's not quite true that there is no immutable lists in the JDK, there is always the Collections#unmodifiableList method, return a wrapper around the supplied List that does not allow modification. However, it is only a wrapper and the underlying data structure can be modified so there are no guarantees about immutability, only conventions which are only convention if you knew about it in the first place. Or the guy before you did.

The problem with the unmodifiable list is that once you have it, there is no way to check if it is unmodifiable. The implementation class, UnmodifiableList is package protected so it is not possible even to do an instanceof check. I have found this to be a big source of inefficiency. There is no way to check if the list is immutable so if you must have an immutable list you can "ask" via documentation that lists should be immutable or defensively copy the list. Typically I would using defensive copying, because there is no way to know how the code is going to be used in the future and if the engineer is going to check the documentation. I'm not even sure that it is a reasonable requirement to ask someone to check the small print for every method they use.

The fix for this is relatively easy and even doable without hacking the OpenJDK by using the -XbootClasspath command line option. Using this you can specify the boot classes you want to load, by default its your JRE rt.jar. If you modify some JDK classes you can specify that to be loaded first and then rt.jar so your modified classes will be first to load.

All that needs to be done as a starting point is to make the UnmodifiableList class public and make that the return type from Collections#unmodifiableList instead of List so we know what we're getting and other classes can pass it around also. It doesn't fix the possibility of the data structure being modified but we're 80% of the way there for such a small change. Because UnmodifiableList is still a List implementation all current code will still compile.

Unfortunately it is not legal to deploy this change to a production system, it's only for fun.