Paul Grenyer

Agile Financial Times (Webinar)

2012-01-18T11:56:00.001Z

Ian Brookes Cake Solutions

Today I dialled into a webinar on the financials of Agile given by Ian Brookes of Cake Solutions. A webinar gives you a window in which you can see the slides from the presentation and hear audio from the presentation. I worked quite well, but the audio was flaky at times.

I enjoyed the presentation, its content and Ian’s style. Here are some of the things Ian covered.

Ian started off by running through what Agile is and pointing out that it doesn’t cost any less than traditional software development processes such as waterfall. The added value is the fact that it delivers what the business needs, in contrast to traditional processes which can (sometimes) deliver on budget and on time, but usually don’t deliver what is required by the business. He also pointed out that Agile excels at delivering the most valuable features, rather than a lot of features that are unlikely to be used.

Ian went on to explain how the Agile estimation process works, including planning poker as he described the makeup of Agile teams. He pointed out that BAs should be involved throughout the project, otherwise there is a criminal waste of knowledge. Ian then went on to point out the flaws in Waterfall and compared it contractually to Agile. Agile has a more pay as you go feel with much better visibility and encourages communication, collaboration and trust. Ian told us how Agile can prevent projects from failing and about values and the human side of agile.

The final part of the presentation had all the numbers and showed how Agile can really reap financial benefits.

Unfortunately I had to leave before the end.

Agile East Anglia: User Stories Explained

2012-01-16T18:37:00.003Z

Date: Monday 6 February 2012

Time: 6pm

Location: The Assembly House, Theatre Street, Norwich, Norfolk, NR2 1RQ

Agile developers seek to deliver valuable software early and often. They work closely with customers to figure out what's the most valuable increment of software to build next. In order to tease apart tangled and bulky requirements, agile teams want to understand user stories. Come to this talk to learn how to uncover user stories and underlying acceptance criteria. You'll also hear about some pitfalls to avoid.

Rachel Davies, Industrial Logic Europe Ltd.

Rachel is co-author of the first "Agile Coaching" book and the UK’s leading expert in coaching agile teams. She is director of Industrial Logic Europe, a company that specialise in Lean/Agile training, coaching, and eLearning. Rachel has over 20 years experience in software development and has been working with agile teams since 2000.

This is a free event sponsored by Smart 421. To register please email: paul.grenyer@gmail.com.

Agile World Breakfast Seminar

2011-12-02T20:16:00.003Z

Yesterday I attended my second Agile World Breakfast Seminar given by Cake Solutions at Hays IT's offices on Cheapside in the centre of London. I was coming from Norwich so it meant getting the 5.25am train. An early start but well worth it.

A breakfast seminar is probably just as you imagine. You turn up at 8am, you're given a nice breakfast and the chance to network before attending the seminar. Following the seminar there is more opportunity to network. It's mostly over by 10am.

I'm being completely honest when I say I go for the networking and to catch up with the Cake Solutions team. The level of Agile given by Jan Machacek was introductory. It was solid, interesting and perfectly pitched for the majority of the audience. What sets Jan and Cake Solutions apart from other Agile organisations is that they are able to speak about their experience. Many Agile evangelists (consultant appears to be becoming a dirty word) are unable to do this.

I only took issue with one suggestion towards the end which suggested that using an Agile methodology could make your team appear to be going slower. Jan gave some metrics, but I think the missing point was that with traditional software development (Waterfall etc.) the only yard stick the business has are the metrics supplied by the development team. With an Agile team the metrics don't necessarily look so good, but the major advantage is that the business can see working software at the end of each iteration which is a far greater indication of real progress.

There were some very interesting and revealing questions about the collaborative software development process that Cake Solutions offers its clients. It was clear that there is a similar amount of risk on both sides, but the risk for the client is significantly reduced from more traditional methods of working.

The next seminar will be on the financial aspects of Agile development. I'm looking forward to more networking and more content relevant to me personally.

Learning UML 2.0

2011-11-30T20:36:00.005Z

Russ Miles & Kim Hamilton
ISBN: 978-0596009823

I have never been a big fan of UML or really seen the need for it. However I was told it was imperative for my latest contract, so I out my old copy of UML distilled by Martin Fowler and bought a new copy of it for my Kindle and started reading it. I had been with my new client very long when someone recommended Learning UML 2.0 by Russ Miles and Kim Hamilton. It contains the Philippe Kruchten 4+1 model that we would be using for the project so I thought it would probably make a better book to learn from (no pun intended).

Philippe Kruchten 4+1 Model
This is a great book. Easy to read and lots of detail about the key areas of UML 2.0. It doesn't cover absolutely everything, but recommends other books that do. There are lots of code examples in Java. I'm not sure if all of these are useful or if the authors, who are programmers, were just desperate to get some code in.

The book focuses on what in my opinion are the most useful diagrams:

Use Cases
Activity Diagrams
Class Diagrams
Object Diagrams
Sequence Diagrams
Communication Diagrams
Timing Diagrams
Interaction Overview Diagrams
Composite Structures
Component Diagrams
State Machine Diagrams
Deployment Diagrams

I hesitate to include Class diagrams in the list. Along with Use Cases and Sequence diagrams, class diagrams are probably the most well known of all UML diagrams. Unlike sequence diagrams and to a certain extent Use Cases, class diagrams are of little use. Usually it's quicker to get on and write the code than it is to draw diagrams and get someone else to write it. One possible exception is where you are generating code from a UML model, but I don't really see the point in that either. Fortunately there are only two chapters on Class Diagrams.

In my opinion if you want to learn the important parts of UML in a hurry. This is the book for you.

Review of Effective C# Item 15: Utilize using and try-finally for Resource Clean-up

2011-11-17T15:36:00.003Z

The original Effective C++ Series from Scott Meyers was a real revelation for C++ programmers. It grouped together many idioms from the wildly diverse and complex language and made them understandable. It identified many of the pitfalls and made them avoidable. It was a must read for every serious C++ programmer.

Since then all the major language seems to have an effective series. You would think this was a good idea, but most languages are not as wildly complex as C++, with fewer idioms and pitfalls. They're still there, but the languages have been designed with the idioms in mind, and the introductory texts teach them, and with a lot of the pitfalls already avoided. Consequently most effective series for modern languages are smaller and contain a lot of patterns as well. For example, Effective Java starts off with the builder pattern. To my mind that belongs in a patterns book and it certainly should not be the first Java idiom described.

I am currently reading Effective C# by Bill Wagner. I've got as far as chapter 18 and so far it is full of good advice, but, in my opinion, is extremely poorly explained. Items 6 and 7 cover equality and GetHashCode. These are complex concepts in predominantly reference based languages, like C#, and after I'd finished reading the items I didn't feel I understood them much better.

Items 12 to 20 cover resource management. This is a real passion of mine, so naturally I'm quite critical of what's written here, as well as what's actually written. Luckily most of what's written is sound, but part of Item 15 gives, in my opinion, some just plain bad advice. The following item, 16, is another exceptionally badly written item, all though the advice is sound, but I'll leave that for another time.

Item 15: Utilize using and try-finally for Resource Clean-up Resource management is probably the biggest Achilles heal of garbage collected languages. As such, it should probably be the subject of the first section of any effective series, but item 15 out of 50 isn't to bad.

How and why resources need to be managed in C# is explained satisfactorily by the item, so I won't go over it again. However I was highly amused by one paragraph: "Luckily for you, the C# language designers knew that explicitly releasing resources would be a common task. They added keywords to the language to make it easy." Surely this is treating a symptom, not solving the problem and they should have found a way to encapsulate resource management within types.

My real issue with this item is what the author describes as an ugly construct. There is an implied using example that uses both a SqlConnection and a SqlCommand:

public void ExecuteCommand(string connString, string commandString)
{
    using (var myConnection = new SqlConnection(connString))
    {
        using(var myCommand  = new SqlCommand(commandString, myConnection))
        {
            myConnection.Open();
            myCommand.ExecuteNonQuery();
        }
    }
}

The author points out that you've effectively written this construct:

public void ExecuteCommand(string connString, string commandString)
{
    SqlConnection myConnection = null;
    SqlCommand myCommand = null;

    try
    {
        myConnection = new SqlConnection(connString);
        try
        {
            myCommand = new SqlCommand(commandString, myConnection);

            myConnection.Open();
            myCommand.ExecuteNonQuery();
        }
        finally
        {
            if (myCommand != null)
                myCommand.Dispose();
        }
    }
    finally
    {
        if (myConnection != null)
            myConnection.Dispose();
    }
}

As he finds it ugly, when allocating multiple objects that implement IDispose, he prefers to write his own try/finally blocks:

public void ExecuteCommand(string connString, string commandString)
{
    SqlConnection myConnection = null;
    SqlCommand myCommand = null;

    try
    {
        myConnection = new SqlConnection(connString);
        myCommand = new SqlCommand(commandString, myConnection);

        myConnection.Open();
        myCommand.ExecuteNonQuery();                
    }
    finally
    {
        if (myConnection != null)
            myConnection.Dispose();

        if (myCommand != null)
            myCommand.Dispose();
    }
}

I have two problems with this. The first is that if the Finally For Each Release pattern, as described by Kevlin Henney in Another Tale of Two Patterns, is correctly implemented, the null checks, which are a terrible code smell and often the cause of bugs if they get forgotten, would be completely unnecessary:

public void ExecuteCommand(string connString, string commandString)
{
    var myConnection = new SqlConnection(connString);
            
    try
    {
        var myCommand = new SqlCommand(commandString, myConnection);

        try
        {
            myConnection.Open();
            myCommand.ExecuteNonQuery();
        }
        finally
        {
            myCommand.Dispose();
        }
    }
    finally
    {
        myConnection.Dispose();
    }
}

If the nested try blocks are a problem for you, another method can be introduced:

public void ExecuteCommand(string connString, string commandString)
{
    var myConnection = new SqlConnection(connString);

    try
    {
        ExecuteCommand(myConnection, commandString);
    }
    finally
    {
        myConnection.Dispose();
    }
}

private void ExecuteCommand(SqlConnection myConnection, string commandString)
{
    var myCommand = new SqlCommand(commandString, myConnection);

    try
    {
        myConnection.Open();
        myCommand.ExecuteNonQuery();
    }
    finally
    {
        myCommand.Dispose();
    }
}

However, the real problem is that you are only effectively implementing this construct. If you stick with the original nested using blocks, the compiler creates the construct for you and you don't see it. Which means that it really doesn't matter how ugly it might be and ditching the using blocks and writing your own construct just creates the ugliness. Maybe the root of the authors aesthetic objection is the nesting. Again, this is easily overcome by introducing another function:

public void ExecuteCommand(string connString, string commandString)
{
    using (var myConnection = new SqlConnection(connString))
    {
        ExecuteCommand(myConnection, commandString);
    }
}

private void ExecuteCommand(SqlConnection myConnection, string commandString)
{
    using (var myCommand = new SqlCommand(commandString, myConnection))
    {
        myConnection.Open();
        myCommand.ExecuteNonQuery();
    }
}

Finally
In conclusion, the final part of the summary advice given in the chapter which states, "Whenever you allocate one disposable object in a method, the using statement is the best way to ensure that the resources you allocate are freed in all cases. When you allocate multiple objects in the same method, create multiple using blocks or write your own single try/finally block." should be ignored in favour of "... When you allocate multiple objects in the same method, create multiple using blocks."

A PDF version of this review can be found here.

First Agile East Anglia Meeting

2011-11-15T08:51:00.001Z

It’s a little later than I was planning for but I’ve fixed a date, time and venue for the first Agile East Anglia meeting:

Date: 5 December 2011
Time: 6.30pm to 8.30pm
Venue: Coach & Horses, Thorpe Road, Norwich

I’ll aim to get there between 6pm and 6.30pm and will be there until at least 8.30pm. There are at least two Coach & Horses in Norwich. Please make sure you come to the one on Thorpe Road near the Railway Station in Norwich. Please try and let me know if you intend to come. Either by replying to this message or emailing me: paul.grenyer@gmail.com.

As with XTC in London, there’s no agenda or format. It’s just an opportunity for those interested in or practicing Agile to get together for an informal chat. In the future if people would like to have more structure or speakers, that can be arranged. Please feel free to bring anyone else interested along with you.

Although XTC meet weekly I think that might be a little optimistic for Norwich at this stage. So if all goes well I’ll plan the next meeting for early January.

I look forward to seeing you all.

Opeth

2011-11-13T11:49:00.001Z

O2 Academy Birmingham
Saturday 12th November 2011

The last time I was a the Academy in Birmingham was February two years ago for Lamb of God and Dimmu Borgir. Both were very good, but the people there were rude and inconsiderate. Last night was very, very different. Lots of friendly people and the staff were great. In fact London venues have a lot to learn.

Opeth did not play a single song that I would have asked for! Having resisted the urge to play their new album all the way through, they instead opted for a more progressive, less death metal approach, playing both some new and old songs. There's was no Blackwater Park and no Daemon of the Fall. Mikael Åkerfeldt was on fine form. Talking to the audience for long periods between songs, even getting the audience to participate in a Napalm Death cover. I loved it! Can't wait to see them again.

The Devil's Orchard
I Feel The Dark
Face of Melinda
Porcelain Heart (with drum solo)
Nepenthe
The Throat of Winter
Credence
Closure
You Suffer (Napalm Death cover)
You Suffer (Napalm Death cover)
You Suffer (Napalm Death cover)
You Suffer (Napalm Death cover)
Slither
A Fair Judgement
Hex Omega
Folklore

Working Effectively with Legacy Code

2011-11-10T09:55:00.001Z

by Michael Feathers

ISBN-13: 978-0131177055

This is my second read through of Working Effectively with Legacy Code. I don’t usually read books twice, but it was being used as the material for an ACCU Mentored Developers project I was running.

Working Effectively with Legacy Code is almost as relevant now as when I read it in 2007. The only real thing that dates it are some of the links to pages that have moved on and some of the techniques which were new then, but are far more widely understood now. A credit to the book in a lot of ways.

Both times that I read it I felt that it didn’t teach me much that I hadn’t already learned during my career. I have been exceptionally fortunate to have worked with or been associated with some of the best developers in the world, so it was inevitable that I would pick this stuff up. Many developers are not so fortunate and that is why this book remains in my top ten.

All of that aside, this book contains surprisingly practical advice. I remember seeing Michael Feathers presenting at an ACCU conference and the room, including myself, being up in arms about using inheritance to mock out the methods of a class under test. Now I’ve read the book I understand that is just a first step to get the class under test before you refactor.

Singleton is a pattern that comes up again and again in all sorts of books (I’m reading a UML book at the moment and it’s even there!). One of the problems with singleton is that it is difficult to test. Feathers shows how you can get a singleton in existing code under test before you refactor it out. This is not the same as advocating singletons.

Feathers describes techniques for getting code under test that I had considered in the past and dismissed as far too complicated to be useful, but he makes them simple and straightforward. I could go on and on with example after example but the bottom line is that even if you’ve been fortunate in your career, you should read this book to get even the smallest bits that you haven’t considered.

Catalina-Ant for Tomcat 7

2011-11-09T12:45:00.007Z

I recently upgraded from Tomcat 6 to Tomcat 7 and all of my Ant deployment scripts stopped working. I eventually worked out why and made the necessary changes, but there doesn’t seem to be a complete description of how to use Catalina-Ant for Tomcat 7 on the web so I thought I'd write one.

To start with, make sure Tomcat manager is configured for use by Catalina-Ant. Make sure that manager-script is included in the roles for one of the users in TOMCAT_HOME/conf/tomcat-users.xml. For example:<tomcat-users> <user name="admin" password="s3cr£t" roles="manager-gui,manager-script"/> </tomcat-users>
Catalina-Ant for Tomcat 6 was encapsulated within a single JAR file. Catalina-Ant for Tomcat 7 requires four JAR files. One from TOMCAT_HOME/bin:

tomcat-juli.jar

and three from TOMCAT_HOME/lib:

catalina-ant.jar tomcat-coyote.jar tomcat-util.jar

There are at least three ways of making the JARs available to Ant:
1. Copy the JARs into the ANT_HOME/lib folder. Then Ant will just find them.
2. Copy the JARs to a folder within your project that you check into your source control system. Ant then needs a path id to find them:
```
<path id="catalina-ant-classpath">
    <fileset dir="${catalina-ant-dir}">
        <include name="catalina-ant.jar"/>
        <include name="tomcat-coyote.jar"/>
        <include name="tomcat-util.jar"/>
        <include name="tomcat-juli.jar"/>
    </fileset>
</path>
```
  Where catalina-ant-dir is the directory with the JARs in. This way you don’t need to modify the Ant installation on every machine you build on.
3. Access the JARs directly from your Tomcat 7 installation. Ant then needs a path id to find them:
```
<path id="catalina-ant-classpath">
    <fileset dir="${appserver.lib}">
           <include name="catalina-ant.jar"/>
           <include name="tomcat-coyote.jar"/>
           <include name="tomcat-util.jar"/>
        </fileset>
    <fileset dir="${appserver.home}/bin">
               <include name="tomcat-juli.jar"/>
    </fileset>
</path>
```
  Where appserver.lib is the path to Tomcat 7’s lib directory and appserver.home is the path to Tomcat’s top level installed directory. This way Tomcat 7 is required on every box you build on.
My personal preference is for 2 above.

Now that your Ant script can see the Catalina-Ant JARs you need to tell it what tasks are available. These are most if not all of the tasks that are available to Ant.

<taskdef name="catalina-deploy" classname="org.apache.catalina.ant.DeployTask" classpathref="catalina-ant-classpath"/>
<taskdef name="catalina-list" classname="org.apache.catalina.ant.ListTask" classpathref="catalina-ant-classpath"/>
<taskdef name="catalina-reload" classname="org.apache.catalina.ant.ReloadTask" classpathref="catalina-ant-classpath"/>
<taskdef name="catalina-findleaks" classname="org.apache.catalina.ant.FindLeaksTask" classpathref="catalina-ant-classpath"/>
<taskdef name="catalina-resources" classname="org.apache.catalina.ant.ResourcesTask" classpathref="catalina-ant-classpath"/>
<taskdef name="catalina-start" classname="org.apache.catalina.ant.StartTask" classpathref="catalina-ant-classpath"/>
<taskdef name="catalina-stop" classname="org.apache.catalina.ant.StopTask" classpathref="catalina-ant-classpath"/>
<taskdef name="catalina-undeploy" classname="org.apache.catalina.ant.UndeployTask" classpathref="catalina-ant-classpath"/>

Finally you need a set of tasks that actually do the work. Although, as you can see above, there are a few tasks I only tend to use the following ones:

<target name = "stop-webapp">
       <catalina-stop url="${tomcat.manager.url}"
                         username="${tomcat.username}"
                         password="${tomcat.password}"
                         path="/${webapp.name}"
                         failonerror="false"/>
</target>

<target name = "start-webapp">
    <catalina-start url="${tomcat.manager.url}"
                       username="${tomcat.username}"
                       password="${tomcat.password}"
                       path="/${webapp.name}"/>
</target>

<target name = "undeploy-webapp">
    <catalina-undeploy url="${tomcat.manager.url}"
                          username="${tomcat.username}"
                          password="${tomcat.password}"
                          path="/${webapp.name}"
                          failonerror="false"/>
</target>

<target name = "deploy-webapp">
    <catalina-deploy url="${tomcat.manager.url}"
                        username="${tomcat.username}"
                        password="${tomcat.password}"
                        path="/${webapp.name}"
                        war="file:${war.file}"/>
</target>

tomcat.manager.url is the URL where Tomcat manager lives. This is another of the changes from Tomcat 6 to Tomcat 7. Usually this will be: http://:8080/manager/text.

Tomcat.username and Tomcat.password are the user name and password for Tomcat manager.

webapp.name is the name of the Tomcat application that you are deploying.

war.file is the path the Tomcat application you are deploying’s WAR file.

The stop-webapp task has the failonerror attribute set to false as on most occasions you don’t want the Ant build to stop if a Tomcat application you’re trying to stop isn’t running.

I usually define all of these properties in a properties file that Ant can read. That way local settings can be picked up more easily if builds are run on different machines.

Agile East Anglia

2011-10-29T14:15:00.001+01:00

Inspired by the Extreme Tuesday Club (XTC) in London, Agile East Anglia's intention is to organise regular informal meetings for people new to Agile, Agile practitioners and Agile experts to meet, discuss ideas and network.

I'm hoping to arrange the first meeting in late November at the Coach and Horses on Thorpe Road in Norwich.

You can join Agile East Anglia here.

Edward Jeremy Paul Grenyer

2011-09-22T13:49:00.003+01:00

Date: Tuesday 20th September 2011
Time: 6.34pm.
Weight: 7lb 1oz

An Introduction to the WPF with the MVVM - Part 2

2011-09-22T13:35:00.002+01:00

Originally published in CVu.

In part 1 of An Introduction to the Windows Presentation Foundation with Model-View-ViewModel I introduced the Canon application. I used it to introduce you to simple WPF UI development and the Model-View-ViewModel pattern including simple binding and commands.

Part 2 is focused around making the GUI look more aesthetically pleasing and introducing menus and tool bars and demonstrating system commands. I'll start off by introducing images.

Read More

Parts 1 & 2 combined can be found here.

Clean Code

2011-09-22T12:25:00.003+01:00

by Robert C. Martin
ISBN: 978-0132350884

I knew this was going to be an excellent book from the moment I heard Uncle Bob describing his ideas of Clean Code at his key note at an ACCU conference. I bought the book there and then, but didn't start reading it until a couple of years later. More recently I got it signed by Uncle Bob at Skillsmatter. After just a few pages it propelled itself into my top three books every programmer should read (behind Kent Beck's Test Driven Development and The Pragmatic Programmer by Andy Hunt & David Thomas) and at the end it's still there.

The chapter on comments is worth the price of the book alone. I have worked in places over the last few years, where comments have been encouraged to explain the code, rather than writing code that explains itself. Another great chapter is the one on functions and the advice to keep them small is especially good and compelling. As I look back over the table of contents now, every chapter that describes how to improve an aspect of code is an absolute mine of good advice.

The final few chapters contain a number of refactorings. One on an application from the ground up and the others on existing code written by other people. This is the only place where the book got gratuitous and I must admit I skipped most of the final refactoring.

The final chapter is a summary of the advice given in the rest of the book and something I will find myself referring to again and again.

If you've read Test Driven Development and The Pragmatic Programmer, make sure you read Clean Code next.

Our House Is For Sale (Again)

2011-09-07T13:12:00.001+01:00

3 bedroom town house for sale
Marauder Road,Old Catton,Norwich,NR6

MODERN 3 story home in Catton which features living room with Juliet balcony, separate dining room, kitchen/breakfast room, downstairs cloakroom, 3/4 bedrooms with en-suite shower room to master, bathroom, gardens, parking & garage. CALL LINK UP PROPERTIES ON (01603) 76 40 40 TO VIEW.

See this property on rightmove.co.uk

C# In Depth

2011-08-31T18:39:00.002+01:00

Jon Skeet
ISBN: 978-1935182474

Let's get one thing straight, every single C# developer with a working knowledge of the language should read this book. I picked it up because it had been three years since I'd written any C# (I'd been doing Java) and back then all I had exposure to was version 1.1. I knew nothing of var, LINQ, Lambdas, extension methods or dynamic typing. I guessed a little about generics from my Java knowledge. I've read the book and now I know about all of them. Of course I don't know everything about all of them but I know enough to make use of them. If I went back and read the book again and again I would increase my knowledge of these features with each read.

This is not an introductory text. The book starts off with a a brief tour of C# 1.1. It then goes through all of the recent versions, 2.0, 3.0, 3.5 and 4 introducing most of the new features as it goes. It does what it says on the cover, it goes into each feature in depth. This is both the books strength and its weakness.

There is so much information in here that at times it is very heavy going. I will admit that I skipped a few sections when I felt that I knew enough and knew I could go back to it at any time. If I'm brutally honest, I feel that this book could be pruned quite a bit and still be in depth. Alternatively, maybe a text that gave an overview of the various features with some examples would have been more suitable for me.

Jon Skeet is clearly a C# junkie and very passionate about the language. Jon, you'll be glad to hear it does all make sense!

Pragmatic Version Control using Git

2011-08-17T08:16:00.001+01:00

Travis Swicegood
ISBN-13: 978-1934356159

I was an early adopter of Subversion after having used CVS for a little while. I've come rather late to the Git party and I wanted a book that would give me a quick, yet solid, introduction. Pragmatic Version Control using Git is just such a book. I really like the Pragmatic Programmer books as they tend to be short and easy to read. They allow me to absorb a lot of information in a very short period of time.

The first thing that struck me was the brilliant simplicity of the example code. Many books on version control use Java as a language that is easily understood by most people. Even with Java you need a fair bit of code before you've got a program that does anything, even Hello, World! Swicegood uses HTML as his example code. This is perfect because everyone can understand it easily and you only need a little to do some interesting things. The HTML example is used throughout the book, in my opinion, very successfully.

Git itself took me a little by surprise. Having a local copy of the whole repository felt a little extravagant at first and it took me a while to get my head around the idea of having to add a file every time I want to commit it, even if I've committed a previous revision. However, Swicegood explains how and why you do both of these very well and now I see the benefit of local copies of a repository and having a staging area.

Branching is key to Git and Swicegood explains it in a lot of detail. The book closes with a chapter on Subversion and CVS integration and migration with Git and a chapter on setting up a Git server. The only disappointment for me was the sparse descriptions of GUI clients. I am totally addicted to TortoiseSVN and would have liked to have seen a Git equivalent explained in some detail.

Available on the Kindle here.

Terminal World

2011-08-11T22:00:00.001+01:00

by Alistair Reynolds
ISBN-13: 978-0575088504

I waited a long, long time for Terminal World. Even though it came out for the kindle at around the same time as the hardback, I had a feeling the price would come down at the same time as the paperback release. It was worth the wait, as a week after the paper back release the kindle version halved in price.

I'm afraid it's the same old story (no pun intended) with Alistair Reynold's post Revelation Space work. It lacks the depth and breadth and just isn't as good. And like House of Suns and Pushing Ice it sets the scene for a sequel, but you're left wondering if a sequel will ever materialise.

I did, however, love the characters in this book, especially Meroka. She was a real, down to earth, tell it like she sees it kind of a girl. If I met her on a dark night, I would want to be on her side! The main character, Quillion, who started off looking like he was going to be a weak, weaselly sort of a person turned out to be really strong. I think the book could have explored his past a bit more.

Parts of Terminal World really did have me gripped. The climax was a little disappointing and lacked Reynold's usual attention to detail and complexity. It's almost as if he got bored and didn't follow it through properly. The actual theme that was played out did take me by surprise, I still came away not feeling I fully understood everything. Maybe that was the idea?

I believe Reynold's next book will be for children. I'll still read it, but I imagine it'll be quite different. Hopefully still dark and full of space opera though.

An Introduction To Test Driven Development

2011-08-08T15:23:00.002+01:00

Originally published in Overload 104

There are a lot of introductory articles for Test Driven Development (TDD). So why, might you ask, am I writing yet another? The simple answer is because I was asked to by Allan Kelly who wanted a piece for a small book he gives to his clients. I was happy to oblige, but writing about TDD is difficult. In fact if Allan hadn't wanted an original piece he could print as part of his book I would have suggested he just get a copy of Test Driven Development by Kent Beck. The main difficulty is coming up with a suitably concise, yet meaningful, example and Beck has already done this.

Allan was also quite keen for me to publish elsewhere, so I chatted the idea over with Steve Love, the editor of the ACCU's CVu magazine to see if he thought the readers would be interested in yet another TDD article. He said they probably would be as long as I thought carefully about how I wrote it. I thought this over for a long while. The majority of introductory TDD articles, at least the ones I have read, focus on unit testing. A recently completed ACCU Mentored Developers project read through Growing Object Orientated Software Guided by Tests by Freeman & Pryce. They focus on starting a simple application with acceptance tests and only writing unit and integration tests when the level of detail requires it or the acceptance tests become too cumbersome. However, it is a big book, so I decided to try and condense what I saw as the most important points into an introductory article and this is what you see before you. I hope you find it as useful and fun to read as I did to write.

Read more here.

R.I.P Andrew 'Mac' McDermott

2011-08-05T08:06:00.003+01:00

The first time I encountered Threshold was at the first (of only two) ProgPower UK in 2006. I thought they were good and bough all their stuff. They turned out to be fantastic and Andrew 'Mac' McDermott's voice was just incredible. Unfortunately that was to be the only time I would see Threshold with Mac as he left the band shortly after the release of Dead Reckoning. It was a double shame as my wife and I had planned a short honeymoon so that I would be back in time to see them play in Nottingham at Fire Fest.

I found out yesterday that Mac died on 3rd August 2011. It's a real shame. Although it was highly unlikely I would see Mac sing again with Threshold, I had hoped for plenty more material with his other projects and maybe even to see him live.

He and his voice will be missed.

http://rememberingandrewmacmcdermott.webs.com/

Russel Winder: You Need To Know Python

2011-08-03T19:49:00.002+01:00

Skills Matter Tuesday 2nd August

As I've said before, I love seeing Russel speak. He was on form again tonight, despite his migraine. One of the reasons I like seeing Russel speak is his sense of humour. Although, there is always a sensible and serious message behind it.

Tonight I think the message was really that knowing multiple programming languages and paradigms makes you a better programmer in all of them. The reason Russel chose Python is that he clearly has a deep fondness for the language. It has always appealed to me, so much that I write acceptance tests for my .Net applications in IronPython.

Harking back to Uncle Bob's talk a few weeks ago, Russel started with a whirlwind tour of programming languages through time, starting with FORTRAN through to the creation of C and the world domination of C++ that was eventually, according to Russel, killed off by Java. I'm not sure I agree with Russel here. I suspect what he actually means is that within academic institutions Java took over from C++ on computer science courses. I was certainly still programming in C++ in 2006 and didn't switch to Java until later. Conspicuous by their absence all the way through, were all the Microsoft languages. Russel clearly isn't a fan. Last came all the new dynamic languages such as Ruby and Clojure. Where was Groovy, Russel's favourite, I hear you ask? It was in the mix too. Unusually Russel only mention Groovy a couple of times tonight. The focus, as expected, was very much Python.

Then we got into the heart of the presentation and Russel explained his thinking and delivered his message that knowing multiple programming languages and paradigms makes you a better programmer in all of them.

In the final part of the talk Russel examined some of latest features of Python, including with, its take on C++'s RAII. I am almost entirely unimpressed with garbage collected languages versions of RAII. So much so I'm going to write a blog post. Watch this space. Finally he discussed one of the most important issues of our time, concurrency and parallelism. Python is unprepared, but it's being worked on.

The video of Russel's talk is link from his blog here.

Agile Cambridge: Creating a Walking Skeleton from Scratch

2011-07-30T11:30:00.003+01:00

11am Thursday 29th December 2011

Come and see me at Agile Cambridge.

Session

Starting with an (almost) clean IDE Paul will develop a Walking Skeleton.

The walking skeleton was described by Alistair Cockburn as "... a tiny implementation of the system that performs a small end-to-end function. It need not use the final architecture, but it should link together the main architectural components. The architecture and the functionality can then evolve in parallel." It is also one of the theme's in Freeman & Pryce's Growing Object Orientated Software Guided by Tests.

In this session Paul will start with an (almost) clean IDE and develop a walking skeleton for a simple application and demonstrate how Test Driven Development (TDD) can be used even at the system level to test features.

Profile

Husband, father, software consultant, author, testing and agile evangelist.

Paul has been programming in one form or another for over 20 years and has been involved in building agile teams since 2007. After several years of C++ and a very happy period using Java, Paul is now developing predominantly in C#.

Paul has worked in industries as diverse as marking machinery, direct mail, mobile phones, insurance and Internet TV. He is currently contracting at an investment bank at Canary Wharf.

When he's not programming or chasing his 2.5 children, Paul thoroughly enjoys science fiction, heavy metal and cycling.

Mocking C++

2011-07-22T08:38:00.003+01:00

This month’s ACCU London was at 7City to hear Ed Sykes tell us about a couple of C++ mocking frameworks, MockIt Now and HippoMock. Ed is a very relaxed, confident speaker and the code and demonstrations he used were simple, straight forward and easy to understand. I mostly came a long to meet Ed as he’s an excellent contributor to the ACCU and specifically the Mentored Developers projects.

Ed obviously hit a chord with the audience and there was plenty of interaction and question asking. There were even a few tangents that Ed handled brilliantly. It looks like both of these frameworks use quite a bit of compiler magic and function pointer repointing, along with macro magic to achieve in C++, what is easily achieved with reflection in the likes of Java and C#.

Following the short presentation there was a long discussion on the more general topic of mock objects. Even though I haven’t used C++ for a little while, this presentation was absolutely fascinating and I will definitely be using a mock framework on my next C++ project.

Behavior Driven Development

2011-07-20T18:55:00.002+01:00

While collaborating on a new article I was recently pointed in the direction of Behavior Driven Development (BDD) by Chris O’Dell. I only thought I had a vague idea of what it was before and I got so absorbed in Behavior Driven Development on Wikipedia and Dan North’s Introducing BDD today that I missed my stop on the tube. I never miss my stop on the tube!

There are two main points that stood out for me.

I usually develop software inside out. Start with the model and then add the user interfaces on top. Dan North tells us that the first thing that we should do is get the user interface going and then show it to the customer/user to get immediate feedback. This is actually far more sensible as the user interface is what the users see and use, so they can tell you if it’s right or how it needs to be changed. Then you can develop the model to suit, rather than the other way around.

For while now I have been looking for a good way to record acceptance criteria with user stories and I think I’ve found it. Dan gives and example of an ATM:

To illustrate, let’s use the classic example of an ATM machine. One of the story cards might look like this:

+Title: Customer withdraws cash+
As a customer,
I want to withdraw cash from an ATM,
so that I don’t have to wait in line at the bank.

So how do we know when we have delivered this story? There are several scenarios to consider: the account may be in credit, the account may be overdrawn but within the overdraft limit, the account may be overdrawn beyond the overdraft limit. Of course, there will be other scenarios, such as if the account is in credit but this withdrawal makes it overdrawn, or if the dispenser has insufficient cash.

Using the given-when-then template, the first two scenarios might look like this:

+Scenario 1: Account is in credit+
Given the account is in credit
And the card is valid
And the dispenser contains cash
When the customer requests cash
Then ensure the account is debited
And ensure cash is dispensed
And ensure the card is returned

Notice the use of “and” to connect multiple givens or multiple outcomes in a natural way.

+Scenario 2: Account is overdrawn past the overdraft limit+
Given the account is overdrawn
And the card is valid
When the customer requests cash
Then ensure a rejection message is displayed
And ensure cash is not dispensed
And ensure the card is returned

Both scenarios are based on the same event and even have some givens and outcomes in common. We want to capitalize on this by reusing givens, events, and outcomes.

Of course there is a lot more to BDD, than I have described here, but these are the inspirational particles for me.

An Introduction to the WPF with the MVVM - Part 1

2011-07-15T21:34:00.004+01:00

After three wonderful years working with Java I am back in the C# arena and amazed by how things have changed. When I was working with C# previously it was with .Net 1.1 and as I return .Net 4 is ready to go. I started a new contract and my client suggested that to get ahead of the game I should learn Windows Presentation Foundation (WPF), the latest Microsoft framework for creating Windows desktop (and web) applications. It replaces the likes of Windows Forms on the desktop. Two of the major features of WPF are that it is rendered entirely on a computer's graphics card and separates presentation from presentation logic.

Manning is my preferred technical book publisher, so I bought the PDF version of WPF In Action with Visual Studio 2008 and read it on my Kindle. It is a great introduction to producing Graphical User Interfaces (GUIs) with WPF, but I later discovered that although Model-View-ViewModel (MVVM) is covered, the detail is not great. The MVVM pattern is similar to Martin Fowler's Presentation Model, but where the presentation model is a means of creating a UI platform-independent abstraction of a view, MVVM is a standardised way to leverage core features of WPF to simplify the creation of user interfaces. Fortunately there is a great MSDN Magazine article called WPF Apps With The Model-View-ViewModel Design Pattern that explains it simply and in a fair amount of detail.

To demonstrate WPF with MVVM I am going to incrementally develop a small application which allows the user to search an archive of books. The application is called Canon and the source code is available for download from my website. I developed Canon using Visual Studio 2010 and .Net 4, but WPF applications can also be created with Visual Studio 2008 and .Net 3.5. I have assumed that the reader is following along.

Read more. Originally published in CVu.

Canon-0.0.1.zip

JVM Cloud Platforms

2011-07-15T07:56:00.003+01:00

Tonight kicked off with the usual high quality lightening talks that I have come to expect form the London Java Community.

The two main presenters spoke individually about the cloud solutions that their individual companies offered. I know little to nothing about cloud computing. The emphasis was centred around Platform As A Service (PaaS). It appears that most of the major players (Amazon, google, etc) do not provide a private PaaS for testing and development. I find this astounding, despite the fact that I have worked with at least one major vendor who makes it very expensive to have a development environment, but at least it was still possible.

The stronger of the two systems described seemed to be the offering from SpringSource. Peter Ledbrook (Grails Advocate and ACCU Mentored Developers mentor) is a very interesting speaker. He has clearly been bitten by live demos not working in presentations before and, alas, he was bitten again tonight. Although, the previous speaker also had a problem with his live demo.

The more I hear about cloud computing, the more interested I get. With the two offerings this evening there is the opportunity to try it for free to get a real feel for it. However, I just don’t have a sufficient interest yet or a cloud suitable application to make it worth the while. Maybe my next contract.

You can see the video here.

One Test Or Two?

2011-07-14T10:30:00.004+01:00

Paul Grenyer & Chris O’Dell

"I know what you’re thinking: “Is that two tests or only one.” Well, to tell the truth, in all this agility, I’m not sure myself. But this is Test Driven Development, the most power development technique in the world, and could give you clean code, you’ve got to ask yourself one question: Do I feel expressive? Well, do ya, punk?"<

Paul: I have a Windows Presentation Foundation (WPF) application that loads a list of widget names from a database and uses them to populate a drop down box. There is no default widget, so the user must select one from the list and click the load button to load it. The behavior is such that before a widget name is selected the button is disabled and cannot be clicked.

One pattern often employed in WPF applications is Model-View-ViewModel. The view model can use variations of the Command Pattern for processing commands from and giving feedback, such as the enabled state of a button, to the View. MVVM is intended to give separation between a view and its logic. Therefore the view model is usually devoid of User Interface (UI) code and easy to instantiate and run unit tests against.

I have a unit test that instantiates a view model and checks that the load command cannot be fired until a widget name is selected. A simplified version is show below, without the view model instantiation:


public void testThatExecuteIsOnlyPossibleIfNameIsSet()
{
  Assert.IsNull(model.Name);
  Assert.IsFalse(model.CanExecute());
  model.Name = "Something";
  Assert.IsTrue(model.CanExecute());
}

Recently I have also been involved with the ACCU Mentored Developers project based around Growing Object Orientated Software Guided By Tests by Steve Freeman and Nat Pryce. In this book they write a lot about the naming and granularity of tests. So I posted the above code to the list and asked what the project members thought: “Should the above test be one test or two?”.

Chris: Without blinking I immediately replied that the above should definitely be split into two distinct tests so that a failure would be obvious from the test name. The above test has two asserts and as such either of these could fail.

Paul: Chris, and all the others who replied are of course right on the money (no one suggested it should only be one test), but something didn’t sit quite right with me. In this small example the extra code of two tests is not very much: the method definition, a pair of curly braces and some spacing. The problem for me is that test classes should not be treated that much differently to normal classes and any class with with a large number of methods becomes difficult to maintain and difficult to even to navigate. Although modern IDEs do make this easier with regions (C#) and code collapsing (Eclipse).

Chris: I firmly believe that it is worth the extra code - as many others also remarked, the five minutes now and extra curly braces could easily save twice that if you need to hunt down a related bug in future.

I went on to explain that in terms of application logic the two scenarios “with a name” and “without a name” are expected to be mutually exclusive and the two tests will ensure this by isolating each scenario and addressing them individually - with explicit test names.

In regards to the large classes this can be tackled by breaking your tests down into smaller classes, generally per scenario. For example, group all of the positive “happy path” tests together into one class and all the negative, error handling tests into another class and store both classes in a folder given the name of the class under test.

Paul: Again, Chris is of course right. Although the implication that a test method should only have a single assert is a whole other discussion.

Then Nat Pryce came along with another suggestion altogether:

“To really play Devil's advocate, I think there should be THREE tests!

1. The model initially has no name
2. The model cannot execute when it has no name
3. The model can execute when the name has been set.

You could squeeze that into two:

1. The model initially cannot execute
2. The model can execute when the name has been set

But I think the state transitions and constraints are clearer with three tests.”

Even with there now being the extra code for three functions, rather than one, this is of course the answer. It even satisfied the idea of one assert per method. The most difficult idea for me was not testing preconditions specific to a test if they were already tested in a another test .I have consequently modified my way of thinking and a lot of my test code.

Originally published in CVu July 2011.

The Last Programming Language

2011-07-13T22:59:00.003+01:00

Tonight was mostly about entertainment and Robert C. Martin had me in stitches for most of the evening. He started off, as I gather he often does, by seeing who in the room could recite PI to any number of decimal places and how he lost a PI off to Herb Sutter.

Throughout his talk Uncle Bob mentioned most of the languages and paradigms of the last 60+ years and gradually brought us to the idea that nothing much that was really new has come about since around 1965. He went on to tell us that he thought that programming would converge into a single language. He even told us what that language would be, but I'm not going to spoil his surprise.

If you ever get the chance, go and listen to Uncle Bob! It's 100% geeky fun with a serious message. And I got my copy of Clean Code signed.

See the video here.

Progressive Psychedelic Pulp

2011-07-10T17:57:00.002+01:00

Hyde Park, Sunday 3rd July 2011.

I was only meant to be playing the role of taxi driver, but after most of the party dropped out, my wife talked me into going to Hyde Park to see Pulp with her. I wasn't really looking forward to it as I was expecting a 90 minute set with probably only a couple of songs I knew. I couldn't have been more wrong! There were only a couple of songs I didn't know!

We got to the festival just in time to catch Grace Jones. The best that can be said about her is that she has a great voice, but bad songs. She finished with a Roxy Music cover of Love Is The Drug and Slave to the Rhythm, so it wasn't all bad.

By the time Grace left the stage we'd been allocated some seats. Sometimes having a pregnant wife is an advantage!

I really wasn't expecting Pulp to do the big arena/festival thing either, but they did. They started with a big black curtain in front of the stage onto the back (stage side) of which they shone a lazer. A camera replayed what the lazer was writing to the audience via the large screens at the side of the stage: "Do you remember the first time?", "Are you ready?", "Again, are you ready?", etc. Then the curtain fell to the sound of streamers exploding into the crowd and there was Jarvis et al ripping through Do You Remember The First Time. From then on it was hit after hit including Sorted For Es And Whiz and Disco 2000.

I thought Jarvis would be too "cool" to stand on the monitors, but all he needed was a bass guitar and he could have been Steve Harris. He charmed the audience after every song proving what a great performer he is. The band was note perfect and the quality of the PA surprising.

Towards the end of the set Pulp did a couple of songs from the album that apparently followed Different Class. I could only describe them as Progressive Psychedelic Pop and really quite good, further proving what talented musicians they are. Then there was just time for a couple more hits, before the band, sensibly, didn’t waste time going off prior to an encore. Of course the final song was Common People, preceded by by a teasing description of St. Martin’s college form Cocker.

Was I impressed? Yes! Was I pleased I’d gone? Yes! Would I go to see Pulp again? Maybe.

Transformers: Dark Side of the Moon

2011-07-10T14:02:00.001+01:00

We enjoyed the first transformers film, but didn't think much of the second. However the trailer for Transformers Dark Side of the Moon was excellent. The first ten minutes of the film, which featured the first moon landing, was superb. Then the film fell apart. It's not just that the Witwickey character is rubbish or the fact that the Autobots are a bit soft, but the language, the sex and the violence is way too much for a 12A.

Having seen the first two films we thought we were in safe territory. We'd taken our son for his 8th birthday, along with a friend, and my wife and I were wincing most of the way through. The language was very frequent and gratuitous, including at least one use of the F word. There was a lot of flesh on show in the opening scenes with Whitwiky. Once the film got going, there was a lot of gratuitous violence, including Transformers machine gunning humans in an office block through the window and Transformers vaporising humans leaving only a skull rolling away. What were the classifiers thinking?

As well as language, sex and violence the film just seemed to go on forever. There was a plot discrepancy where Megatron cuts Sentinel Prime's head off and a few minutes later it's on again when he fights with Optimus Prime.

Don't take your children to see this film.

It's Always Nice To Get A Mention...

2011-07-07T21:32:00.003+01:00

Please go along and read this new blog post by Agile Coach Rachel Davies on When To Write Story Tests.

Threshold @ The Peel 2011

2011-07-02T17:39:00.003+01:00

Threshold are simply amazing. Ok, so they are my favourite band, so I may be a little biased. I have seen them six times now, almost as many times as I've seen Terrorvision and the Wildhearts, and they get better every time.

Threshold should be playing places much, much bigger places than The Peel in Kingston, but I am so glad they aren't. In these tiny venues you can get right up and personal with the band. Not only that, but the band walked into the Pizza restaurant my friends and I were enjoying before the gig, Damian Wilson was on the door talking, as he always is and the remainder of the band were reportedly in the bar signing stuff after the gig.

With no support they played a stonking two hour set with something from every album except Psychedelicatessen:

Slipstream
The Ravages of Time
Long Way Home
The Destruction of Words
Hollow
Sanity's End
Falling Away
Clear
Ground Control (acoustic version)
Pressure
The Art of Reason
This Is Your Life
Pilot in the Sky of Dreams
Mission Profile

Encore:
One Degree Down
Light and Space

Damian Wilson only sang originally on two of the songs in the set (Sanity's End and Clear), but he makes every song his own. At the end of a Fish gig I look forward to him pirouetting into the crowd during External Exile. Damian must have been into the crowd four or five times throughout the set, mostly due, I imagine, to the lengthy instrumental breaks in most of the songs. Forget Freddie Mercury, Damien Wilson is the ultimate frontman and his charismatic ability as frontman is second only to his incredible singing ability. It's going to be interesting to hear his vocals on a new Threshold album for the first time since 1998's Extinct Instinct.

I could listen to Karl Groom play guitar all night! In my opinion he is second only to David Gilmour, but he looks like someone's uncle! In fact all of the band and a lot of the crowd are firmly into middle age. Does it show in the heavy progressive metal they play? Does it stop the crowd being louder than the PA? Of course not!

I can't wait for the new album and to see them play again. If you only every see one progressive metal band, make sure it's Threshold!

Fallen Dragon

2011-06-28T20:22:00.003+01:00

by Peter F. Hamilton
ISBN: 978-0330480062

This is the first Peter F. Hamilton book I have read. It's a big book and proper science fiction. I liked it a lot. In fact bits of it I thoroughly enjoyed. However, it's nothing special and really quite predictable. Although I didn't see the final little twist right at the end coming. From what I had heard I expected a bit more from Peter F. Hamilton, but I will certainly be reading his other books.

The characters are superb. I really related to them, especially the young Laurence when he met, loved and lost Roslyn. I spent the whole book wanting him to get her back. I won't tell you if he did or not. I found Laurence's disgust at the idea of real food interesting on a couple of levels. First there is all the aversion to processed food in modern society and then I remembers the children in James Follett's Earth Search entering puberty when they finally stopped eating the processed food provided by the Angels.

Spring Roo at Skills Matter

2011-06-22T21:56:00.004+01:00

I've just got back from a fantastic presentation on Spring Roo from Jan Machacek of Cake Solutions. It was hosted at Skills Matter by Barry Cranford of the London Java Community. I came away totally understanding what Spring Roo is for.

In a few words, it's code a generator that gives you a boost when creating Java and Spring MVC based web applications. It uses a lot of Aspect Orientated Programming (AOP) to take away a lot of the boiler plate code, such getters and setter on beans and persistence, that are required for CRUD web applications. If, after the application is completed, you want to stop using Sprig Roo, you can. If you want to keep using it to generate more of the application, you can and it examines the code every time you build to see if it can generate more helpers from your changes. It's not a silver bullet or a golden hammer thought, it's another tool in a Java web application developers arsenal.

One draw back for me is that Spring Roo requires Maven (quite possibly one of the roots of all evil) and I don't yet know know enough Grails to know if Spring Roo provides greater advantages for web development.

Jan Machacek is a excellent speaker, very clear and enthusiastic as well as knowledgeable without being arrogant. He clearly understands Spring Roo inside out and was able to answer all of the questions asked. The only frustrating thing was that every time I thought of a question, it was answered a few slides later.

You can see the video here.

Working Effectively with Legacy Code Project

2011-06-09T19:34:00.003+01:00

The ACCU Mentored Developers have recently started a project based on Working effectively With legacy Code (ISBN: 978-0131177055) by Michael Feathers. The project members are reading about a chapter a week, starting on Monday 13th June 2011. Each week a project member will publish a review of a chapter and the group will discuss the chapter and the review on an email distribution list. This all happens under the watchful eye of the book's author, Michael Feathers.

The project is only open to ACCU members, but you can join very cheaply and there are other benefits including an ACCU Conference discount and journals. The project schedule can be viewed here and project distribution list is here.

Execute Around Exception

2011-06-07T22:34:00.004+01:00

I have a lot of UI controller code that looks like this:


try
{
    // Do something that might throw is is probably a single line of code
}
catch (Exception e)
{
    // Notify the user of the problem.
}

This is 8 lines of code for a single line operation. The common code that notifies the user of the error, commonly just a message box, can easily be refactored into a single method. The problem is the try/catch block. So I started wondering if I could reduce it somehow. I would be so much nicer if I could write:


ExecuteSafely(delegate
{
    // Do something that might throw is is probably a single line of code
});

where ExecuteSafely takes care of the boiler plate code. I started playing around with Execute Around Method ideas and came up with this:


public class ExecuteAroundException
{
    private readonly Action<Exception> exceptionHandler;

    public ExecuteAroundException()
        : this(delegate { })
    {
    }

    public ExecuteAroundException(Action<Exception> exceptionHandler)
    {
        this.exceptionHandler = exceptionHandler;
    }

    public void ExecuteSafely(Action action)
    {
        try
        {
            action();
        }
        catch (Exception e)
        {
            exceptionHandler(e);
        }
    }
}

The default exceptionHandler does nothing. It just swallows the exception. The chances of you wanting to use it are therefore slim. However you can provide a delegate that handles the exception:


ExecuteAroundException x = new ExecuteAroundException(delegate(Exception e)
{
    // Notify the user of the problem.
});

And then you can use it like this:

       
x.ExecuteSafely(delegate
{
    // Do something that might throw is is probably a single line of code
});

The only two scenarios where this is worth while is when the ExecuteAroundException instance is created once at class scope or created in a factory method. Otherwise you end up with almost as much code.

Cerebral Bore

2011-06-06T20:09:00.002+01:00

I buy a lot of music so I don’t often get a chance to blog about it. However Cerebral Bore are really something else. Hailing from Scotland and with a singer from Holland they’re the best death metal band I’ve discovered since Annotations of An Autopsy. I originally read about them in Metal Hammer, where they were described as concerned no one would take them seriously as they are a death metal band with a female vocalist. After the success of Arch Enemy I really couldn’t believe it would be a problem, so I bought their debut album Maniacal Miscreation and I wasn’t disappointed.

Growing Object-Oriented Software, Guided by Tests

2011-05-31T21:04:00.002+01:00

by Steve Freeman and Nat Pryce.
ISBN 978-0321503626

I'll cut straight to the chase: This is a great book! In fact I'd put it second, behind Test Driven Development by Kent Beck, on my must read list for developers. Testing is so important and while Unit Testing is becoming mainstream, many are failing to take the next next few steps to integration and system (end-to-end) testing. This book tells you why you should and shows, with practical examples, how to get started.

Growing Object Orientated Software Guided by Tests was the first place I read about the Walking Skeleton. Originally described by Alistair Cockburn, this is a technique I've been using for the last few years and didn't realise there was a name for. The Auction sniper example that covered by the middle chapters introduces not only testing techniques, but lots of useful and practical lessons about good design. The later chapters discuss improving your tests, including readability. The final two chapters cover testing threaded code and asynchronous code. Some of the ideas presented here were new to me and would have have been very useful refactoring exercises for some projects I used to work on.

If you want to develop higher quality, robust software, read and apply the lessons in the book.

Warning: The code examples in the Kindle version of this book are difficult to read and there are a few misprints compared to the paper version.

Triumph TR7 V8 Forsale

2011-05-30T09:00:00.001+01:00

Today is a dark day. My pride and joy is forsale:

http://tinyurl.com/3o37rdy

Triumph TR7 drop head in British Racing Green. Converted to 3.5 litre V8 using a Rimmer Brothers Kit and SD1 engine. Engine modifications include Carter downdraft carburettor (Similar to Webber) and a 4:2:1 twin stainless steel exhaust system (beautiful V8 sound). 15inch alloy wheels, including spare, with Michelin Pilot 205/50 tyres with plenty of tread. Brakes have been uprated with front ventilated discs and 4 pot callipers. The suspension has also been uprated. Tow bar with single socket electronics. Bee Security category 2 immobiliser. Panasonic CQ-FX321N stereo radio with 6 disc CD changer.

The car is in generally good condition but has a few quirks and some surface rust as one would expect from a car of this age. The worst rust is shown in one of the photos. The drivers seat is in poor condition (see photo) but there is a spare driver’s and passenger’s seat to go with the car. The high speed setting for the wipers does not work but there is a replacement wiper motor included. The indicated mileage is 8950 which is believed to be the mileage since the V8 conversion, but this cannot be confirmed. The car is perfectly driveable but could do with some TLC.

The TR7 is a very underrated British sports car. With the original 2.0 Litre engine the performance was unimpressive but the torque of the V8 engine really brings the TR7 alive with the modified suspension and braking system matching the increased performance. This is a real opportunity to obtain a classic high performance convertible at a budget price.

Inspection welcomed and a test drive can be arranged with proof of insurance cover.

The car has been advertised elsewhere and therefore may be withdrawn before the end of the auction.

Agile Cambridge 2011#

2011-05-10T08:46:00.000+01:00

Call for speakers: http://www.agilecambridge.net/ac2011/speak.php

Afterglow by Kevlin Henney

2011-05-02T11:11:00.003+01:00

We all know Kevlin Henney from his technical writings, so I was keen to see what sort of fiction he might write. Before I read it, and even now, I had no idea of what the guidelines set for this short story were, but I was hoping for some science fiction. There wasn’t any, but it was still good.

The subject matter of Afterglow is a little on the dark side and like so many good stories, I had to read it a couple of times to really understand what it was about, who the person telling the story was and what situation they found themselves in now. Along with all the obvious emotion and feeling there is still a slight technical edge in certain places.

Personally I’m looking forward to the next, hopefully longer, piece.

Market Forces

2011-04-24T10:27:00.003+01:00

Richard Morgan
ISBN: 978-0575081260

I did not like this book at all! Which is very disappointing because, despite some slow parts, I've loved everything else I’ve read by Richard Morgan. There were a few good sections, but the book never got going, there was no plot, the climax was quick and disappointing and I had a feeling the whole way through that I was missing something. Maybe I was. As I've implied before, I like my science fiction novels to have science fiction in them and it was mostly missing here. And of course Lackenheath is in Suffolk, not Norfolk. I'm told Black Man is very much better and I won't let one poor story put me off Richard Morgan.

Our House is Forsale

2011-04-13T21:07:00.003+01:00

Dive Into Python

2011-04-13T21:00:00.000+01:00

by Mark Pilgrim
ISBN: 978-1590593561

I used to do the odd bit of Python programming a few years ago and as part of a recent position. I hadn't done any for a year or more and when I came to pick it up again, to write some acceptance tests for a .Net command line application, I found I could hardly remember anything. So I asked some people about good refresher books. Dive Into Python came dubiously recommended.

Dive Into Python is a great book, once you get used to the chatty style and things like “...actually, what I just told you was a lie. The truth is....” and “....you didn't really think that did you? Go and sit in the naughty corner!” Each chapter builds on the next and has copious amounts of examples, all of which are explained in detail line by line. The domain of all the examples are simple and extremely well thought out.

The web service chapters aren't really about web services, but web service clients. I found this rather disappointing. I skipped the chapters on XML manipulation and regular expressions. The chapter on dynamic functions says that you should read the chapter on regular expressions first, but there's really no need as all the regular expressions are explained in detail. The unit testing chapters are very good. The functional chapter is really just an extension of the unit testing chapters. Following the optimisation chapter, the final 20% of the book is appendices.

Dive into Python is available for free here.

Nested Types

2011-04-04T10:27:00.000+01:00

The ideas behind encapsulation and abstraction, to a certain extent, are about you as a developer keeping control of your code and how others use your code. For example if there's an operation in your library that would have bad consequences, you make it difficult or impossible to do.

Developers being able to understand your code is also very important. Putting things in context makes understanding your code easier.

What's my point? Nested types, enums, constants etc, not only help you control the way your code is used, they also identify those nested things as belonging to the context of the class in which they are nested.

Firstborn: A Time Odyssey Book Three

2011-04-01T21:08:00.002+01:00

by Arthur C. Clarke & Stephen Baxter
ISBN: 978-0575083417

I read the other two Time Odyssey books some years ago I seem to remember enjoying them more. It could be of course that since I've discovered Alistair Reynolds and Richard Morgan, Arthur C. Clarke's relatively soft style just doesn't cut the mustard.

I did enjoy this book. I also discovered I'd forgotten most of the story from the previous two. The story develops on three different fronts, Earth, Mars and Mir and I had trouble following the characters from one switch to the next.

Nothing very exciting happens throughout, but it does get better towards the end. In fact I couldn't put the book down for the last 80%. I'll still read Arthur C. Clarke and I do hope Stephen Baxter writes another in the time Odyssey series.

Woken Furies

2011-03-11T16:57:00.001Z

by Richard Morgan

ISBN-13: 978-0575081277

I have read all of Richard Morgan's books in this series up to Woken Furies and this is the best yet. The characters are deeper and more intricate. The plot twists and turns and bubbles with the unexpected. There is more of everything that Richard Morgan does best. There is the odd slow patch as the pace is moderated towards the middle, but it soon picks up again. There are all sorts of questions that materialise throughout the book, some of which are not answered until the end. It takes some following, but is well worth it! I can't wait to read the next one.

Integration Testing A Java Enterprise Application Data Access Layer

2011-03-01T20:20:00.001Z

Finding the best design approach is only part of the solution to writing an Enterprise Application. As with all software, the application must be tested. Unit tests are the first line of defence, but they only the units of the application individually. You also need to test how the units interact with each other and other parts of the application, such as the database. These sorts of tests are called integration tests.

Soon after I discovered unit testing I accidental discovered integration testing. I was writing a system that interacted with a database at just about every stage. So each of my tests would start by creating and populating the database. Then the tests would be run and afterwards the database would be torn down. Creating and destroying the database for each test ensured that it was always in a known state. It also meant that every test took a very long time to run. When I only had a handful of tests this was not too much of a problem. Once I had in-excess of a hundred tests it was a big problem! A general rule is that tests should take close to zero time to run, or people stop running them.

I started to think about how I could improve the performance of my integration tests. So I created a data access layer as is described in my article Data Access Layer Design for Java Enterprise Applications. This enabled my integration tests, which were only masquerading as unit tests, to become real unit tests as they could use a mocked-out data access layer, rather than a real database, there by reducing their run time to almost zero. However, I still needed to write true integration tests to test the data access layer itself. These tests still needed a real database.

Most of the time taken up in setting up and tearing down a database is in its creation and deletion. The actual insertion, update, reading and deletion of data is relativity quick. Most databases support transactions. Transactions prevent a unit of work from being committed to the database until it is completed successfully. If an error occurs part way through the unit of work the transaction can be rolled back and none of the work carried out is committed. If the unit of work is successful it is committed to the database in its entirety once complete.

This can also be applied to testing. At the beginning of an integration test a transaction is started. As necessary, data is inserted into the database and the tests run, which themselves may insert or remove data. Once the test is complete the transaction is rolled back and the database is returned to its original state before the tests. Even if the test fails, the transaction is rolled back and the database returned to its original state.

Once I discovered this I moved the creation of the database structure (the database itself, tables, views, stored procedures, reference data, etc) to my build script and started running my tests in transactions. This greatly improved the performance of my integration tests.

Read more...

The Last Theorem

2011-01-31T17:05:00.001Z

by Arthur C. Clarke & Frederik Pohl

ISBN-13: 978-0007290024

I expect Arthur C. Clarke is turning in his grave. I've quite enjoyed some of his posthumous collaborations, but this novel is just plain bland. There isn't even enough tragedy to keep Steps happy, let alone the Begees and the two main tragedies are really quite sanitised and not that upsetting at all. This might be a good book for mathematicians, but there's precious little science fiction until the final third and even then not a lot. I did quite enjoy some of the politics and references to current events, such as Somali prorates, otherwise ignore this book. I won't be reading anything else by Pohl.

ACCU Mentored Developers Project: Growing Object-Orientated Software, Guided by Tests

2011-01-30T11:23:00.002Z

The ACCU Mentored Developers will soon be embarking on their next big project, a read through of Growing Object-Orientated Software Guided by Tests by Nat Pryce and Steve Freeman. This will differ slightly from the tradition project structure as there are no "items" or exercises. However, most of the chapters are only 10 to 20 pages long and can therefore be read and discussed as if they are items. We're hoping to read at a pace of 2 chapters a week. Each chapter will reviewed and summarised by an allocated project member and serve as a starting point for group discussion.

The project is open to all ACCU members. To take part, please sign up to the list at the link below and make yourself known:

http://lists.accu.org/mailman/listinfo/accu-mentored-growing

You can take part as a project member, who will be allocated at least one chapter to review or an observer, who doesn't review a chapter but is free to take part in the discussion. If you have an questions about the project, please feel free to email me.

Cloud Computing with Scala and Gridgain

2010-11-04T21:06:00.002Z

This was my first London Java Community event. I've heard of cloud computing and was looking for a bit more. The evening started off with a lightning talk about the Lift web framework. This was really very interesting, but after so long with the Java of GWT I look at web frameworks that involve HTML and big round trips to the server to display pages and page updates with quite a lot of caution.

Nikita Ivanov seemed to have a lot of very interesting things to say. I just couldn't understand 90% of what he said. I don't know if this was caused by where I was sitting of the PA. Anyway, he demonstrated very well how simply distributed programs could be written in Scala. The most impressive thing he demonstrated was the lack of a deployment stage and how the runtime adjusted effortlessly to the realtime addition and removal of processing nodes.

Unfortunately not the best presented presentation, but enough to impress me and for me to buy a Scala book.

Agile Cambridge 2010

2010-10-17T16:57:00.002+01:00

Mark Dalgarno, with the support of Redgate Software, is using Software East to do great things for the software community in Cambridge. Software East has been running frequent evening events on topics including Agile and iPhone development and attracted a number of ACCU speakers including Allan Kelly, Pete Goodliffe and everyone's favourite Mac pusher, Phil Nash. Not content with rivalling ACCU London's events Software East has gone further and put on their own Agile conference over two days in the heart of Cambridge. I was pleased to be asked to speak and enjoyed both thoroughly exhausting days. What follows are some of the highlights for me.

Agile Cambridge was the first conference I have attended as a Twitter user. It's an amazing tool for not only communicating with the the attendees and passing on words of wisdom from one session to another, but also for keeping those who could not attend up-to-date and wetting their appetites for next time.

I do not know what it is about the last day of a conference, and it does not seem to matter how long or short the conference is, but I always leave completely spent on that last day. Maybe it is the activities of the night before the last day? Agile Cambridge was no different and I cannot wait to go again next year!

Test Engineering at Google by James A. Whittaker

James Whittaker is the second incredibly enthusiastic and charismatic tester I have had the pleasure of seeing speak this year, following James Bach at ACCU 2010. He took us through the technology of the last twenty years, including a picture of Michael Douglass on a phone about the size of a small loaf of bread and demonstrated how things have changed. He seemed very surprised that a lot of people in the audience still used a paper phone book and this became the subject of a number of jokes throughout the presentation. One of the main points James made was that with a lot of software now being web based, it is no longer cheaper to fix bugs in a product before it ships. He went on to describe the role of a tester as a consultant in a hospital and told us that all software is broken and on life support until the testers can get in and diagnose the diseases.

What Does It Take to be an Agile Company by Allan Kelly

I have seen Allan Kelly speak a few times and have always enjoyed his direct style. He passionately believes in what he is doing and I enjoyed this presentation as well. I think Allan has a very complete view on what agile is, where it came from and where it is going. He explained that he believes that Agile has arrived and is here to stay and that it will only get better. I am very much inclined to believe him. Another of the stand out points for me was that companies should use experimenting over planning and make sure that if and when failure comes, they fail fast and fail cheap. This became a much repeated line throughout not only the presentation, but the whole conference.

Building Effective Habits Through Peer Group Learning & Assessment by Jason Gorman

Jason Gorman has been doing some very interesting work. I think it is best summed up when described as: coaching Test Driven Development (TDD) at the BBC. I still find it amazing that some developers still do not see the clear benefits of TDD and have to be encouraged with incentives. Jason Gorman has been at the BBC teaching and assessing those who have been incentivised and it sounded like very interesting work! He described some of the exercises that the developers went through, their assessment and certification and some of the problems he faced. One of the techniques used was pair programming, where developers would mark off on a sheet which TDD rules their partner had broken, in order to help them learn and improve. At the end of the session he wrote some code and unit tests while the audience marked off the rules he had broken on a similar sheet to demonstrate how it worked. Of course he broke (almost) every rule. This was another very enjoyable session.

Five Years of Change, no Outages by Steve Freeman and Andrew Jackman

Again, I have seen Steve Freeman talk a couple of times before and he has a lot of very interesting things to say. In this presentation Steve and Andrew Jackman described a very successful project that they both worked on at different times. It solved a particular problem that had been attempted by different teams in the past who had failed. The main secret to the project's success was the use of Agile methods, including regular and automated deployments. They described a lot of the methods I am using every day and I am again amazed that more teams do not see the obvious benefits of regular automated deployments. Maybe this is why this sort of conference is needed so much.

Cyberdojo by Jon Jagger

I attended Jon Jagger's Cyberdojo as a participant at ACCU 2010. On this occasion I was delighted to be asked to help out alongside Jon. The setup had changed significantly as Jon has been developing his Cyberdojo since the last time. There was a greater choice of languages and problems to solve; and the teams were not given an objective until part way through. What was most interesting to me was the teams being told that their only objective was to get every team's build to green and the number of them that then proceeded to break their build after having reached green, before the others had caught up. These Cyberdojo's get more and more interesting and I'm looking forward to the next one.

Building Trust in Agile Teams by Rachel Davies

This was one of most enjoyable presentations, not least because I got to take part. Rachel spoke about how important it was for members of Agile teams to trust each other and the ways in which trust could be gained and lost. Rachel has spent many years coaching Agile teams and had a lot of very useful things to say. They certainly made me think about my team in new ways. Unlike ACCU conferences, the Agile Cambridge bunch took a while to start interacting with the speakers. There was plenty of interaction throughout Rachel's presentation and a whole lot of laughter. I am very much looking forward to seeing Rachel speak again soon.

Creating a Development Process for Your Team: What, How and Why chaired by Giovanni Asproni

The final session at the conference was a panel. I really enjoy panels, both as a member of the panel and a member of the audience. You never know quite where it is going to go and by their very nature there is lots of interaction between the audience and the speakers. Those who joined Giovanni on the panel included Allen Kelly, Steve Freeman, Rachel Davies and Nat Pryce. It was a chance for the audience to ask about some of the recent Scrum bashing and get to the bottom of the concerns some of the industry experts have with it. There was a long and very interesting discussion on pair programming and another on how to convince an organisation that Agile was the way to go.

Agile Cambridge: Agile is a journey, not a destination

2010-10-16T09:40:00.002+01:00

Although I have done it (tongue in cheek) before, I don't like reviewing my own presentations. So I was delighted when Giovanni Asproni, (ACCU conference chair) reviewed my participation at Agile Cambridge 2010 and was kind enough to allow me to publish his comments:

Rachel (Davies) spoke about building trust in agile teams. Setting aside lots of interesting material about the importance of trust in teams and on various techniques to use or avoid in order to earn trust, the highlight of her keynote was an exercise where Paul Grenyer was volunteered by Rachel to do a stage diving (interestingly enough, Rachel, Allan, Paul and I had talked about it the night before at the pub, but we didn’t think Rachel was going to take the conversation seriously ;-)). He accepted and was caught by a group of six or eight people (which included Jon Jagger and Allan Kelly who joined them to make sure the ACCU didn’t loose one of its most valued members). I’m happy to report that Paul was not hurt during the exercise (neither were Jon and Allan).

Paul (Grenyer) presented a session entitled "Agile is a journey not a destination" where he described his experience in introducing agile development practices at his company. The session was aimed at people trying to introduce agile in their own companies for the first time. Paul presented the material in a clear and compelling way, and, judging from the number of questions at the end, the audience really enjoyed it. Personally, I found the content quite interesting, and I was truly impressed by the way he delivered the presentation.

Agile is a journey not a destination presentation slides available on request.

Zima Blue

2010-10-03T15:20:00.003+01:00

By Alistair Reynolds
ISBN-13: 978-0575084551

I loved Zima Blue even more than House of Suns. The standout stories in this collection are those based around the Merlin character. Superb space opera from the master. Not every story is a winner and a couple of them are conduits for explaining science. In some places modified humans are back and there's space travel and extension of the human life span. All the classic Reynolds winners. I only have Terminal World left to read now, so Alistair needs to get on and write something else!

Cerberus Trial

2010-09-23T20:55:00.001+01:00

Plenty of you will have heard me banging on about Cerberus recently and some will be wondering what it is, other than the multi-headed hound that guards Hades of course. Cerberus is an application I have been working on that monitors websites. Features so far include:

URL checking at configurable intervals up to once a minute
Measurement and recording of response times
Email notification on URL failure
Email notification on URL recovery

I'm currently running a free trial for a handful of websites and it's going very well. If you would like me to monitor your site, please contact me and I will be happy to add you to the trial.

Up and coming features include:

Dashboard for user monitoring
User configurable URLs
URL statistics
Automated reporting

ACCU Conference 2011 Proposal 2

2010-09-18T14:52:00.001+01:00

Session title: Web Application Development with Spring, GWT and MVP

Session type: Case Study / Experience Report

Session duration: 90

Speaker: Paul Grenyer

Biography: Paul has been programming in one form or another for over 20 years. After several years using C++ and a brief period using C#, Paul is now happy somewhere he hoped he'd never be, programming in Java.

After time in industries such as marking machinery, direct mail, mobile phones, investment banking and Internet TV, Paul is currently working for a company based in Norwich where he heads up an ever growing team of senior and highly skilled people.

When he's not programming and family life allows, Paul thoroughly enjoys science fiction, heavy metal and cycling.

Session description: In Enterprise Web Application Development in Java with AJAX and ORMs (ACCU London March 2010 and ACCU2010) I spoke about how to develop and test a Data Access Layer and integrate it with a very simple Google Web Toolkit (GWT) based front end.

In Web Application Development with Spring, GWT and MVP I will demonstrate how to take advantage of Spring's Model View Controller implementation to add Spring Security to a GWT application and show how an adapter can be used to map it onto almost any user domain model. I will then go on to demonstrate the power of the Google Web Toolkit when developing web applications.

Traditionally web based applications, and even some that make use of AJAX, require large numbers of round trips to a server followed by the rendering of entire web pages each time something is submitted. Coupling GWT with the powerful and aesthetically pleasing GXT widget library (which is based on the EXT JS JavaScript library used by web applications such as Nexus) and the Model View Presenter pattern I will show how to create a powerful web application that runs almost entirely within a browser, with much of the same power as a desktop application, only calling to the server to send or retrieve the bare minimum of data.

Throughout the session I will build an application and demonstrate each new feature by running and operating the application.

No knowledge of the previous session is required.

ACCU Conference 2011 Proposal 1

2010-09-18T14:50:00.001+01:00

Session title: Agile is a journey not a destination.

Session type: Case Study / Experience Report

Session duration: 45

Speaker: Paul Grenyer

Biography: Paul has been programming in one form or another for over 20 years. After several years using C++ and a brief period using C#, Paul is now happy somewhere he hoped he'd never be, programming in Java.

After time in industries such as marking machinery, direct mail, mobile phones, investment banking and Internet TV, Paul is currently working for a company based in Norwich where he heads up an ever growing team of senior and highly skilled people.

When he's not programming and family life allows, Paul thoroughly enjoys science fiction, heavy metal and cycling.

Session description: I work for a young company that has made a big impact in its market and has quickly established a strong foothold and a growing reputation for product innovation and time-to-market delivery.

A company that at times needed to be “more agile than agile”, as was a frequent refrain of the CTO. In the early days, like many start-ups, requirements were changing on a daily basis and the software needed to keep up with it. Right from the beginning, Agile was the intended methodology, but it was impossible to get the requirements to stand still even for a five day iteration (as is often the way with an owner occupied start-up and the race is on to ‘deliver’). Company growth was phenomenal. However, the requirements did eventually start to stabilise enough for Agile to become a real proposition.

‘Agile is a journey not a destination’ describes a' software team's two and a half year journey from inception to really becoming agile, the evolving process that was adopted and the key lessons learnt in the first iterations.

In the first part of the presentation I will look at how the' software team grew into one of the most technically proficient and successful teams in the area, examining some of the triumphs and pitfalls along the way. I will describe the period from the heady early days to the a time when the requirements finally began to stabilise enough to enable the team to stand back (for a moment) and consider how Agile could be effectively implemented.

I will look briefly at the agile practices, such as unit testing and continuous integration, that should not be taken for granted in any software development, not just Agile software development. I will then go on to describe some of the obstacles that were encountered and how they were overcome, including how buy-in from more traditional project managers was achieved. Also, I’ll provide some key lessons on how you can effectively manage the transition from a waterfall mindset to an agile one; e.g. how to dovetail a business process map with an Agile story and winning the hearts-and-minds of all concerned.

Finally I will describe the development process followed and the lessons learned in the early iterations; like the need for visibility and continuous and free flowing team communication. No agile process is perfect first time and like software, the process must evolve.

The Java Programming Language

2010-08-22T17:13:00.003+01:00

By Ken Arnold, James Gosling, David Holmes
ISBN: 978-0321349804

I decided to read this book about 18 months after having to learn Java in a hurry after discovering what I had been lead to believe was a C# role turned out to be a Java role. Despite several years of programming in C++ and C# I figured there must be lots of stuff that was different in Java and that this book would be a good way to find out. The first chapter is a 40 page general introduction to Java and I found it such a dry read that I gave up. Then, twelve months later, I decided I really should read it cover to cover to find out what I was missing and it took me five months to do it!

Although solid and reasonable well written the book is a dry read most of the way through. The chapter on streams is especially hard going. Although in many cases each method of a class being discussed is described in detail, this book represents a medium level (as opposed to high or low level) introduction to the language. As you would expect it covers classes, interfaces, inheritance, polymorphism, enums, control flow, generics, threading, reflection, etc. so you do get a good overview of the language. However it does not go into any detail about how to compile or run Java programs, neither does it mention ANT or describe how to create JARs. If you want a practical tutorial, this is not the book for you.

I didn't agree with a lot of the “good coding style” suggestions such as using a fall through comment in switch blocks to tell the reader of the code what he should already know the language does or using continue in a bodiless for loop as a semi-colon may get deleted or forgotten. Many people, including myself and the creators of the spring library, believe that checked exceptions are a bad thing in most cases and should not have been added to the lanuguage, so I find bad advice like “Nearly all exceptions you create should extend Exception, making them checked exceptions” appalling. There are a number of examples of poor practice throughout the exceptions chapter.

Overall I think most Java developers would benefit from reading this book just to plug a few of the inevitable gaps in their knowledge. It is hard going, but worth it. As it covers Java 1.5 and Java 1.7 is nearly upon is, it would certain benefit from an update and a review of good programming practice.

Agile Cambridge 2010: Agile is a journey not a destination.

2010-08-05T13:50:00.003+01:00

I have just had confirmation that I will be speaking at Agile Cambridge at 2.15pm on Thursday 14th October 2010. Please come and see me!

Session title: Agile is a journey not a destination.

Session type: Case Study / Experience Report

Session duration: 45

Session abstract: Agile is a journey not a destination describes a software team's two and a half year journey from inception to really becoming agile, the evolving process that was adopted and the lessons learnt in the first iterations.

Session description: This is a success story. A young company that has made a big impact in its market and has quickly established a strong foothold and a growing reputation for product innovation and time-to-market delivery. A stretching but credible business strategy will see the company broaden and deepen its market proposition; a future that is critically enabled through a fully distributable software platform.

A company that at times needed to be “more agile than agile”, as was a frequent refrain of the CTO. In the early days, like many start-ups, requirements were changing on a daily basis and the software needed to keep up with it. Right from the beginning, Agile was the intended methodology, but it was impossible to get the requirements to stand still even for a five day iteration (as is often the way with an owner occupied start-up and the race is on to ‘deliver’). Company growth was phenomenal (11 to 100+ people in a little over two years). However, the requirements did eventually start to stabilise enough for Agile to become a real proposition.

‘Agile is a journey not a destination’ describes a software team's two and a half year journey from inception to really becoming agile, the evolving process that was adopted and the key lessons learnt in the first iterations.

In the first part of the presentation I will look at how the software team grew into one of the most technically proficient and successful teams in the area, examining some of the triumphs and pitfalls along the way. I will describe the market opportunity that the company spotted and how the business responded rapidly to meet and exceed the expectations of its new customer base; and how the urgency to deliver a proposition affected the software development team. I will then describe the period from the heady early days to the a time when the requirements finally began to stabilise enough to enable the team to stand back (for a moment) and consider how Agile could be effectively implemented.

I will look briefly at the agile practices, such as unit testing and continuous integration, that should not be taken for granted in any software development, not just Agile software development. I will then go on to describe some of the obstacles that were encountered and how they were overcome, including how buy-in from more traditional project managers was achieved. Also, I’ll provide some key lessons on how you can effectively manage the transition from a waterfall mindset to an agile one; e.g. how to dovetail a business process map with an Agile story and winning the hearts-and-minds of all concerned.

Finally I will describe the development process followed and the lessons learned in the early iterations; like the need for visibility and continuous and free flowing team communication. No agile process is perfect first time and like software, the process must evolve.

This presentation has been written especially for Agile Cambridge, but will probably be given a warm up at ACCU London.

Intended audience: Software developers and project managers.

Session outputs: None

Biography: Paul has been programming in one form or another for over 20 years. After several years using C++ and a brief period using C#, Paul is now happy somewhere he hoped he'd never be, programming in Java.

After time in industries such as marking machinery, direct mail, mobile phones, investment banking and Internet TV, Paul is currently working for a company based in Norwich where he heads up an ever growing team of senior and highly skilled people.

When he's not programming and family life allows, Paul thoroughly enjoys science fiction, heavy metal and cycling.

Nathaniel Grenyer

2010-08-05T13:46:00.002+01:00

It's been a while since I have had chance to blog and this time it's with good reason! I am very happy to say that Charlotte and I had a baby on Monday (2nd August 2010) at 8.53am. After going to the hospital on Saturday at 4pm and following a long painful labour, Nathaniel was finally born in a speedy 90 seconds. I almost missed it! He was born at the very healthy weight of 7lb2. Mother and baby are continuing to do very well! I need sleep.....

Falling Off A Log

2010-05-23T20:52:00.002+01:00

This was this first Software East presentation I have attended. It was hosted at the Redgate offices just off the A14. They were very nice, if not as technologically advanced as Morgan Stanley. It just so happened that Allen Kelly, the speaker, was arriving as I phoned him from the car park, so we wondered in together to find no receptionist and a sign directing us to the Seagull Suite on the first floor. From the first floor there was no indication of where the Seagull Suite was, so Allan gave Mark Dalgarno, the event organiser a call and he showed us to the suite via the “SQL Servery”, Red Gate's appropriately named cafeteria.

The presentation was scheduled to take place between 6.30pm and 8.30pm. Two hours is a long time for these events, even though I can imagine Allan speaking for two hours without a problem. I found out that the first half hour is for networking and buffet eating, so I tucked in and chatted to Allan and Pete Goodliffe.

Allan spoke about setting up your own business. He believes that it's as easy as falling of a log and it is! He pointed out that all you need to do is pay an accountant and they set it up and do all the legal and financial stuff for you. I know this to be true as I have done it.

Allan's main thrust though was that there needs to be at least two of you, a techie and a salesman. That way you may just make it to through your first year. Again, the same thing had occurred to me. Whenever I have thought of setting up my business and going it alone I've always had two problems, I'm no good at selling and I don't have an idea for a product. A salesman wouldn't necessarily have an idea for a product, but they should be able to sell!

Allan went on to explain how he missed out on making a billion dollars by not developing an idea for a product he had early in his career that someone else later did. I did have some sympathy, but mostly envy.

Allan over ran and after questions at the end he finished about 8.30pm. The most significant question asked from my point of view was where do us techies find a salesman and, unfortunately, no one really had an answer.

The rest of the group stayed to polish off the buffet and do some more networking while I sloped off for the drive back to Norwich.

Allan's slides are available here: http://allankelly.blogspot.com/2010/05/falling-off-log-slides-online.html.

User Stories Applied – For Agile Software Development

2010-05-18T19:21:00.002+01:00

by Mike Cohn
ISBN: 978-0321205681

After reading Agile Estimating and Planning, also by Mike Cohn, I was rather disappointed with User Stories Applied. Then I saw that Agile Estimating and Planning was published in November 2005 and User Stories Applied was published twenty months earlier in march 2004. A lot of the material in User Stories Applied forms the basis for and is expanded in Agile Estimating and Planning. Therefore I have come to the conclusion that Mike Cohn spent the twenty months between the two books improving as a writer! However, I think there is great scope for merging the two books and coming up with a better title. There is not enough user story based material here for a single book.

Only about half the book is actually about writing user stories. The other sections cover things like planning and testing. There is also some discussion about identifying roles within a system which, on the first read, felt a bit thin. Then when the case study came at the end and I had had chance to think about user roles in my own context I started see how useful defining them could be.

As you would expect, user stories are talked about in a reasonable amount of depth and most of the advice seems good to me. One of the main points I liked was the clear explanation of how user stories differ from tradition requirements capture and upfront design.

Mike Cohn asks questions at the end of each chapter. At the end of the book there are two appendices. One giving an introduction to XP and the other the answers to the questions.

Overall User Stories Applied is a little bit killer, but mostly filler.

ACCU Conference 2010

2010-04-18T18:18:00.005+01:00

The Roots of Scrum: How the Japanese Lean Experience Changed Global Software Development

Jeff Sutherland

Dr. Jeff Sutherland covers the history of Scrum from its inception thru his participation with Ken Schwaber in rolling out Scrum to industry, to its impact on Google, Microsoft, Yahoo, Oracle, Siemans, Philips, GE, and thousands of other companies. He describes the relationship of Scrum to experience at Bell Labs, MIT, iRobot, and the Grameen Bank, his communications with Kent Beck who used Scrum experience to help create XP, and how the Agile Manifesto accelerated Scrum adoption. Most important, he concludes by describing how team spirit is at the root of product innovation and hyperproductive teams and how that spirit can transform organizations.

Just as last year with Robert Martin's key note, the 2010 ACCU conference got off to a storming start with this key note from Jeff Sutherland, that I wish I could have got my entire team, the managers and to some extent the board to see. It contained good explanations about so many things about Scrum that I have been trying to explain for some weeks now.

Jeff Sutherland, one of the fathers of Scrum, described how Scrum is based on leadership, honesty and transparency and how, in comparison, fraud, greed and corruption fuelled the current global financial crisis. He went on to explain how Toyota's lean Scrum methodologies helped it to put its main competition, General Motors out of business and how, when it let leadership, honesty and transparency slip, it got into trouble that resulted in car recalls. He also described how lean allowed Toyota to develop the Prius in half the normal time by removing waste and impediments form the project. This case study also helped to demonstrate how lean agile methodologies helped define Scrum.

In talking about Scrum itself, Dr Sutherland went on to describe how Scrum:

Removes management practices in favour of leadership
Empowers employees
Uses rules and procedures as enabling tools
Uses hierarchy to support organisational learning

With the use of a diagram, Jeff Sutherland, showed how simple a framework Scrum really is. He went on to explain how Gantt charts are always 100% wrong, as things change quickly and they become out of date and how teams must be able to self-organise in order to be truly agile.

Introduction to Scrum: Shock Therapy -- How new teams in California and Sweden systematically achieve hyperproductivity in a few sprints

Jeff Sutherland

New teams need to learn how to do Scrum well starting the first day. This talk will describe how expert coaches at MySpace in California and Jayway in Sweden bootstrap new teams in a few short sprints into a hyperproductive state. This requires new teams to do eight things well in a systematic way. Good ScrumMasters with make sure their teams understand these basics for high performance and great ScrumMasters will make sure the teams execute all of them well. This session will review the critical success factors for new Scrum team formation.

Hoping to learn some more about Scrum I want into Dr Sutherland's follow-up presentation and I wasn't disappointed as there was more of the same! It was good to have the idea that Sprints could be one, two, three or four weeks as I had previously believed that Sprints had to be 30 days to be Scrum.

Jeff Sutherland described how he encourages Scrum to be implemented and understood from board level down and two of the main things that get enforced, by the board, are Test Driven Development (TDD) and Continuous Integration (CI). I see these as two of the bare minimum requirements for software development.

I especially like the definition of “done” given:

Feature complete
Code complete
No known defects
Approved by product owner
Production ready

Dr Sutherland reiterated his previous point that Scrum should be lean and reminded me that although the right way to estimate stories is with relative story points, in a Sprint planning meeting those stories should be broken into tasks and real time estimates given to each one.

Real QA - the argument for smarter quality assurance than mere testing

Tom Gilb

Traditional testing, as a means towards quality assurance, is far too costly and far too ineffective. There are much smarter ways to approach software quality. This session will argue with facts for a half dozen more-cost-effective ways to get reliability and all other qualities, like usability, security, adaptability, into your systems, than conventional testing.

It seems that Scrum themed sessions are the order of the day for me as Tom Glib works closely with Jeff Sutherland and both attend each others presentations. I went into this presentation unsure what to expect and hoping to learn something. Although I enjoyed it and may just possibly have missed something subtle, it appeared the whole point was that quality should be specified quantitatively in requirements, and those requirements should also be high quality and bug free, rather than trying to ensure it with only testing at the end.

Jon Jagger's DOJO

I was invited, well it was more like press ganged, to a late collaborative programming session. I was a member of one of five pairs who were developing a simple unsplice function and accompanying tests. We ran several iterations and were informed we should be working as group, rather than compete. At the end of each iteration the people in each pair were changed, and each pair would work on another pairs code. It was an interesting look at the way teams collaborate together in an agile environment. In retrospect I wish we'd planned and shared a bit better, but with the information we were given I think we did quite well.

Hello, I'll Be Your Tester Today

James Bach

This talk is how I introduce myself to programmers. It is especially aimed at programmers who may wonder why any intelligent person would willingly be a tester, and why projects needs testers, and how to work with testers. I will talk about what makes skilled testers different and special and about the commitments I make to the programmers I work with. I will help you set a high, but reasonable standard for the testers you work with.

If I am successful, then by the end of my talk, at least a few programmers in the audience will have become testers.

The ACCU conference has always been about quality, but this year is very special, especially with the keynote speakers. James back is a highly charged and very amusing individual. In fact he;s the sort of tester I'd like to be working with.

He explained that he started his testing career as a test manager for Apple about 20 years ago. Throughout his key note, James highlighted the many differences between testers and developers. Including the fact that, apparently, testers have more social interaction. Another subtlety he pointed out was that testers don't break code, developers do and testers do not steer projects, they make suggestions and hold the light so developers can create great code.

One of the best parts of the keynote were the testing related subtitles James added to a clip from The Towering Inferno where Steve McQueen is gathering the requirements he needs to fight the fire. I can't describe its brilliance in a way that will do it justice here.

The point that resonated the most for me is that testers need to be able to think their way around a system with or without a specification or requirements. They need to think outside the box as, after all, requirements are often rumours, right? This is the oppostie end of the scale from what Tom Gilb was saying yesterday. From an understanding of what the system should do and bags full of common sense testers should be able start testing and test effectively.

Genemodulabstraxibilicity

Steve Love

The title says it all! If it's hard to write unit tests, or they take too long to run, if your plugins need the whole application for their distribution, if you can't (re)use a bit of your colleague's code without importing the entire team's work, if your multi-threaded code performs better when you run it sequentially, or you've got 5 versions of the same 3rd party library littering your source repository, then you're suffering from this. Or perhaps just part of it...

Modern languages provide us with many tools for creating beautiful, modular, general, flexible and simple abstractions, yet it seems they give us even /more/ tools for writing ugly, monolithic, specific, rigid and complicated, er, /concretions/.

With examples of both kinds in C#, Python, C++ and maybe even C++0x (if it stays still long enough to get the syntax right :-)), this is a talk about our (code's) propensity for wearing too many hats.

Steve is one of my oldest friends from the ACCU, going back to the first conference I attended in the early naughties. The lessons and observations he discussed in the session are what the ACCU is all about for me. He described lots of the common pitfalls of the code that a lot of people write and how to avoid them sensibly.

There was of course just the right amount of singleton bashing and plenty of humour, not to mention of course, the subliminal elephant that no one was meant to be thinking about. Other important points made were that too many comments is a sign of poorly written code and public inheritance is the strongest form of coupling.

What surprised me the most was Steve's description of a painful code review where he was pulled up for using single entry, single exit. The company Steve was working for actually explicitly stated that they tried to enforce multiple exit points. Just when I thought I'd heard it all....

Data warehouse, OLAP, Data Cubes, Business Intelligence - Buzzwords explained

Sven Rosvall

In the database world there are many buzzwords that most software engineers only hear about but never get experience with. This talk aims to clarify what lies behind some of these buzzwords and describe key differences from the more common transactional database. The talk will also provide enough insight for engineers to decide if any of these technologies are useful in their current or future projects.

The presenter has work for many years on the periphery of the databases, wondering about these buzzwords. He eventually got involved with data warehouses and now wants to share his experiences with fellow engineers.

Sven is another ACCU member I've known for many years. His presentation did exactly what it says on the tin. I came away understanding the difference OLTP and OLAP and that we really need to try and break our own databases up onto separate servers to improve performance.

Although I'm still a little hazy on data cubes, I now understand dimensions and how data is reorganised when it is transferred from OLTP to OLAP to make it easier query. This was certainly one of the most useful sessions of the conference so far.

Database Testing Demystified

Sven Rosvall

Testing databases is not as easy as unit testing of classes and functions. Databases are full of state and internal logics which must be set up before testing can start. There are also lots of dependencies that are difficult to isolate or stub out.

This presentation will look at some techniques to create automated tests for databases and how to debug SQL code including single stepping stored procedures. We will automate database testing with the use of popular unit testing frameworks. We will test simple CRUD statements, calls to stored procedures and verify triggers. Test suites in Java and .Net will be demonstrated.

We will also see how a database can be developed with agile methods. Databases are traditionally developed up front as the database schema is difficult to change later.

Another great session from Sven (immediately following the previous one) even if the material from the second half does overlap what I'm speaking about a fair bit. The highlight here for me was seeing the SQL Unit Testing Framework SPUnit in action and the ability to step through stored procedures in SQL Server Management Console.

TDD at the System Scale

Steve Freeman, Nat Pryce

We present our experience applying "system-test first" test-driven development (TDD) in the development of large systems and systems-of-systems. We try to address integration and system testing as early as possible. The sooner the system is in a deployable state, the easier it is to react to changing business needs because we can deliver new features to users as soon as is deemed necessary. We therefore start by writing tests that build and deploy the system and interact with it from the outside and, to make those tests pass, add code to the system in the classic "unit-test first" TDD style.

Many teams applying TDD start writing unit-tests and leave integration and system testing until late in the project because they find it difficult to write tests that cope with the distributed architecture and concurrent behaviour of their system. We will describe how we address common pitfalls, including unreliable tests, tests that give false positives, slow-running tests and test code that becomes difficult to maintain as the system grows.

We will also describe how writing system tests guides our architectural decisions. Writing unit tests first guides design of the code to be flexibile and maintainable. In a similar way, we have found that writing system tests first guides the architecture to be easier to monitor, manage and support.

A couple of colleagues and myself saw Steve and Nat speak at JP Morgan in February and it was a little bit like disorganised chaos with Steve doing most of the talking and Nat chipping in. There was a marked improvement this time, with Nat doing the majority of the speaking.

I was a little bit concerned to see that they were advocating starting with system level tests before unit tests, but I can see how it might work in some circumstances. The same old system level problems, such as driving the GUI, faking external systems, etc, are still there, but Nat and Steve came up with some interesting ideas to overcome theses.

The main points that stood out for me where:

Making the system scheduler external so that it can be faked during test.
Use an audit interface instead of direct logging so the system can decide what it wants to report as a whole.
Add hooks so that you can easily ask the system if it is happy.

Another point I realised is that I really need to read their book!

The Multicore Revolution: We've Only Just Begun

Russel Winder

I will and have travelled a long way to hear Russel speak, even for a short period of time, on many occasions. He is very entertaining and today was no different. Before talking about the architecture of multi-core processors, Russel spoke about the different forces occurring in atoms. Unfortunately it's so long for me since A-level physics, I was rather lost!

The two important points that Russel made were that we need to stop thinking in a single processor, single memory model and consider a mulit-core, multiple memory model and that although the hardware is mostly there, there is a lot of catching up to do on the software side.

Fortunately no kittens were harmed during the production of Russel's slides as he is using open office instead of power point.

Understanding User Stories

Rachel Davies

On traditional projects, software developers are often presented with volumes of requirements that seem to be definitive and yet are full of holes. On agile projects, the whole team gets involved in establishing user stories on index cards. Come along to this session to understand the life-cycle of a user story from inception to implementation. You'll get a chance to practice working through some real user stories. We'll also investigate ways that agile teams handle requirements that don't seem to be user stories.

I didn't read the description of the session sufficiently! So I was a little shocked when the layout of the room indicated it would clearly be interactive. I don't really enjoy that sort of thing, but this was superb and the 90mins just flew by!

This session was, for me, really about confirming what I have read recently about writing user stories. It was nice to know I was generally right and to find ways to smooth some of the rough edges.

We played a game where one person wrote down a story, e.g. “A man opens a door.”. Then the next person draws it and the following person then writes down what they think has been drawn and this goes right around the group. Each person only sees what the previous person has written or drawn. The idea of the exercise is to show how if one person describes something and another person documents it, things get lost and other things get added. The final description was “A man with a hat, closes a door.”

We also did a brief exercise where one member of a three or four person team is the product owner and the other members of the team ask them questions to determine what is needed for a system and write stories. This also worked very well.

Based on what I saw I'd be very happy to have Rachel come and coach my team.

FindBugs: Testing (Java-) Code Against Bugs And Defects

Bernhard Merkle

This session should be really fun. We will make a deep dive into findbugs, a very useful tool which every programmer should use to test Java code against potential bugs, defects and antipatterns.

After a first overview of the problem domain (static analysis), we will take some of Joshua Bloch's "Effective Java" Rules from his book (a ACCU mentored developer mailing lists currently runs...) and see how / if they can be implemented in a tool like findbugs. I will show how findbugs works internally and we will implement a new bug detector (findbugs rule) to find specific defects we are interested in.

Additionally we cover different levels of static analysis like code-, design- and architecture-level. Interestingly findbugs checks code and design level, but fails itself (!) on the architecture level; which means the tool itself suffered major architecture erosion from version 0.7 to the current 1.3.8.

I am participating now in the findbugs project and contributed several architectural refactorings on the findbugs 2.0 branch (see the sourceforge/googlecode SVN repository) which is currently under development and should hopefully be finished during the time of the ACCU 2010 conference. We will see, how far an automated and tool supported approach can lead to better results and how tools like findbugs can discover areas of code- and design-erosion and suggest improvements. Additionally we will look at the next generation of analysis which is architecture analysis.

Bernhard took us through a very interesting look at what findbugs provides and showed us many examples of bugs in established code bases, such as Eclispse and the Java SDK itself, that could have been found simply by running findbugs. He included some great photos of non-programming bugs and lots of excellent humour.

Findbugs can also highlight architectural problems and Bernhard showed us how the architecute of findbugs itself has got steadily worse over the years.

Bernhard convinced me that we should add findbugs to or static analysis arsenal, which current consists of just PMD.

Saturday Keynote

Due to the volcano eruption in Iceland, Dan North didn't make it to the conference for the Friday keynote, so Russel Winder (as described above) moved his keynote forward. So the Saturday keynote was replaced with four fifteen minute “Lightning talks”. Lightning talks are just very brief talks, usually only five minutes and usually for people who aren't already speakers to give them a chance to try it out. On this occasion the talks were given by four conference speakers:

Bob "Unclude Bob" Martin – The birthday problem.
Walter Bright – The biggest problem with C.
James Bach – Testing models.
Jim Hague – Are you getting enough?

All were humorous in one way or another and all very good.

Coupling as resistance to change, understanding and fixing it

Tony Barrett-Powell

Coupling, the number of things a unit of code depends on, is an important consideration when designing and maintaining software. Without due care a slow increase in coupling between units over a few releases of a software product, or even over a number of iterations within a release, can lead to software that is difficult to change, or worse results in a ripple effect throughout seemingly unrelated units. We cannot write software without some coupling, how else would the code achieve anything? Thus, coupling is not a bad thing in itself, it is the degree to which a unit is coupled to other units that can be undesirable, yet is not an absolute measure. Understanding of what coupling is, its many forms and how to recognise them is useful if we want to avoid unnecessary coupling in the software we create. It is important to control coupling in software if it is to be improved over a number of releases, as high coupling slows development, increases time to market and inevitably lost revenue.

This session attempts to explore coupling in all its manifestations, examine the difference between good and bad coupling and to consider its bedfellow cohesion. The session will also explore the techniques used before, during and after the act of design which can be used to reduce unnecessary coupling and as an aside looks at those which can lead to increased coupling. The intent of the session is to arm those designing and writing software with the understanding and techniques to create loosely coupled and maintainable software.

I have known Tony a good few years, but this is the first time I have seen him speak. He is very good and this subject is close to my heart.

Tony explained how lots of coupled code is very difficult to change and even harder to understand. He took us through inheritance coupling and temporal coupling and explained cohesion as a measure of the strength of functional relatedness of elements within a module. If it's all together it's cohesive, if it's split up it's coupled.

Tony continued by explaining Afferent and Efferent coupling. Afferent coupling occurs at the package level and efferent coupling is the number of classes inside a package that reference classes outside of a package.

A Simple Matter of Configuration - how can we tame the complex world of configuration?

Roger Orr

Configuration is a vital element of many programs. However it is often hard to get configuration right, leading to people wasting time and programs that do not work correctly.

In my experience explicit discussion of design options for the configuration of a program is rare and, all too often, the choice is made arbitrarily. I believe that looking at the usage patterns of the program early on helps to pick the best method(s) for configuring it and hence reduce the cost of problems caused by configuration issues.

Configuration is a complex subject and there doesn't seem to be an obvious single solution that works in every case, but we can try to fight against the common 'anti-pattern' of using multiple, unrelated, configuration techniques at the same time.

I will look at some of the issues surrounding configuration; firstly by trying to answer the "six key questions" (who, why, what, where, when and how) for this subject to help understand the size of the problem and the forces at work.

I'll then sketch out some possible design patterns and look at their trade-offs and interaction with the intention that I (and you) can reduce the pain of getting programs working in different environments by making more informed and deliberate decisions.

I am looking at the problem in the general case, using examples from various problem domains, and expert knowledge of a particular language or API is not assumed.

This was the last session I attended as I was speaking in one of the final slots of the day. Again, I have known Roger, through the ACCU a long time and shared many a drink and lunch with him. He took us through a humorous look at how to configure applications. This wasn't a look at build configuration, but the way we actually pass settings to a program.

I have come across many of the same problems in my career, and although there was no specific solution to the problem, one of the proposed solutions, storing settings in a database is one I use regularly. Roger showed me lots of methods and their pitfalls, that I had never even considered!

Enterprise Web Application Development in Java with AJAX and ORMs

Paul Grenyer

Recently Java enterprise web application programming has been leaning towards a more classical J2EE approach. Traditional Java Server Page (JSP) programming, and even libraries such as Struts, are being replaced by new AJAX libraries that make GUI programming more straight forward, robust and easier to unit test.

In this session I will look at what an enterprise web application is.

I will demonstrate how to develop a more robust GUI with an AJAX library and how to create a more object orientated Data Access Layer (DAL) with an Object Relational Mapping (ORM) library.

After defining what an enterprise web application is I will move on to demonstrate how to create a DAL, with real code examples, and explain how to use a registry to abstract away Data Access Objects (DAOs) so that the real DAOs can be used in production and integration testing while seamlessly substituting mock objects for unit testing.

Then I will look at an AJAX library and demonstrate how to create the presentation layer in Java, again with real code examples, and make Remote Procedure Calls to access the DAL. I will then look at how to integrate the AJAX library into traditional Spring MVC in order to tap into the vast library of functionality that the Spring Framework can provide for web based enterprise application. I will explain how the tools provided by Spring make integration testing of DAO objects very simple.

Finally I will look at how to use Spring Security to authenticate users of the application and secure individual Remote Procedure (RPC) calls made from the client application, running in a browser, to the server.

I don't know how good I was, but this presentation flowed for me easier than any other presentation I have done. I have never managed to speak for the full ninety minutes before and I came in on time.

It was one of the final sessions of the conference, I was up against some stiff competition and most people had actually already gone home. Even so I had an audience of about half a dozen.

My slides are available here: http://paulgrenyer.net/dnld/Enterprise_Web_Application_Development_in_Java_with_AJAX_and_ORMs.pdf.

Finally

This was the best ACCU conference I have ever been too, simply because of the amount directly useful information I was able absorb. I'm sure next year will be even better.

Agile Project Management with Scrum

2010-04-08T18:23:00.002+01:00

by Ken Schwaber
ISBN: 978-0735619937

I bought this book when it looked like I was going to be doing the Certified Scrum Master course at the ACCU Conference, as it's required reading. I was hoping for a detailed explanation of the Scrum process, but this book actually contains a number of case studies which describe how Scrum has been implemented in different places, what worked well and what didn't.

Even thought the book didn't contain what I expected, I found it quite interesting and informative and it made me think about how our agile team could improve. It's quite a short book at only 153 pages and very easy to read. Consequently I ploughed through it in about a weeks intensive reading.

Agile Estimating and Planning

2010-03-27T17:07:00.002Z

by Mike Cohn
ISBN: 978-0131479418

I bought this book because I'm generally rubbish at estimating (I usually under estimate). Also, although we have the technical elements of agile (source control, unit tests, continuous integration, etc) sorted, my agile project management is not all it could be. Agile Estimating and Planning may be as close as I ever get to a silver bullet.

To be honest I expected to be let down and that the scenarios described in the book would not match the situations I find myself in. I was not let down at all. The book covers both planning when features are important and planning when a deadline is important.

It taught me that it was wrong to break stories into tasks when release planning and to leave that for iteration planning. The book discusses the use of both story points and ideal days in estimating, what they both are, the differences between them and then suggests you should use story points.

It described what release and iteration planning are and when to use them. It also discusses how to predict, where necessary, and how to measure velocity in order to calculate the duration of projects. One of the most important things covered from my point of view was how, when and with what to report to the product owner and stake holders.

The book finishes with a 60 page case study. I was tempted not to bother reading this as it goes over the main points covered in the rest of the book again. I was glad I read it and if you buy this book you should read the case study if you read nothing else. It helps put in context how estimating should be done and describes the processes surrounding it.

All I have to do now is write a distilled version for my team, including the project managers, product owners and stakeholder and put it into practice.

ACCU London March 2010 (2)

2010-03-19T19:39:00.003Z

Last night I presented the 60 minute version of Enterprise Application Development in Java with AJAX and ORM for ACCU London. A couple of people asked for the slides, so here they are:

http://paulgrenyer.net/dnld/Enterprise_Application_Development_-_ACCU_London.pdf

and the video can be found here:

Part 1
Part 2

Sustainable TDD Review - ACCU London February 2010

2010-02-28T10:56:00.002Z

I always say this and I'll say it again: London is a long way to go from Norwich for the evening. On this occasion it was worth it, as it always is for ACCU London. This dark, cold, late February evening had the added drawback of torrential rain. To make matters worse, while looking for the JP Morgan building at 125 London Wall, we got to the junction of Moorgate to find a sign suggesting we had been walking in the wrong direction. With faith in a printed google map and iPhone GPS we forged on another fifty yards and found 125 London Wall exactly where we expected.

I have been in many offices belonging to a number of financial corporations and JP Morgan is no different to any of them, except for the lifts! Instead of calling the lifts by pressing a button next to them, you have to go to a set of small screens in the middle of the lobby. On one of these screens you select the floor you want and it indicates which lift you have to get in. The assigned lift then opens and takes you to the selected floor. Being a techie I couldn't help thinking how cool this was, but I did find myself wondering what you would do if you changed your mind about which floor you wanted once in the lift. We ascended 17 floors in what didn't feel like not enough time. However the view form the window confirmed just how high we were.

Test Driven Development (TDD) and the benefits it brings are well understood by most software developers and even most companies and managers. Still, every year at the ACCU conference someone does an introductory presentation on TDD. So, I was intrigued when I read about Steve and Nat's presentation on Sustainable TDD as it sounded like the next step.

Steve Freeman and Nat Pryce have a book to sell: Growing Object Orientated Software [1]. Their presentation was based around one section of the book. It was only about 45 minutes long, but there was a fairly long discussion after. During the initial 45 minutes Steve did the majority of the talking and took us through some simple techniques that would improve the readability and maintainability of unit test code.

Steve started off by showing us some lengthy, quite messy unit tests of the sort we have all probably seen or even written at one time or another. Then there were some examples and discussion of how to name test methods effectively. Instead of naming test methods after the method under test we should give them names that describe what is being tested. For example:


holdsItemsInTheOrderTheyWereAdded() 
canHoldMultipleReferencesToTheSameItem() 
throwsAnExceptionWhenRemovingAnItemItDoesntHold()

The problem with “magic numbers”, literals used directly in code, has been understood for some time, but as Steve explained they still get used in test code, so we should try to use self describing variables instead. For example:


final static Chat UNUSED_CHAT = null; 
final static int INVALID_ID = 666;

Often tests require one or more complex objects to be constructed before the test can be carried out. This setup code can often be very verbose:


Order order = new Order( 
  new Customer("Sherlock Holmes", 
    new Address("221b Baker Street", 
                "London", 
                new PostCode("NW1", "3RX")))); 
order.addLine(new OrderLine("Deerstalker Hat", 1)); 
order.addLine(new OrderLine("Tweed Cape", 1));

The verbosity can be reduced by using a builder, similar to those described in item 2 of Effective Java [2]:


new OrderBuilder() 
 .fromCustomer( 
     new CustomerBuilder() 
      .withAddress(new AddressBuilder().withNoPostcode().build()) 
      .build()) 
 .build();

Steve described quite a few examples of how you might use builders to repeatedly build test objects with different properties. Although this technique could be useful, it would only be where you have a large number of objects to construct or a number of different permeations of a single object that takes a large number of parameters.

Steve then went on to describe a technique that I consider a little controversial. He suggested that the message parameter of JUnit's asserts should be used to help diagnose the problem when a test fails. For example:


assertEquals("balance", 16301, customer.getBalance());

This to me is tantamount to using comments. Here, someone could change the test to test something else and not bother to update the message. However, in simple assertions like this with one word descriptions this is unlikely and the message is is likely to be very useful.

Then Steve explained something that appealed to my colleagues and I as pure genius in its simplicity and potential usefulness:


Date startDate = namedDate(1000, "startDate"); 
Date endDate = namedDate(2000, "endDate"); 

Date namedDate(long timeValue, final String name) { 
  return new Date(timeValue) { 
   public String toString() { return name; } 
  }; 
}

Here if an assertion involving startDate or endDate fails, instead of the actual date being reported:


java.lang.AssertionError: payment date 
Expected: [Thu Jan 01 01:00:01 GMT 1970] 
     got: [Thu Jan 01 01:00:02 GMT 1970]

you get a description of the date:


java.lang.AssertionError: payment date 
Expected: [startDate] 
     got: [endDate]

I think the potential usefulness of this technique speaks for itself.

Discussion continued and Alan Stokes pointed out that only code with unit tests should be refactored and asked how you therefore refactor test code, as it has no tests. The answer was that you first break your production code so that the tests fail, refactor the test code making sure it still fails and then fix the production code and make sure the tests still pass.

Those were the highlights of the presentation for me, although Steve and Nat did cover some other techniques and examples. It was certainly enough for me to buy their book.

References

[1] Growing Object Orientated Software by Steve Freeman and Nat Pryce, ISBN-13: 978-0321503626

[2] Effective Java by Joshua Bloch, ISBN-13: 978-0321356680

EJB3 In Action

2010-02-27T20:55:00.001Z

EJB3 In Action
By Debu Panda, Reza Rahman, Derek Lane
ISBN-13: 978-1933988344

I bought and read this book as I wanted to learn about Enterprise Java Beans having only used Spring for Enterprise Java development up to this point. This is an excellent book for just that.

It explains in a reasonable amount of detail what stableful and stateless session beans, message driven beans and entity beans are. After a number of chapters describing how to use session beans and a further chapter on message driven beans a large amount of the book is turned over to entity beans and the Java Persistence API. As a user of Hibernate I found going over a very similar API somewhat tedious in places, but I am sure this would not be the case for a novice ORM user. I also think Hibernate does it better.

I found the general style of the book, although chatty, quite easy to read. Although the authors mention many of the areas where Spring has similar or even better functionality it is clear, as you would expect, that the authors favour EJB in all cases. Even when EJB is still quite heavy weight in comparison.

My biggest criticism of the book is that it's more of a text book that a practical guide. Although the source code for the example application is available to download, it is not possible to put the application together just from reading the book and deploying an application to a container is handled very late in the book. If I was actually wanting to do some EJB development at this stage I would want to try things out and therefore having deployment examples at the start of the book would be paramount.

Linux Fortinet VPN Client

2010-02-13T16:54:00.002Z

Ever since the company I work for changed to a Fortinet VPN I have been looking for a Linux client that will work with Ubuntu. Today I found one:

forticlientsslvpn_linux_4.0.2010.tar.gz

Install and use instructions can be found here.

Referencing one Nexus repository from another

2010-02-13T16:48:00.002Z

If you want to reference one (master) Nexus repository from another (slave) Nexus repository this is what you have to do:

Add 2 proxy repositories to the slave Nexus, one configured for releases and one configured for snapshots. Set the remote url in both to:

http://<master>:<port>/nexus/content/groups/public

Then add the releases proxy to the public group and the snapshots repository to the snapshots group.

Thank you to Damian Bradicich of the nexus-users group for these instructions.

ACCU London March 2010

2010-01-18T20:34:00.004Z

I will be giving my Enterprise Web Application Development in Java with AJAX and ORMs presentation for ACCU London at 7pm at 7 City (4 Chiswell Street, London, EC1Y 4UP) on Thursday 18 March 2010.

Registration will be required.

Who's the daddy?

2010-01-18T20:27:00.002Z

My blog has always been personal and professional so I want to share the most important news I have ever had and the best thing that's happened to me since I got married.

Data Access Layer Design for Java Enterprise Applications

2010-01-14T18:17:00.001Z

Java Database Connectivity (JDBC) can be used to persist Java objects to databases. However JDBC is verbose and difficult to use cleanly and therefore is not really suitable for enterprise scale applications. In this article I will demonstrate how to replace JDBC persistence code with an Object Resource Mapper to reduce its verbosity and complexity and then, through the use of the appropriate patterns, show how you might design a more complete data access layer for a Java enterprise application.

Read more.

Installing VMWare 2.0.x on Ubutnu 9.10

2010-01-02T07:52:00.002Z

There are some known issues with installing VMWare 2.0.x on Ubuntu 9.10 which are described well here:

http://www.ubuntugeek.com/how-to-install-vmware-server-2-0-x-in-ubuntu-9-10-karmic.html

so I am not going to repeat them. However I will add the following:

Make sure you have build-essentials installed so VMWare can build its special kernel modules:

sudo apt-get install build-essentials

Make sure you have the linux headers installed. To obtain your kernel version execute:

sudo uname -r

Then to install the headers:

sudo apt-get install linux-headers-<kernel version>

In the configuration step, following the install, you will be asked which user you want to be able to log into VMWare as. The default is root and since root is not enabled by default on Ubuntu you should choose another user with root permissions rather than enabling root.

Installing SubVersion with Apache2 on Ubuntu 9.10

2009-12-26T16:37:00.002Z

First start off by installing Apache:

sudo apt-get install apache2

Enter the root password and follow the instructions. Check that is it installed correctly by going to http://localhost and checking that you see the standard Apache "It works!" message. Then install subversion and the subversion Apache module:

sudo apt-get install subversion libapache2-svn

Then create a directory to store repositories in:

sudo mkdir /var/svn/
sudo mkdir /var/svn/repositories

and create a test repository:

sudo svnadmin create /var/svn/repositories/test

So that Apache can read and write the repository its user (www-data) needs to be given ownership of it:

sudo chown -R www-data:www-data /var/svn/repositories/test

To be able to authenticate users who access the repository a password file is needed:

sudo htpasswd -c /etc/subversion/passwd paul

Enter a password for the user paul. For additional users repeat the command without the -c option to make sure the existing file is appended to rather than replaced.

Then edit the Apache config file:

sudo gedit /etc/apache2/apache2.conf

Add the following to the end of the file:

<Location /svn>
  DAV svn
  SVNParentPath /var/svn/repositories/
  AuthType Basic
  AuthName "Test"
  AuthUserFile /etc/subversion/passwd
  Require valid-user
 </Location>

Save the config file and restart Apache:

sudo /etc/init.d/apache2 restart

The Test repository can now be accessed via http://localhost/svn/test

Reference

https://help.ubuntu.com/9.10/serverguide/C/subversion.html

Installing Eclipse Galileo on Ububtu 9.10

2009-12-26T15:02:00.003Z

Before installing Galileo on Ubuntu it is worth making sure you have a decent and reasonably recent Java SDK. Open a command prompt and enter:

sudo apt-get install sun-java6-bin sun-java6-jre sun-java6-jdk

enter the root password and follow the instructions. Once the SDK is installed, check the version:

java -version

This should give you something along the lines of:

java version "1.6.0_15"
Java(TM) SE Runtime Environment (build 1.6.0_15-b03)
Java HotSpot(TM) Server VM (build 14.1-b02, mixed mode)

If you get something that suggests a different SDK is install run the following command to remove it and try again:

sudo apt-get autoremove

Then download Eclipse from the Eclipse download page: http://www.eclipse.org/downloads/

Once downloaded unarchive it:

tar xvfz eclipse-jee-galileo-SR1-linux-gtk.tar.gz

and move the eclipse directory into /opt:

sudo mv eclipse /opt

It is now possible to run Eclipse with the following command:

/opt/eclipse/eclipse

however, as Eclipse uses the latest version of GTK and this is not installed in Ubutntu 9.10 by default, a number of dialog buttons will not work. To work around this problem create the following script in the eclipse directory:

gedit /opt/eclipse/launch.sh

#!bin/sh
export GDK_NATIVE_WINDOWS=1
/opt/eclipse/eclipse

Then use the chmod command to make it executable:

sudo chmod +x /opt/eclipse/launch.sh

Noe Eclipse should be launched by calling the script:

sh /opt/eclipse/launch.sh

and all buttons should work correctly. Finally to create a desktop icon, right-click on the desktop and select Create Launcher. Enter Eclipse as the name and the above line as the command and click OK. Then right click on the desktop icon and select Properties. Click on the icon and navigate to /opt/eclipse and open the icon.xpm file. Then click OK to close the properties dialog.

Java Dependency Management with Ivy - Part II

2009-12-22T11:56:00.002Z

In Part I of Java Dependency Management with Ivy I looked at basic Ivy usage and configuration using Ant and the Ivy Eclipse plugin, IvyDE. I demonstrated how Ivy can be used to download modules (dependencies) from a repository, such as the Maven Repository and cache them locally, negating the need to check them into a source control system.

However there are some scenarios where the Maven repository is not suitable:

1.Your development team may not have direct access to the Maven repository or you want to prevent each module from being downloaded more than once.
2.You may want to restrict or specify the modules your development team has access to.
3.You want to use libraries such Microsoft's SQL Server JDBC driver or your own propriety JARs that are not hosted in the Maven repository.

Ivy and IvyDE can be easily configured to look at custom repositories. In this article I will discuss a way of setting up a local public repository and a shared repository, and how to reference them from Ivy and IvyDE.

In my previous article I also explained the difference between a repository and a cache. As I am going to look at repositories in a little more detail it is worth repeating the distinction. A cache is usually local. When you do a build, Ivy checks the cache to see if you already have the required modules. If you do, it uses them, otherwise it looks in one or more repositories for them and downloads them. Repositories can be local, but tend to be remote on the internet or on a central server in an organisation. Maven is a repository and stores a large number of modules.

More

House of Suns

2009-12-19T12:15:00.004Z

House of Suns
by Alistair Reynolds
ISBN: 978-0575082373

This is much more like it! Reynolds' best work outside of his Revelation Space series. I loved the characters, their interaction and the way he swapped the first person between the two main characters and the young Abigail Gentian.

From reading the back of the book, which describes Abigail Gentian splitting herself into multiple clones, two of whom fall in love, I was expecting the two lead characters to both be female. Maybe that would have been a step too far?

Reynolds describes this book as stand alone on his website. I'm really rather hoping there will be some more.

Gun at Nottingham Rock City 2009

2009-11-26T19:33:00.001Z

First up were New Device, a very good young rock band. Good vibe, good sound and tight musicians. Very enjoyable to watch, I won't be buying any if their CDs though.

Gun, to my surprise had the ex-little angel Toby Jepson singing for them. A deeper voice than the original singer, but still very good. They opened with don't say it's over, which is one of my favourite songs. About halfway through the show was stopped by Toby as someone was starting a fight. He demanded they were thrown out as there was no place for that behaviour at a Gun gig. Inside, outside of love included a cover of the Police's So Only. All the way through, Gun made it clear that Les Paul guitars were made for Rock bands like this. They finished with Steel Your Fire and Shame on you. And Encored, of course, with a superb Word Up, the place erupted.

Threshold at the Garage 2009

2009-11-26T19:31:00.001Z

Pythia, a fairly good female fronted metal band, were up first. The matching tshirts were a bit much , as was the shrill, slightly irritating singer. Overall I quite liked them, but not enough to be persuaded to buy their CD from the merchandise stand.

Serenity, who were up next, completely blew me away. An absolutely superb prog/power metal band. They were heavy in places along with great ballads and an exceptionally strong signer. They did persuade me to part with money for both of their CDs!

Threshold are always superb. Plain and simple. They played lots of old stuff as well as some new stuff. I loved it all. The guitar sound wasn't mixed properly in critical mass, which was a shame, and I had to leave early to get a tube. I only missed Mission Profile, Pilot in the Sky of Dreams and Slipstream, but given that they are three of their best songs, I did miss out.

Stranger in a Strange Land

2009-11-05T19:47:00.002Z

by Robert A. Heinlein (978-0340938348).

This book lacks much real science fiction. At most it's a fantasy book. What it really is is a dig at society and religion and that, unfortunately, stifles a story that actually isn't there. Many science fiction books make these points as well, but that doesn't make this science fiction. If this was a relatively new book I'd say it's all been done before, but given its age, all I can say is that it's all been done again since and better. If I was reading it in the 1950s or when I was a teenage boy, I'm sure I would have loved it.

One ray of light in an otherwise dull read was one of the main characters, Jubal. The story is very much told through his, very sensible, view on the world. He understands everything perfectly, has seen it all before and is never fazed by anything. While everyone else is giving into their prejudices and preconceptions he is watching and making sense of it all.

The ending was probably the worst part. The main character is murdered for the good of the people, his followers rejoice and then he visits Jubal from beyond the grave. Time for some more Alistair Reynolds I think.

Item 57 - Use Exceptions only for exceptional conditions

2009-10-18T10:46:00.000+01:00

Using exceptions only for exceptional conditions is something we can all agree with. However, this item should have been named "Don't use exceptions for control flow and how to decided between state-testing method and distinguishing return value". Bloch gives an example of how exceptions can be used for ordinary control flow, two alternatives in state-testing method and distinguishing return value and how to choose between them. I was rather hoping for some discussion of what exception conditions are, not just a brief discussion of what they are not.

Java Dependency Management with Ivy Part I – The Basics

2009-10-11T14:40:00.001+01:00

Along with the rich enterprise libraries that come as part of the language, one of the biggest advantages of Java is the vast number of third party libraries available. For example if you are writing an enterprise web application, GWT, Spring and Hibernate provide a framework with a huge amount of pre-existing functionality.

The size and number of dependencies grows as your application grows. GWT and Spring alone, without their dependencies, are more than 7MB. The ideal place to put dependencies is in a source control repository as part of your project so that when you or your continuous integration server check out the project for the first time all the dependencies are there. Then you don't have to go and get them and store them locally in a location that is agreed by the entire development team.

Storing the dependencies for a single project in a source control repository isn't too bad, provided there is plenty of room on the source control server.. However, if you have more than one project using the same or similar sets of dependencies the amount of space taken up in the source control repository starts to get a bit ridiculous. And then when a new version of a library comes out and you upgrade, even more space is wasted as the differences between binary jars cannot be detected, so the entire jar must be replaced.

Read more

Item 55: Optimize Judiciously

2009-10-11T14:31:00.001+01:00

Bloch gets this item so right! He includes some famous quotes about optimisation and of course the most well known one:

We follow two rules in the matter of optimisation:
Rule 1: Don't do it.
Rule 2: (or experts only). Don't do it yet.

But Bloch doesn't leave it there. He goes on to summarise the rules with "measure performance before and after each optimization attempt." We all know this, but how many of us actually do it?

Actually I've seen these rules put to bad use and Bloch covers that too when he points out that you should still be thinking about performance issues when writing code. The example I've seen is someone retrieving a lookup table from a database for each iteration through a dataset, rather than reading it once and caching it. At least that optimisation was straight forward.

The new information that surprised me a little was that it appear to be accepted that Java does not have a strong performance model. We all know Java is traditionally slow, but i must admit I thought performance had been greatly improved in recent years. Of course the “semantic gap” between what the programmer writes and what the CPU executes is far greater than in traditional programming language.

I almost didn't need to write a summary as the final paragraph of the item summarises it so well.

Item 49: Prefer primitive types to boxed primitives

2009-10-11T14:24:00.002+01:00

This is the first item, certainly that I have reviewed, where I feel Bloch has it spot on. There's no arguing with this one!

Bloch points out that Java has a number of primitive types such as int, double and boolean and each of these types has a corresponding reference type: Integer, Double and Boolean. These are the boxed primitives. Auto-boxing and auto-unboxing was introduced into the language in 1.5, so the Java programmer must now be more mindful of their use.

There are three main differences between primitive types and boxed primitives:

Primitives have only their values, whereas boxed primitives have identities distinct form their values

Primitive types cannot be null, but boxed primitives can

Primitive types are more space and time efficient than boxed-primitives

Care must be taken with using the == operator with boxed primitives as, with any other reference type, it compares identity and you almost certainly want to be comparing value. If a boxed primitive is compared to a primitive with the == operator, the primitive type is boxed and the identities compared, so care must also be taken here.

The process of boxing and unboxing, especially in a loop can serious impede performance.

Basically, boxes primitives should be avoided unless primitive types cannot be used, such as in collections or as parameterised types.

ACCU Conference 2010 Proposal (2): Java Dependency Management with Ivy

2009-09-26T11:22:00.002+01:00

Type: case study
Duration: 90 min
Speaker name: Paul Grenyer

Speaker Biography
Paul has been programming in one form or another for over 20 years. After several years using C++ and a brief period using C#, Paul is now happy somewhere he hoped he'd never be, programming in Java.

After time in industries such as marking machinery, direct mail, mobile phones, investment banking and Internet TV, Paul is currently working for an exciting new company based in Norwich where he heads up an ever growing team of senior and highly skilled people.

He has been an ACCU member since 2001, a regular publications contributor, including the now well established Desert Island Books column, creator of the mentored developers and a committee member for most of that time. When he's not programming and family life allows, Paul thoroughly enjoys science fiction, heavy metal and cycling.

Description
One of the biggest advantages of Java is the vast number of third party libraries available. As the size and number of third party libraries used grows your application's disk footprint also grows. The ideal place to put dependencies is in a source control system as part of your project. This means that when you or your continuous integration server check out the project for the first time all the dependencies are just there.

Although, storing the dependencies for a single project in a source control system isn't too bad, if you have more than one project using the same or similar sets of dependencies the amount of space taken up in the source control system starts to get a bit ridiculous. And then when a new version of a library comes out and you upgrade, even more space is wasted as the differences between binary jars cannot be detected, so the entire JAR must be replaced.

In this session I will demonstrate how easy it is to integrate Ivy with Ant and Eclipse and use a couple of XML files to manage dependencies without the need to check large numbers of JARs into source control. You will also see how to setup a local repository for any proprietary libraries or versions of libraries not in the publicly available repositories.

Bloodstock 2009

2009-08-22T09:08:00.001+01:00

This year was one of the best Bloodstocks ever, which surprised me as the line up didn't look too strong. I haven't come away with a list of bands I want to buy all the albums of, but I did enjoy a lot of the performances.

Insomnium[6] sound a lot like Swallow the Sun and Paradise Lost. They put on a very good show. I find a lot of old thrash bands quite boring, but Sodom[5] were quite good. They could have done with a second guitarist and the bass broke in the first song and it seemed to take ages to get it fixed. Saxon[8] gave us some some classic traditional heavy metal. Solid, as expected. The best bit was, following the guitarist standing on a monitor, Biff Bifford ripped off the sign saying "DO NOT STAND" and showed it to the audience. Once their sound was sorted, Arch Enemy[10] stole the show. They turned out not only to be the best band of the day, but of the festival, but then that's what you'd expect from Arch Enemy. Carcass[4] were very disappointing. They played some stuff from Heartwork, but none of their set had the best sound. Arch Enemy should have been on last.

Just like all the other folk/battle metal bands Battlelore[3] were, bland and rubbish which was not helped by the poor PA setup. Wolf[7] were much better than last time I saw them at Bloodstock (when they lost sound part way into their set). Still the same old Slayer/Metallica/Maiden wannabes though. With the Haunted [1] I just didn't see the point. To stoner like for me maybe. I haven't seen or kept up with Entombed[7] for ten years or more. They're great. Especially A Damn Deal Done. Lots of fun. Candlemass[2] seemed to play quite well, but are just not my sort of thing. I was hoping Enslaved[5] would be great from the off, but all they really managed was ok. Good fusion of black and death metal, nothing new. Kreator[8] are like Deicide and Like Slayer, only better. Loved it. Band of the day. All I can say about Apocolytica[1] is nice idea, but the only thing that makes this metal is the drummer. I'm sure some love it, but I don't. I wanted not to like Blind Guardian[5] as their Twyst in the Myth album is rubbish, but they weren't too bad. What can I say about Cradle of Filth[4]? They were half an hour late to the stage. They were really loose, but better than the last time I saw them. Then they called it off after Paul A got hit on the back by a gob stopper fired from a catapult bought on stage. Not very metal, especially when Dani Filth had been goading the crowd to throw full drinks rather than empty ones. To be honest if the Bloodstock organisers are going to book a band like Cradle of Filth to festival many of us believe represents true metal, what do they expect? I Hope Cradle of Filth never darken Bloodstock's door again.

Beholder[6] gave us some straight up metal and despite the singers verbal diarrhea Surprisingly good. For Agonyst[9] I was in a tent full of familiar faces from the Marquee in Norwich, including Louis Coates on the stage. Totally superb progressive death metal with a great sense of humour. Girlschool [4] were disappointing, but then they probably weren't good musicians 30 years ago either. Equilibrium[8] are a great band! They want to be death, folk, black and battle metal, but I like it! Anathema[9]: Wow! Another band I haven't kept up with for 10 years. Opened with my favourite song and did a stonking set of old stuff. With Martin Powel (ex My Dying Bride, ex Cradle of Filth) and one of my favourite and best drummers in the work, Nick Barker (ex Cradle of Filth, ex Dimmu Borgir) on drums and finishing with an iron maiden cover of Phantom of the Opera, Anathema are the second band of the festival. Wish I'd kept up with them over the years now. Turisas [6] weren't quite as good as expected. There was a bit more music and less larking about this time though. Good entertainment none the less. Moonspell[8] were very good as expected. Just wish I knew more of their stuff better. Amon Amarth[9]: Death Metal! Wow! As good as expected. Loved it. I was a Viking for an hour. Satyricon were very enjoyable to watch, but they've only really got one sound, not that it's a bad one. I enjoyed them more at the last Download. The singer is a great entertainer. Europe [5] didn't have a good sound, at least where we were standing. The bass swamped everything. I did wonder if maybe they'd turned it all up to try and feel heavier to a metal audience. Joey Tempest always proclaims John Norum as a guitar god and he just isn't that good. I was horribly disappointed as prior to today I rated them as the second best live show I'd ever seen (after Wasp performing the Crimson Idol and closely followed by Roger Waters, Pink Floyd, The Mission in 1995 and Fish performing all of Misplaced Childhood). I'm hoping bloodstock get a decent headliner next year after three duff ones this year.

There's rumours of Threshold playing again next year. I suspect the best they can hope for is a special guests slot, but even that is unlikely. If they play it'll just be superb. The organisers need to look at the tshirts people are wearing. I'd love to see Lamb of God, Deicide, Behemoth, Vader, Nile, Hypocrisy. Cradle of Filth and Europe just aren't what Bloodstock is about.

Century Rain

2009-08-22T08:40:00.004+01:00

by Alistair Reynolds (978-0575076914)

Alistair Reynolds is still by far my favourite author and he never fails to amaze and surprise me. I've said it before, and I'm sure I'll say it again, but nothing else he's written, for me, gets anywhere near as good as his Revelation Space series. I'm sure it's just the lack of scope of a stand alone novel compared to a series.

I enjoyed Century Rain, but I don't think I'll read it again. The ending was rather cliché and I think I'd rather have seen the bad guys win for a change, although it wasn't clear to me when they were trying to wipe out the ALS, I probably missed it somewhere. This book is a lot easier to follow than the Revelation Space novels.

In a few books time I'll be reading House of Suns. Hopefully this will live up to Revelation Space.

ACCU Conference 2010 Proposal (1): Enterprise Web Application Development in Java with AJAX and ORMs

2009-08-02T10:28:00.002+01:00

Type: case study
Duration: 90 min
Speaker name: Paul Grenyer

Speaker biography
Paul has been programming in one form or another for over 20 years. After several years using C++ and a brief period using C#, Paul is now happy somewhere he hoped he'd never be, programming in Java.

After time in industries such as marking machinery, direct mail, mobile phones, investment banking and Internet TV, Paul is currently working for an exciting new company based in Norwich where he heads up an ever growing team of senior and highly skilled people.

He has been an ACCU member since 2001, a regular publications contributor, including the now well established Desert Island Books column, creator of the mentored developers and a committee member for most of that time. When he's not programming and family life allows, Paul thoroughly enjoys science fiction, heavy metal and cycling.

Description
Recently Java enterprise web application programming has been leaning towards a more classical J2EE approach. Traditional Java Server Page (JSP) programming, and even libraries such as Struts, are being replaced by new AJAX libraries that make GUI programming more straight forward, robust and easier to unit test.

In this session I will look at what an enterprise web application is and why you should choose an AJAX based library for GUI development over traditional JSP libraries and an Object Relational Mapper (ORM) over traditional JDBC for the Data Access Layer (DAL).

I will look at an AJAX library and an ORM Library and present simple examples of how and where they should be used. I will then look at how to integrate the AJAX library into traditional Spring MVC and how to use Spring Security to authenticate users of the application and secure individual Remote Procedure (RPC) calls made from the client application, running in a browser, to the server.

In the final part of the session I will take a more in-depth look at the ORM library and explain how to use a registry to abstract away Data Access Objects (DAOs) so that the real DAOs can be used in production and integration testing while seamlessly substituting mock objects for unit testing. I will also explain how the tools provided by Spring make integration testing of DAO objects very simple.

Terminator Salvation

2009-06-22T19:55:00.004+01:00

Terminator Salvation is a big disappointment. Maybe it's the lack of Arnie (well except for a short scene that was almost certainly superimposed from a previous film) and a story line, but it just didn't feel like a terminator film. It wasn't going anywhere and it never got to the part where John Connor sends Kyle Reese back to save his mother. There is also way too much of a gap in story line since the previous filem. We need more action, more story and more Helena Bonham Carter, please!

It really seems like the Terminator producers are writing perpetual sequels which never actually get anywhere. I was asleep by the end.

Steel Panther

2009-06-22T19:39:00.002+01:00

Finally a band that might be able to take over where the Darkness left off. Steel Panther sound enough like Poison, Motley Crue and Def Leppard to be radio friendly (in the US at least) while are heavy enough to get away with calling themselves a metal band and singing about metal.

Musically Steel Panther are great. What lets them down is the lyrical content and it let's them down big time. Death To All But Metal is amusing and genius, but just about every other track on the album is either embarrassing toilet humour or unnecessarily derogatory towards women. It's not big, it's not clever and I'm sure they could do better.

Putting the lyrics aside this album is a great listen and just what the rock genre needs at the moment to combat the current crop of bland rubbish such as the Kaiser Chiefs.

Here's hoping Steel Panther pull it together for their second album and grow up a little.

Effective Java

2009-06-22T19:38:00.001+01:00

Item 44: Write doc comments for all exposed API elements

The item does not even attempt to justify or explain it's reasoning. It just states that "If an API is to be usable, it must be documents". This is complete rubbish. A good Java developer can use and API by reading it!

It then the proceeds to make the frankly ludicrous statement "to write maintainable code, you should also write doc comments for most unexported classes, interfaces, constructors, methods and fields." The lack of maintainability of code is most of my problem with this item. Adding comments in the fashion simply duplicates what is already in the code, increasing the maintenance the code required. History dictates that developers are very good at updating and fixing code, but not the associated comments. Good code only has comments where it is necessary to say why and never how.

The item also states that "The doc comment for a method should describe succinctly the contract between the the method and its client." No! That's what the method name and signature should do.

In general, but not always, comments are a bad thing and should be used sparingly. The only time I can see doc comments being a good thing is if you're writing a library for someone else to use where you don't want them to have to look below the public interface.

The remainder of the item describes the details of how to write doc comments.

Pushing Ice

2009-06-08T18:50:00.003+01:00

By Alistair Reynolds (978-0575078154)

Having read all of Reynolds' Revelation Space series I was a bit disappointed by Pushing Ice. Obviously there is far less scope in a standalone novel compared to a series, but the story took quite a while to get going and didn't really contain any new science fiction.

The book draws heavily from both the Space Odyssey and Rama series and even steals the "First Ones" concept from Babylon 5.

Reynolds successfully induces a sense wonder and makes you want to read on to find out what's really going. The ending is a little week and there are many questions left unanswered, but the scene is set for two possible sequels. If he writes them, I'll read them!

If you're new to hard science fiction or to Alistair Reynolds then this would be a good place to start.

Agile Testing: A Practical Guide for Testers and Agile Teams

2009-05-24T21:07:00.002+01:00

by Lisa Crispin and Janet Gregory (978-0-321-53446-0)

This book is pretty much what it says on the tin and that's a good thing. Behind all the usual Shiny Happy People Having Fun stuff you usually get in books from the Agile community is some sound, well expressed advice. This isn't just a book for Agile testers. There's a lot of good practical information that all testers should learn. It's a difficult balance to achieve, but I think the use of the word Agile may put of a lot of people who should really be reading this book.

As well as the general practical testing advice the book also covers a lot of fundamental Agile stuff. It sets out some Agile testing principals and discusses the problems a lot of teams have when transitioning to Agile. It's all been written before, but never from a testers perspective, but to be honest it's not that different from the developer perspective.

The book is very hung up on the idea that developers in Agile teams, and indeed testers in or joining Agile teams have difficulty seeing how testers fit in as developers are doing unit testing and therefore the code is supposedly already tested. Personally I feel that anyone who doesn't understand that not everything can be unit tested and see that “independent” testers are vital is probably in the wrong job. The book made me view our owner tester, who does not come from a programming background, in a totally different way. Instead of seeing him as someone who just carries out the manual user interface tests, I now see him as an integrated member of the team who needs to take part when requirements are gathered and should also be writing integration and end-to-end tests as well as maintaining continuous integration. The necessary training has now commenced.

Most of the Agile discussion is at the beginning of the book. The practical stuff comes later and is quite detailed, including most of the sorts of testing, including automated GUI testing, that should be carried out.

I think this book will make most people think differently about testing in a good way.

Tomcat Servlet with Spring Timer

2009-05-22T19:51:00.001+01:00

recently had a requirement to write a service, in Java, that monitors a directory and when new files with the correctly formatted name appear, send them to another system. All fairly simple stuff. There are many different ways of writing Java services, but we use Tomcat quite heavily, so rather than investigate another way, I decided to write a Tomcat servlet to act as the service.

I started off by extending GenericServlet and overriding the init and destroy methods to write log messages to standard out. Then I wrote the appropriate web.xml to tell Tomcat about the servlet and wrapped it all up in a war file (basically a zip file with a Tomcat specific directory layout) and deployed it to my local Tomcat installation. I then checked the logs and found the log messages I'd put in the code. Not bad going for twenty minutes work and my first Tomcat servlet written from scratch.

We've been gradually learning about Spring recently and I remembered reading that Spring had timers that would be perfect for polling the directory for files. So I integrated Spring into my servlet, repackaged and redeployed it and then checked the logs to make sure the Spring application context had fired up correctly. It had.

Next I created a Ticker class by implementing the Java TimerTask interface and implementing the run method to write "Tick" to standard out. I then registered the class as a Spring bean and created a Spring ScheduledTimerTask, set the tick interval to one second and created an anonymous TimerFactoryBean. Making the TimerFactoryBean anonymous causes it to be instantiated when the Spring context is started, rather than waiting for an explicit instantiation from code somewhere. So, what should happen is that the ticker should start as soon as the application starts. Sure enough as soon as I repackaged and deployed, "Tick" was written to standard out every second.

It occurred to me that the class extending GenericServlet was redundant. So, not expecting it to work, I removed the class from the servlet and web.xml entirely and repackaged and redeployed. That's when I had my real "Whoah! That's really neat!" moment. To my amazement and joy the ticker started again and kept ticking every second. I already knew Spring and Tomcat worked well together, but having Tomcat start the Spring context without needing a servlet class is pure genius.

It may seem like such a small and simple thing, but creating my first Java service and Spring timer and having them work together in a very simple way was a real revelation for me.

ACCU Conference 2009

2009-05-18T20:52:00.003+01:00

Wednesday Keynote: The Birth of Software Craftsmanship by Robert Martin

Brilliant! Simply brilliant! Uncle Bob is an enthusiastic and wonderfully engaging speaker. Through this keynote he chronicled the, now well understood, pitfalls of big upfront design, the emergence of XP and the birth and journey to maturity of Agile. Bob explained how Agile was adopted by business as it is more people focused than XP and how that caused the technical practices that made XP so good to be left behind. He highlighted how we need to reengage with the technical practices moving forward. We should all be using Test Driven Development, Continuous Integration and Pair Programming and Uncle Bob demonstrated why. In 2009 the benefits of using these are measurably several magnitudes greater than not using them. Uncle Bob has also brought out a new back to basics book to help us all remember how to write good code.

Security in Distributed Systems and SOA by Nicolai Josuttis

At previous conferences it has always been very difficult for me to find sessions that are directly related to my everyday work, so Nico's session intrigued me greatly as securing web services is something my team was due to attempt shortly after the conference. Together with joining the ACCU Nico is responsible for kick starting my career. I learnt more about C++ and the standard library from his book than almost any other source. What I learnt, in a very short period of time, allowed me to absolutely trounce a job interview and increase my salary by 30%. So I always try and go to Nico's sessions.

The session was everything I hoped it would be and answered some key questions that had been going around in my mind for some time. Nico took us through the different issues and methods of securing web services and methods of avoiding common denial of service attacks, such as XML bombs.

Measuring the Effect of TDD by Keith Braithwaite

This was another interesting session, but unfortunately some of the maths and detail went over my head. However, the gist was that code that is designed for test and has good test coverage is almost always less complex and "better" than code that does not. Instead of this being just a general feeling, Keith showed how this could actually be measured.

The Model Student Episode II: A Fresh Hell by Richard Harris

Richard Harris is one of the brightest people I know and his command of maths far outstrips my own. I completely failed to follow most of his talk, but it was fun when I got picked on to choose the numbers in the Countdown simulation. The session was full of entertainment and special effects and left me wondering what Richard would do to better it next year.

Keynote: Welcome Crappy Code - The Death of Code Quality by Nicolai Josuttis

I wasn't the only too come away from this presentation wondering if Nico had lost the plot. I must admit I found myself hoping that Nico's German humour had got lost in translation somewhere. The basic message was that we as developers are not given time to write good code, so we should stop worrying about it so much and accept crappy code. The whole way through I was waiting for the punchline that never came.

Thursday Keynote: The Benefits of Abstraction in Patterns by Linda Rising

Linda Rising is obviously very passionate about patterns. She sees them, quite rightly, everywhere. Not just in software engineering. I'm sure there was some very interesting material in her presentation, but unfortunately it was all lost in the delivery which was slow and at times a little boring.

Memory Allocation and Garbage Collection in Java by Angelika Langer

This was another session where I was hoping to learn something that I could apply in my everyday work and I wasn't disappointed at all! Before the session started I was wondering how Angelika was going to fill 90mins with a relatively straight forward and well understood subject like garbage collection in Java. However, she went in a great deal of detail about the Java memory model and how it has evolved, especially with respect to threading. Angelika also covered some of the tools that can be used to see what is happening with memory inside the virtual machine.

Kirk Pepperdine also attended the session and, as always, took over in a few places. However, I think everybody enjoyed and learnt from his interruptions.

Designing for Testability by Sami Vaaraniemi

I've been designing for testability for years and I wanted to go and see if someone else had a different take on it. Unfortunately Sami, ironically a Microsoft employee, was explaining a lot of stuff such as the use of interfaces and the bridge pattern that I've been using a long time. To my dismay, amongst other things, he also advocated having constructors just for testing purposes where a solution that at least called the production constructors as well could have been employed. There was a lot of useful information for the novice here, but a little bit of caution is required.

Friday Keynote: Geeks, Nerds and Other Prejudices by Susan Greenfield

Susan Greenfield's key note was highly enjoyable and entertaining. She looked at the differences between men and women at the brain level and proved, with plenty of humour, that women are no less capable than men at computer science and pointed to the way in which society portrays computer science and computer scientists as the reason few young women choose a career in IT. Of course if this presentation was flipped on its head and became about why men are as good as women at computer science it would have been condemned as sexist!

Boilerplating Database Resource Cleanup by Paul Grenyer

Paul Grenyer was brilliant! Superb! The star of the conference....Well of course I wasn't really and if I had been I certainly wouldn't be bragging about it. I do feel, however, that this was my most successful presentation to date. Not in terms of number of attendees, but due to the new confidence I feel when presenting. It all comes down to preparation and practice. Next year I'm going to do another 90 minute presentation (if they'll have me).

Processors Processors Everywhere, But How Do I Actually Use Them? by Russel Winder

As I have said in the past, I find Russel very entertaining and this was another enjoyable session where Russel demonstrated the performance of a number of different languages (C, C++, Java, Python, etc) in a threaded environment. Unsurprisingly Java didn't do very well compared to C++. Again, I learnt plenty and was able to contribute. This was three hours well spent.

Saturday Keynote: Considerations for Successful Management

Allan has passed over to the dark side and frustratingly is very good at it. During his session he gave a lot of common sense practical advice about managing agile teams and of course plugged his book.

All in all this is probably the most useful ACCU conference I have been too. I learnt a lot of stuff that I have since been able to apply and there's more to come. During the week I was persuaded, not only to edit three issues of CVu but also to join the conference committee, so I am looking forward to helping shape another great conference next year. Roll on 2010 (isn't that the year we made contact?).

Broken Angels

2009-04-17T12:59:00.004+01:00

by Richard Morgen (978-0575075504)

Broken Angels may be "the new diamond hard novel from the author of altered carbon", but it isn't anywhere near as good. It's not a bad novel, but I did find it took quite a while to get going. Once it did get going it was much improved.

In life, as well as in books, I like to know what's happening and why. Broken Angels is almost like a description of what's happening, without any explanation of why and I found that frustrating, but it also encouraged me to finish the book. Most events are explained towards the end.

Kovacs changes side a few times and sometimes that can be difficult to understand and follow. The violence and the sex is still there. In fact Morgan has stepped them up slightly.

I will be reading Market Forces at some point in the future, but if that isn't better I will probably let Richard Morgan go by the wayside.

Setting-up GWT-Ext for GWT 1.6 with Eclipse

2009-04-13T18:12:00.002+01:00

GWT-Ext is a great set of widgets for the Google Web Toolkit (GWT). At the time of writing the release candidates for GWT 1.6 are out. GWT 1.6 has a different project structure and embedded Java Servlet (Jetty) server. These changes bring the advantage that the project structure can be deployed directly to a Java Servlet server (such as Jetty of TomCat) without having to manually create the WAR directory. A slight disadvantage is that the setup documentation for GWT-EXT is no longer quite right.

Below I describe the steps necessary to create a GWT 1.6 project with eclipse and configure it for GWT-Ext.

Install the Google Plugin for Eclipse (http://code.google.com/eclipse/docs/getting_started.html).
Use the plugin to create simple GWT application:
1. Select File -> New -> Web Application Project from the Eclipse menu.
2. In the New Web Application Project wizard, enter a name for your project (e.g. MegaDeth) and a java package name, e.g., com.megadeth.
3. Take the tick out of the Use Google App Engine tick box.
4. Click Finish.
To run the application:
1. Right click it in package explorer and select Run As -> Run Configurations
2. Put a tick in the Automatically Select Unused Port tickbox.
3. Click Run to see the default GWT 1.6 application
Download gwtext-2.0.5.zip, unpack it and copy the gwtext.jar to war\WEB-INF\lib in the project directory.
Create a js directory in the war directory of the project.
Download ext-2.0.2.zip, unpack it and copy the contents to the js directory.
Right click on the project in package explorer and select Refresh so that eclipse can see the new jar and js directory.
Add gwtext.jar to the project:
1. Right click on the project in package explore
2. Select Properties -> Java Build Path -> Libraries.
3. Click Add JARs, navigate to gwtext.jar in the project and double click it.
4. Click OK to close the properties dialog.

In the project's gwt.xml file (e.g. com.megadeth\MegaDeth.gwt.xml) at the hightlight lines below:


<inherits name='com.google.gwt.user.User'/>
<inherits name='com.gwtext.GwtExt' />
...
<entry-point class='com.megadeth.client.MegaDeth'/>
<stylesheet src="../js/ext-2.0.2/resources/css/ext-all.css" />
<script src="../js/ext-2.0.2/adapter/ext/ext-base.js" />
<script src="../js/ext-2.0.2/ext-all.js" />

Change the project's entry point (e.g. com.megadeth.client.MegaDeth.java) to the following:

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.user.client.ui.RootPanel;
import com.gwtext.client.widgets.Panel;

public class MegaDeth implements EntryPoint 
{
 public void onModuleLoad() 
 {
  Panel mainPanel = new Panel();   
  mainPanel.setTitle("Hello World!");
  mainPanel.setHeight(300);
  mainPanel.setWidth(500);   
  RootPanel.get().add(mainPanel);
 }
}

Remove the following from the project html file (e.g. war/MegaDeth.html):

    <h1>Web Application Starter Project</h1>

    <table align="center">
      <tr>
        <td colspan="2" style="font-weight:bold;">Please enter your name:</td>        
      </tr>
      <tr>
        <td id="nameFieldContainer"></td>
        <td id="sendButtonContainer"></td>
      </tr>
    </table>

Run the application as before to see a GWT-Ext panel.



Lacuna Spellbound
2009-02-25T08:58:00.001Z
Lacuna Coil are one of those bands where I've bought every album only to discover I only really like one of them in it entirety and then odd tracks here and there. The album  I like is In a Reverie and the odd tracks I like most are Swamped and Heaven's a Lie from Comalies. Comalies, and indeed Unleashed Memories are good albums, but I get board very quickly and there's nothing to keep my attention. The much anticipated Karamcode was simply rubbish and therefore I didn't play it more than a couple of times.

I've seen Lacuna Coil live three times and every time they were disappointing with little stage presence. They certainly couldn't compete with their genre counterparts Nightwish.  

Today I heard the track Spellbound, from the new album on thier MySpace page. Although it's only three and a bit minutes long it gives me hope for the new album, Shallow Life, out in April.


Bitter Chilli
2009-02-15T09:16:00.001Z
Readers of this blog could be forgiven for thinking I mostly use it to whinge about poor customer service, but it's happened again.

Charlotte and I went out for Valentines day last night. I'd booked us a table at Sweet Chilli in Norwich. When we got there we discovered that they were only doing set menus at a minimum of £25 a head. This wasn't mentioned when I booked.

Neither Charlotte or I wanted to eat a starter, main and desert, let alone pay over £50 for a meal we couldn't choose. So shortly after our drinks arrived we got up and walked out. I explained the situation and exactly why we were leaving and asked to pay for the drinks, but unsurprisingly I didn't have to pay.

Amazingly we managed to get a table at old faithful, Pizza Express just across the road and we only had to wait about twenty minutes. We couldn't get the table we wanted, but the service was excellent and the food as good as ever.

After a few drinks in the Marquee we had a great night.


Developing a Spring Framework MVC Application
2009-02-15T09:13:00.001Z
Last night I finished reading Developing a Spring Framework MVC application step-by-step by Thomas Risberg, Rick Evans and Portia Tung. It's excellent. They develop a Spring application almost exactly the way I would with unit tests, separate integration tests that talk to a real database, an abstracted data access layer to allow substituting of mock objects and ant based deployment and manipulation of TomCat.

If you need to develop an MVC Spring application start with  Developing a Spring Framework MVC application.