GT Software

This slim tome is like a revolution in software development; instead of eternal deliberations with functional specifications, design specifications and maybe a bit of coding, XP (eXtreme Programming) develops incrementally to produce regular releases that the customer can see and respond too. Now that's a gross simplification of XP; its not that XP is against design or gathering specifications, its more a recognition of the uncertainties between the customers' project requirements and the developers' understanding of them.

The book is split into short chapters that make it an easy read and easy to pick up during a long compile. XP's short iteration development cycle is described in the three pages of the second chapter. The rest of the book says why it works, addresses potential critics and examines each team members' viewpoint.

So what characterises the XP development cycle?

A customer on the team, ready to answer questions and prioritise features
Features written up as stories to plan the next release
Programmers informally paired up to implement a story (yes, two programmers sat up to one workstation!)
Writing tests before coding
Confidence to alter the design with Refactoring
Integration completes a story by passing the tests
Frequent releases
Managers can actually measure progress and manage

This was the first XP book, but now there's a range of them that help to put it in to practice. I hope the brief description fires you up enough to take a longer look at it. I completely recommend this book! No reservations at all! Buy it, read it, do it.

Refactoring

'Improving the design of existing code'

By Martin Fowler, with contributions by Kent Beck, John Brant, William Opdyke and Don Roberts.

ISBN 0-201-48567-2

Second printing July 1999

431 pages

cover

The subtitle 'Improving the design of existing code' really sums up the aim of the book. Starting in the real world where code exists and changes need to be made, refactoring sets about to make changes possible in a way that is safe and leaves a design that is better. The only other alternatives are rewrites or monstrous carbuncles of code crawling one on top of another, not pretty or maintainable.

Deciding where to make changes to the code starts with distinctive smells that help identify where to apply refactoring first. Those smells are briefly described, two or three to a page, with pointers to those refactorings that might be suitable. The changes are often very minor, say moving a method from one class to another, but the effect can really clean up the design or promote the code's own self documentation (with meaningful function names that don't try to do too much at once). The safety comes in the form of automatic tests that the developer codes before the change, tests, makes the change and runs the tests again; leaving a feeling of confidence and regression tests as part of the system.

The ways to improve existing code is laid out in a format very similar to that of the classic Design Patterns and less well known Analysis Patterns (the latter also by Martin Fowler). Each refactoring is listed on the inside cover and then has 3 or 4 pages devoted to it; usually starting with a bit of UML, a longer explanation with notes on similar refactorings to consider, and the mechanics of implementing the refactoring. Examples are usually given to firmly pin down the change for the reader, and code examples are given using Java (these are very accessible to C++ developers).

Apart from the nuts and bolts of refactoring, the book explores how to introduce refactoring in to the workplace, especially overcoming prejudices. I liked the advice to not tell your project manager but to just get on with refactoring. Refactoring is mentioned many times in eXtreme Programming books, and this book explains what is meant and is never too far from XP.

I like this book. I can understand if readers find the discipline of making changes one small refactoring step at a time to be tedious or unworkable, but I would urge you to buy the book and try it!

UML Distilled

Second edition

'A brief guide to the standard object modeling language'

By Martin Fowler, with Kendall Scott

ISBN 0-201-65783-X

185 pages

cover

UML is inescapable in the computing industry; magazine articles, job requirements, books and designs all use it. However, while its often encountered, there's a lot of confusion as to how the various diagrams should be used. This book spends a couple of chapters saying why its good to design (there's a strong hint of XP), before describing each of the UML diagram types with examples, notes and recommendations. Each diagram is well explained and the examples really do help to clarify how to use a diagram and when it would be appropriate.

UML is still changing and Martin Fowler has updated the text to cover UML 1.3. The diagrams are:

Use case diagrams
Class diagrams (these are most frequently encountered diagrams that show blocks representing objects and their interfaces)
Interaction diagrams (these are my favourite as they show the dynamic behaviour of the system)
Package diagrams and collaborations
State diagrams
Activity diagrams (these remind me of SDL, showing how parallel activities can happen)
Deployment diagrams

To finish the book, the author presents a small design with an aim to showing how UML can be used in daily development. I didn't find that chapter useful, and was surprised that it didn't cover the range of diagrams that had just been described. Apart from that, I found this to be a very pleasant read, and easy to pick up for a short chapter. As the title suggests, this book does not try to be a UML reference, but it does succeed in making UML quickly accessible to the reader. It's also worth mentioning that the book is about UML itself, and does not discuss it in the context of any particular UML tool; indeed I doubt whether some of the diagrams in the book could not be produced in the popular UML systems.

So I do recommend this book, but please be aware that you'll need a UML reference too, or a UML system manual, before you can start full reverse engineering life cycles.

Numerical Recipes in C

Second edition

By William H.Press, Saul A. Teukolsky, William T. Vettering and Brian P. Flannery

ISBN 0521431085

994 pages

cover

This is a famous reference tome packed full of algorithms implemented in C. If you want to get a head start with linear algebraic equations, sorting, fast fourier transforms, partial differential equations and compression coding then this is what you need. Every recipe has its brief explanation (often with full mathematical symbols!) and its C implementation.

It has to be said that real maths rarely crops up in everyday software development, but for those odd occasions that it does, then this is the book of choice. You will need to be able to read the symbols and grasp what they mean though, otherwise a lot of this will remain impenetrable!

Better still though, since the authors have moved on to C++, you can now refer to the C (and Fortran) book text for free from http://www.nr.com/ in PostScript or Adobe Acrobat (PDF) format. The authors hope you'll want to buy the hardcopy once you have perused a few chapters.

Numerical Recipes in C++

Second edition (*see below)

By William H.Press, Saul A. Teukolsky, William T. Vettering and Brian P. Flannery

ISBN 0-521-75033-4

C++ edition originally published 2002 (February)

1002 pages

Well it's just arrived, and my first reaction is second edition? Since its based on the previous Numerical Recipes in C, the book has inherited the 'second edition' status. It's not often that I read the publishing details in great depth, but this is interesting as the book is a free license for the individual owner of the book to personally type routines in to a single computer for personal use. A machine readable version can be purchased on CD for £35, or downloaded from the Numerical Recipes Software Web site http://www.nr.com where immediate purchase is possible. Use of the recipes for anything commercial involves an additional fee.

I've had the chance to use the book as a reference now, and I must admit to feeling disappointed. The feeling arises from the presented code examples which I feel have not really made the transition from C to C++. Apart from Appendix B, I haven't encountered the C++ class at all. Indeed the only concession seems to have been the use of a NR namespace! Functions are typically long sequential associations of processes; not object oriented.

The best way to describe the topics covered would seem to be to list the major contents headings.

Preliminaries
Solution of Linear Algebraic Equations
Interpolation and Extrapolation
Integration of Functions
Evaluation of Functions
Special Functions
Random Numbers
Sorting
Root Finding and Nonlinear Sets of Equations
Minimization or Maximization of Functions
Eigensystems
Fast Fourier Transform
Fourier and Spectral Applications
Statistical Description of Data
Modeling of Data
Integration of Ordinary Differential Equations
Two Point Boundary Value Problems
Integral Equations and Inverse Theory
Partial Differential Equations
Less-Numerical Algorithms

I haven't needed a book like this at any time during my first 20 years of developing, and you probably won't need it either. However, I recently started some development involving serious data analysis and the book was essential. So if any of the chapter titles (except Sorting) matches your field of work then I believe this book is essential for you. However, I do dislike the charging structure; what other software development book imposes this?

Designing SVG Web Graphics

By Andrew H. Watt

0-7357-1166-6

400 pages

cover

Published in September 2001, this must be one of the first books to cover the capabilities of Scaleable Vector Graphics (SVG).SVG files are XML text files incorporating key words from a standardised vocabulary to describe graphics building blocks. The vocabulary includes items describing fonts, colours, shapes such as rectangles and circles, colour gradients, screen positions and orientation.

When a SVG file is downloaded from a Web page to a browser, the browser has to handle the job of interpreting the XML text and produces an image. As current browsers generally are not designed for this task, SVG viewer plug-ins are available to enhance the browser's capabilities.

The author discusses the SVG viewers available - easily available by download from the Web. With a viewer such as Adobe SVG Viewer (recommended) the author illustrates a diverse variety of graphic examples on a series of downloadable files mirroring the book.

Those of you who remember the early days of Java 1.0 applets will remember the rash of blinking text characters and moving banners which early Web page designers found hard to resist. That was also based on the client-side browser doing the work, so what is new with SVG? The author sets out his stall with enthusiasm, and although a tad over-evangelical, makes a good case.

Using the SVG vocabulary, quite complex graphic designs can be delivered down from the Web server in perhaps 40K of text, keeping download times short. For text characters, SVG, being vector-based, is able to scale up characters to large sizes without losing definition or looking like a mosaic representation.

There are impressive effects available such as colour gradients, and Bezier curves which produce nicely smoothed curved lines from my wobbly freehand drawings. The simple command "animate" can produce movement in positions or rotation, and since the XML model allows nesting it is possible to build up a complex part of a picture and move it or manipulate its orientation or size. As a subset of the increasing XML capabilities, the SVG set of techniques does have a promising future.

The author builds up his exposition gradually with full code examples all the way.There were times when I felt an O'Reilly sub-editor would have cut the number of pages down from 544 pages by moving rapidly to the available standard vocabulary, but the book is easy to read and at any point it is easy to view the examples given and to test them by modifying the text to vary the display. Although we will have wait for the wider usage of SVG viewers or for a new generation of browsers to incorporate SVG viewing capabilities, the book is well worth reading now by early adopters of SVG.

Java Cookbook

By Ian F Darwin

ISBN 0596001703

650 pages, with downloadable source code

cover

This book is aimed at programmers who are already fairly familiar with Java. The author's format is to pose a problem, indicate a solution, and then explain the salient points in the solution together with text source - complete programs rather than just program excerpts.

As the author of the Perl Cookbook, Darwin already has a devoted fan club and will add to it with this book.

As a lazy programmer, if I need to check a reference on more basic Java code or syntax not covered by the IDE documentation, I reach for the magisterial "Java 2 - The Complete Reference" by Herb Schildt, but the Java Cookbook is well worth its place beside it on the bookshelf within reach. It is also usable as a good crosscheck. For example, on the question of setting up persistence for key-value pairs as strings, Darwin shows how to use the java.util.Properties object, but is sufficiently up to date to point out that in JDK 1.4 one could use java.utils.Preferences objects.

The style is attractively spare. For example the chapter on XML is only 16 pages long but includes XSLT transforms, parsing with SAX and DOM, refers to JDOM and gives a program for converting from XML to Adobe FrameMaker�s MIF format. The chapter on email is all of 44 pages long and within that gives 9 programs on reading and writing email using Java.

This is an enjoyable book which encourages dipping into to discover valuable nuggets of code as much as a secondary reference. Thoroughly recommended.

The Dilbert Principle

By Scott Adams

ISBN 0752272209

336 pages

cover

I'd be surprised if you hadn't already encountered Dilbert the cartoon strip where office workers strive against poor management and stupidity from their cubicles. This book contains many comic strip reprints along with emails from fans sharing their bizarre experiences. Scott Adams ties this all together with his own brand of humour and observations.

While the book is entertaining, what lifts the book for me is the last chapter "The new company model: OA5" where Scott Adams presents his ideas for management as "Out At 5"; presented with bullet points to keep it short and snappy. There's a lot of sense in that last chapter!

I like this book so much that I bought a second copy. Someone else liked it so much they borrowed it and never brought it back! This book has a changed cover and is in a smaller format; I preferred the slightly more expensive original as the larger pages and softer binding are easier to get in to. I'd recommend paying the extra for the original format.

Dogbert's Top Secret Management Handbook

By Scott Adams

ISBN 075221148X

176 pages (probably, as they're not numbered)

cover

This book completes its title with 'As told to Scott Adams' which matches the tone of the text; it's as if evil Dogbert's words had been transcribed on to the page, complete with its mild abuse. As with most of Scott Adams' books the text is interspersed with reprints of the comic strip which not only liven the subject up inadvertently also show how the pointy haired boss artwork has changed over the years. I noticed the artwork detail as I found the text unrelenting and the amusement factor to be low. So I'd recommend skipping this book.

Teach yourself SQL in 10 minutes

By Ben Forta

ISBN 0672321289

258 pages

Published May 2001

cover

While I usually steer clear of the sort of book that promises to teach something in less time than it takes to be delivered, I did give this one a try and I'm really glad.that I did. Each part of SQL is clearly presented with lots of examples and tips on syntax differences between SQL implementations. At the back of the book are some particularly useful appendices; Appendix B covers popular applications, devoting about a page to each one. Appendix C collects the SQL syntax in to just 5 pages for easy reference. I'd recommend buying this small book to learn SQL and also as a quick reference. You'll also need another reference for putting the the ideas in to action, though you can experiment online on sites like http://www.sqlcourse2.com

PHP and MySQL Web Development

By Luke Welling and Laura Thomson

ISBN 0672317842

867 pages with CD

Published March 2001

cover

My initial impressions are very favourable. I'll post more details soon.

UML Toolkit

(includes CD-ROM with Rational Rose 4.0 demo)

By Hans-Erik Eriksson and Magnus Penker

ISBN 0-471-19161-2

397 pages with CD evaluation of Rational Rose 4.0

cover

I've been promising to review this book for quite a while now. I wondered at my reluctance and I've come to the conclusion that each time I went to refer to it I just didn't get what I wanted from it. When it first came out I thought the inclusion of Rational Rose was great, but now that you get UML free with your morning cereal I can't nail down anything to recommend it for. Not what I'd expected, sorry. I mean it sounds like its a useful toolkit to have around when putting your design down as UML. I think that you're probably better off spending the time using a UML tool much as reading this book.