Independent developer book reviews by and for practitioners

While not quite as numerous as the books on Ruby, the Groovy titles are certainly starting to accumulate. This one, by Venkat Subramaniam, co-author of Practices of an Agile Developer, is a single volume introduction that is pitched at Java programmers interested in picking up a dynamic language. It's that point about Groovy being a dynamic language that is the main focus of the book, and it's a message that is explored pretty much from the first page.

The opening section of the book introduces Groovy, and explains what it is, why it's interesting and how it uses the underlying Java platform to do all kinds of clever things that are hard to do with Java but easy to do with a dynamic language. The benefits of dynamic typing, reflection and closures are clearly explained along the way. By the end of the first section you would have picked up the core ideas and seen some simple but effective Groovy code.

Part two moves on to look at how Groovy can be used to tackle specific areas: the Groovy Development Kit (GDK), XML, databases and inter-operating with the Java language. The emphasis is on using short snippets of code to achieve things that take reams of Java code - it's not just that Groovy is less verbose, it's also the fact that you can concentrate on the problem you're solving and not the scaffolding that Java code often requires. [Continued]

An IDE is only the first and most obvious component of a complete development environment. There are build tools, source control, unit testing frameworks and a whole bunch of other tools that together make up the software development eco-system. It is this diverse and interlocking set of tools that is the focus of Java Power Tools, rather than this or that IDE (NetBeans or Eclipse, for example).

Part one of the book looks at build tools, with a chapter each on Ant and Maven (the two prime contenders in the Java world). Each tools gets an in-depth run-through, from introduction, installation and use right through to support in Eclipse and NetBeans and then on to advanced topics. In effect each chapter is a complete and self-contained tutorial. There is attention paid not just to the basics, but also to how Ant and Maven fit in to the broader development life-cycle, how each can be customised and extended and what the differences and advantages are so that you can pick one if you have the choice.

Next up is a section on version control that again looks at two solutions: CVS and Subversion. Again tool gets a single chapter (though CVS only gets 20 pages compared to almost 80 pages for Subversion). There's a discussion on the history of the tools, with a clear picture of how Subversion builds on the lessons learned from CVS. As well as command-line usage, there is also coverage of IDE support from Eclipse and NetBeans. [Continued]

I had thought that we had whelped enough and shown how much we love the planet. But no, suddenly it's back on the agenda again. The Boss has been spoken to by his Boss, who had word from his Boss that we need to do more. Apparently the wife of the CEO is very concerned that our code is melting the ice caps, killing Polar bears and penguins and causing all-round catastrophic climate change. All this from a few time recording systems…

'But there is no consensus,' I tell the Boss.

'Look, Joe,' he tells me, 'I know you mean well and all that, but the science is settled.'

'To be honest, it's not. Even the warmists are back-tracking. The science is anything but settled.'

'You'd argue with a Nobel Prize winning scientist?'

'Which Nobel Prize winning scientist?'

He looks at me like I'm an escaped lunatic. 'Al Gore of course. Christ, Joe, the man invented the internet and you still don't take him seriously…' [Continued]

Scott Bain's 'Emergent Design' ought to be a classic software development read. It covers a range of topics from across the development spectrum, it draws on work from complexity theory, agile development, design patterns and on the author's long experience in the industry. And yet at the end of the day the book is something of a disappointment. It just doesn't live up to the promise.

Part of the problem is that much of the material he covers has previously been covered to a greater depth by other people - many of them people he works with or is associated with. There's an inevitable overlap between his work and some of the other books in this series (the Net Objectives series). If you've never looked at any of these, or indeed at other books on design patterns, refactoring, agile software development and so on, then that's not necessarily a problem. For those who have then there's an air of familiarity about the contents.

This isn't to say that there's nothing of value in the book, or that the writing doesn't stand up. He does a good job of explaining the appeal of design patterns or test driven development, his writing style is down to earth and readable. The book contains anecdotes and war stories to back up the conclusions he has come to. [Continued]

There are plenty of Ruby books that explain the language or focus on Rails, so it's good to see a book that takes the time to look at how Ruby can be used to create a specific type of application. It's been said that ultimately all applications are about persisting data, which means, if you think about it, that a huge chunk of those applications revolve around producing reports. What David Berube has done is taken a look at how Ruby can be used in a range of common reporting scenarios - and that includes both Rails and non-Rails Ruby applications.

In the real world data sources come in all shapes and sizes, from embedded databases bundled with your application to databases sitting on a server to web-based sources such as Google, Yahoo, eBay and so on. The book looks at quite a range of these, starting with database access using MySQL and Ruby's ActiveRecord (part of the magic that makes Rails so powerful). It's a good introduction to the book, giving the reader a chance to see how things work and showing how it's possible to write code that isn't bound to Rails.

Of course once you've got your data you want to report it in some way. This is covered in three separate chapters that look at charting, desktop reporting (particularly spreadsheets) and making it available via the web (which is where we're back with Rails). In all cases there are useful examples and the code makes use of open source libraries and frameworks. [Continued]

Programming Groovy, Windows Vista Annoyances, Refactoring HTML and lots more...