Russel Winder's Website

Gant 0.3.2 Released

To stay in synchrony with the Groovy releases, Gant 0.3.2 has been released to coincide with the release of Groovy 1.1-beta-3. There are only a few minor bug fixes over 0.3.1 but they are worth releasing.

The new distributions are available from the Gant webpage, there is a build for Groovy 1.0, and a build against Groovy 1.1-beta-3, as well as the source tar and zip files.

PyCon UK 2007

PyCon UK 2007 was great. The talks were good, and all the delegates I met were both knowledgeable and sociable. Definitely a conference to prepare to attend next year!

Both the presentations I proposed got accepted, which was exciting for me, since I got to speak on two topics I find really interesting: programming languages comparisons, and build systems (a comparison!) - the links are to the PDF files of the slides held on the Concertant LLP presentations page. The conclusions of the first presentation were that dynamic languages (Python, Ruby and Groovy) are much better than static languages like C++ and Java for building applications, and Python is just great. The second talk concluded that Gant is great but that SCons is also extremely good - dynamic languages and DSLs rock for build systems, and SCons (written in Python) is well ahead of the field.

LugRadio recorded most of the talks from the conference, it will be interesting to see what the result is.

Talking about Gant

I was asked to give the Groovy and Grails User Group presentation at the No Fluff, Just Stuff eXchange event which was held in London 2007-08-29/2007-08-31. Naturally (!) I chose to talk about Gant. As it was the final presentation before the party, I decided to announce the "Death of XML as a Build Specification Notation". The original title of the talk was slightly different, but then that is dynamic binding for you. A PDF of the slides can be found here from the Concertant LLP presentations page.

Gant Moves Forward, 0.3.1 Released

Graham Roberts and myself were some having problems using Ant optional tasks with Gant, so I added extra classpath things:

  • A --lib option to add specific items to the classpath.
  • ~/.ant/lib/ has all contents added to the classpath.
  • if the environment variable ANT_HOME is set then ANT_HOME/lib/ant-*.jar are added to the classpath

Kohsuke Kawaguchi pointed out that Gant failed to return a sensible exit code and this was hindering Gant's use in the Hudson continuous integration system. This definitely required fixing!

The new distributions are available from the Gant webpage, there is a build for Groovy 1.0, and a build against Subversion Head r6962, as well as the source tar and zip files.

New Version of Gant Released

With the release of Groovy 1.1-beta-1 and various little things added to Gant that people had asked for, it seemed about the right time to make a new release of Gant. A major change is that targets are now called targets and are not called tasks. This seemed like a good enough reason to call this version of Gant 0.3.0. Do let me know if you like it and/or have any feedback.

Jar files compiled against the Groovy 1.0 and 1.1-beta-1 distributions can be found on the webpage at

ACCU 2007 Conference

Last week was the ACCU 2007 Conference and it was as good as ever. Serious praise to Ewan Milne, Julie Archer and all the rest of the conference committee for organizing such an enjoyable event.

Although the origins of ACCU is in C and C++ programming, Python, Ruby and Groovy are all well represented in the talks as well. As are higher level issues such as design patterns. It is generally a mix of very high quality development people taking things seriously and having a lot of fun.

I gave two presentations:

  • C++ has no useful purpose
  • Builders: How MOPs make life easy

As you can imagine from the title, the first was intended to be contentious. The room was full to bursting and included many from the BSI C++ Standard Committee and some from WG21 (the ISO C++ Standards Committee, which is meeting this week in exactly the same hotel we had the conference last week - this is by design not by accident). I opened with a variation on a Shakespeare quote:

Friends, ACCUers, programmers, lend me your prejudice I come to bury C++, not to praise it The evil that languages do lives after them The good is oft interred with their compilers So, let it be with C++.

However, in the end I got far less heckling than I expected, almost none in fact. The session was nicely interactive, but no heckling. I guess I should have been more controversial. In case you are wondering, my basic messages were:

  • C++ templates are too complicated.
  • Python, Ruby, and Groovy are the dynamic programming languages of applications development.
  • Java is the static language of applications development. (Possibly also C# but...)
  • Parallelism is here now (finally) and the functional programming languages (Haskell, etc.) are in a better shape to make use of this than any of the imperative languages.

Alan Lenton had promised to organize a lynching party, but people got too excited about the language debate, which at no time descended into flaming or language wars, and completely forgot, so I made it out. I really enjoyed the session, I hope the attendees did.

The second session was really trying to excite people about domain specific languages (DSLs) as tools for systems development. The core concept is that programming is about constructing a language in which to easily express the solution to a problem. Currently programming is creating the classes or functions to solve the problem, a side-effect of which is to construct a language to describe that solution. The "DSL Way" is to construct a domain specific language, a side effect of which is a solution to the current problem. People generally think you need a dynamic language (e.g. Python, Ruby, Groovy) to create a DSL, and indeed these languages are very good for creating DSLs. However, it is important to remember that C++ is also a very good language for creating DSLs - yes, the irony of being positive about C++ in this talk and negative about it in the previous talk is not lost on me.

I have made the slides and some of the code materials available:

Slides (PDF) | Other materials | C++ has no useful purpose | Factorial and Mailshot code ---|--- Builders: How MOPs make life easy | Examples and Presentations code

Groovy and Grails User Group London Meeting 2007-03-15

I made a presentation on Builders (in Groovy) last evening at the GGUG London meeting (held at Skills Matter). Well it should have been a presentation but it was only half a presentation due to:

The projector not talking sensibly to my computers - plural, neither of them was able to work sensibly with the projector, even though one of them had 3 months ago. Eventually I managed to get one to do something reasonable enough to do something.

Definitely embarrassing. Still I managed to talk a bit about metaobject protocols (MOPs) and how the Groovy MOP not only uses metaclasses, but also looks for the method invokeMethod in the object itself as part of method look-up, and how this allows Builders to be constructed almost trivially.

As a mentioned in the entry for the last session I did, sessions such as these are not really the place for heavyweight presentations, so although the idea was to ensure everyone understood how Builders work in Groovy, it was a fairly light talk and the slides I used have next to nothing on them. However, it seems reasonable to make them available, so you can get a PDF of them here.

Groovy has a good selection of Builders: SAXBuilder, StreamingSAXBuilder, DOMBuilder, StreamingDOMBuilder, SwingBuilder, AntBuilder, to name just a few of the obviously most useful. Since I avoid XML as much as possible, SwingBuilder and AntBuilder are the ones I have most familiarity with. SwingBuilder makes creating Swing user interfaces so much easier than writing Java code, and AntBuilder has a plethora of uses, some of them even associated with managing builds. Of course, I only use Gant now for managing builds using Ant tasks - it saves having to work with XML!

I am scheduled to give a talk on Gant at Grails eXchange, so if you want to hear more about how to manage Ant-based builds without using XML, come along. In case you weren't aware, Gant is used within Grails for managing all the activities.

New Version of Gant Released

More and more people are using Gant as their build system in preference to Ant, so I thought it time to create a new release so that people can be using all the latest features. So, I am pleased to announce Gant 0.2.4.

Jar files compiled against the Groovy 1.0 distribution can be found on the webpage at

In case you were wondering if there really were any high-profile projects using Gant, then look no further than Grails which uses Gant for managing all task scheduling - in preference to Ant.

Let me emphasize Gant does not totally replace Ant, exactly the opposite, it relies on the Ant tasks. What Gant does is replace the use of XML as the build specification language, with scripts written in Groovy. An increasing number of people prefer using a dynamic programming language for describing builds rather than using XML. Can you blame them :-)

Copyright © 2017 Russel Winder -