Books

These are the development-related books I’ve read in recent times (some of them only tenuously related, I’ll admit!).  I usually only buy books which have been recommended or score highly on Amazon, which explains the generally high marks.  They’re basically in the order I read them.

This is a work in progress as I haven’t posted reviews for many of the books yet, but like a true Agilist I thought I’d let you have the benefit of the ones I’ve done right away!

Index

.


.

Pro C# 2008 and the .NET 3.5 Platform

Andrew Troelsen

An excellent book on all things C# and .Net.  Although the framework is now very large, this book still manages to cover everything from data types through to WCF (partly by being a hefty 1300+ pages!).  The newer technologies such as WCF and WPF have largely replaced things like Remoting and Winforms, although there is still a chapter on Winforms.

This book is well-written, with a conversational style which encourages you to keep going – I basically read it cover to cover, although this did take several months as there’s a lot of code to write if you want it all to stick in your head!  It gives everything good coverage and explains concepts well, with many useful code examples and exercises to complete.  And while it covers the basics well, it goes into some depth too – after I finished the chapter on CIL and wrote some of my own, I really felt I was getting the hang of .Net!

In summary, a great way to learn .Net if, like me, you like to read through a book – but not so good as a reference.  I look forward to reading the copy for C#4, 5, 6…

9/10

.


.

The Mythical Man Month and Other Essays on Software Engineering

Frederick P. Brooks Jr.

For a more thorough description of this, see my blog about it.  Suffice to say, it’s a development classic, whose thoughts on project management and development are still as true today as they were 30 years ago – although the few hardware-related notes are quite amusingly out-of-date!  Should be at the top of the list for anyone involved in the management of development.

7/10

.


.

Code Complete: A Practical Handbook of Software Construction

Steve McConnell

If I had to pick one book for all developers to read, it would be this one.  While it covers the complete spectrum of development, from requirements though to testing, most of the book is dedicated to what it calls ‘software construction’ – what I refer to as the nuts & bolts of programming.  This covers everything from good class design, through subroutines and control structures, right down to the level of data types, variable naming, and formatting code – all given a thorough treatment based on many years of experience, plus a host of studies and facts, which explain not only what you should do but why, with all of the pros and cons included.  The code examples are given in a variety of languages including Java, C++, Visual Basic & C#, but don’t worry if you’re a pure .Net coder, they’re all pretty easy to understand.

These low-level topics are followed by a look at some higher-level issues, such as optimisation, code quality, and managing development, all of which contain excellent advice from someone who has clearly spent many years doing, thinking about, and researching these topics.  While some of the specific code advice of earlier chapters might be more use to the intermediate developer that somebody advanced, I defy anyone not to get something useful from these later sections.

If you write statically typed code, and you’re an intermediate-level developer, this book will help you improve you more than anything else I’ve come across.

10/10

.


.

The Pragmatic Programmer

Andrew Hunt, David Thomas

tbc

8/10

.


.

Head First Design Patterns

Freeman et al

tbc

7/10

.


.

The Art of Unit Testing: with Examples in .NET

Roy Osherove

tbc

7/10

.


.

Microsoft Application Architecture Guide (2nd Edition)

Microsoft Patterns & Practices

tbc

2/10

.


.

Peopleware: Productive Projects & Teams

Tom DeMarco and Timothy Lister

tbc

10/10

.


.

Head First HTML with CSS & XHTML

Elisabeth Robson, Eric T Freeman

tbc

9/10

.


.

Refactoring: Improving the Design of Existing Code

Martin Fowler

tbc

9/10

.


.

The Art of Agile Development

James Shore

tbc

8/10

.


.

Behind Closed Doors: Secrets of Great Management

Johanna Rothman, Esther Derby

tbc

8/10

.


.

Don’t Make Me Think!: A Common Sense Approach to Web Usability

Steve Krug

tbc

8/10

.


.

The Design of Everyday Things

Don Norman

tbc

6/10

.


.

Lean Software Development – An Agile Toolkit

Mary & Tom Poppendieck

A relatively brief look at how the lean manufacturing principles made popular by Toyota can be applied to software development.  As stated in the book, this is more about high-level ideas than concrete practices, and as such doesn’t provide detailed information about Kanban or other lean development techniques – but there are certainly some interesting ideas here.  Many of them simply address good agile practices, whether you’re interested in lean or not – in fact I’d say this is one of the best books on agile I’ve read.

Despite it’s fairly small size, it has a lot of information and as well as talking about ‘last responsible moment’, ‘pull systems’ and other lean techniques, goes as far as detailing how these ideas work with schemes like CMM and the types of contracts that work in an agile business relationship.  Well worth a read for anyone with an interest in agile or lean.

8/10

.


.

Working Effectively with Legacy Code

Michael Feathers

Legacy code – bane of the modern developer, but unfortunately something most of us have to deal with on a regular basis.  And with Feather’s definition of legacy being ‘code without unit tests’, I’d say many of us are still writing legacy code right now!

If you’re looking for an easy answer, you won’t find it here – this book describes a variety of techniques you can employ to help you work, but none of them are silver bullets, simply patterns and techniques to help you get the legacy code into a better shape to work with, one small step at a time.

The main focus of this is around making code testable, so that you can safely refactor and improve the code without breaking existing functionality, as well as safely adding new features – although there are also sections on understanding code, working out where to add a feature, and so on.  If you don’t like unit testing, you won’t like this book, but if you do it’s got a lot of good info – many of the techniques discussed will help in writing new code as well as working with legacy.  A variety of languages are used, primarily C++ and Java, although most of the techniques can be easily translated to C# and the like.

The only real thing I have against this book is that it doesn’t cover what is probably my #1 problem dealing with legacy systems – business logic in stored procedures!  In fact it doesn’t really cover databases at all.  Perhaps that’s a lost cause, but I think it deserves at least a mention.

In summary, a well-written book covering a fairly boring subject, perhaps not a page-turner but not a struggle to read.  Useful for any serious developer.

7/10

.


.

Patterns of Enterprise Application Architecture

Martin Fowler

Although it’s a few years old now, and somewhat behind the curve with regards to ORMs and the like, this book is a must-read for anyone wanting to progress beyond basic development in the enterprise space.  It contains two sections, with a general but thorough overview of the enterprise issues followed by detailed descriptions of the  50-odd patterns, nearly all with examples in code (mainly Java, with some C#).  Written with typical Fowler humour, it’s an enjoyable read which can be tackled cover to cover, although you might find some patterns not applicable for various reasons.  And although written in 2003, Fowler’s crystal ball must have been running on full power, as the issues he saw as important at the time of writing have almost universally come to be.

The patterns themselves are fairly high level, things like Active Record, Data Transfer Object, and Pessimistic Offline Lock, so it’s better if you understand some of the lower-level GoF type patterns before you tackle this.  If you’re anything like me, you’ll have encountered many of these patterns before, either knowingly or not – they really are the basis for a lot of enterprise apps.  I personally got most value from the first section, with it’s discussion of the various ways of organising domain logic, and that being the root of the architectural choices.

On the down side, some of the patterns are more suited to people writing ORMs and data mappers than using them, but I think that’s because when it was written there weren’t so many quality tools freely available in that space.  It also doesn’t even try to cover async patterns, and as such will never be an entirely definitive guide – not that Fowler claims it to be.  And it primarily considers web-based systems, although most of the patterns aren’t really web-specific.

Overall, reading this book is a great step towards being able to design your own enterprise app, and provides a solid base that most of the new-fangled techniques such as DDD build upon.  If you want to learn how to write applications instead of just programs, start here.

8/10

.


.

The Toyota Way

Jeffrey Liker

From the outside this might appear to have little connection with software development, but in fact it was Toyota who pretty much started the whole lean manufacturing movement, which has been making big inroads in the software community recently in the form of lean development, kanban, and so on.

This book discusses how Toyota has achieved success through developing and following these lean practices, such as eliminating waste (e.g. excess inventory), value stream mapping to concentrate on the important aspects of a process, moving from batch processing to creating a flow, visual management systems, and more.  It also goes to great lengths to point out that the technical aspects are just the tip of the iceberg, and the whole thing is underpinned by a culture of continuous improvement, building people & relationships, long-term goals, and so on.

While you can see where the recent lean/kanban elements of software development came from, the biggest parallels can be drawn to ‘normal’ agile development.  It’s like if we were still doing waterfall, and heard about the Toyota Way, agile would be the result – the focus on people and communication, maximising value from the process (e.g. early delivery), short feedback loops, building quality in, using simple visual tools – it’s good to hear how these things work as well in manufacturing as they do in software.

If you’re interested in where the agile/lean movement came from, this is an interesting read – although pretty one-sided – and you might even get some new ideas to improve your development process.  However, if you just want to develop software better, these ideas have already been distilled for you in books like Lean Software Development: An Agile Toolkit (and pretty much any book on agile), so you’d be better off spending your time there.

6/10

.


.

The Agile Samurai: How Agile Masters Deliver Great Software

Jonathan Rasmusson

This is a fairly short and light-hearted look at Agile from the Pragmatic Bookshelf, which makes use of cartoons, pictures and conversations in a ‘Head First’ style to make this stuff easier to digest. While this might put some people off, I quite like the style, and found it an enjoyable read.

Being a fairly short book, it’s more of an introduction than an in-depth guide, and can be read by anyone involved in development (although it does go briefly into technical topics such as unit testing and CI). While it doesn’t go into a lot of depth with the subject matter, I did get a few useful ideas which I’ll definitely be trying out on my next project, particularly around project initialisation and what the author refers to as the ‘inception deck’ – a group of documents/cards you can use to get the project off to a good start and minimise the risk of nasty surprises down the line. And while the technical topics are not neglected, they certainly aren’t one of the main focuses of the book.

Overall, a great introduction, including some good ideas for the experienced agilist, but if you’re looking for detailed knowledge or more discussion of the coding side of agile then something like The Art of Agile Development might be more up your street.

7/10

.


.

Web Design for Developers

Brian P. Hogan

The cover says it all really – a book for developers who want to make nice-looking web pages.  For many developers, including myself, creating beautiful and elegantly-designed code is something that, on a good day, is probably achievable.  Beautiful and elegantly-designed web pages, on the other hand, don’t come so easily, and this book aims to help out with that.

It’s well-written and includes plenty of useful images, case studies and screenshots to help explain the points, and is easy to understand.  I was particularly interested to read about the design process, and how it follows a set of fairly straightforward steps – much like writing code, and not the unstructured approach you might imagine.  This gave me hope that I might actually be able to get somewhere with this whole design thing.

However, while there was plenty guidance on thing like colours, fonts, and layout in general, by the end of the book I still felt like I was missing the more artistic aspects of design.  While I may know the importance of making image heights divisible by the line height, I still don’t know what kind of image to choose, or where to put it for best effect.  I don’t know about  using curvy or straight lines, whether shiny buttons are important, and so on.

As stated in the book,  the only way to achieve this is by looking at other designs, dissecting what’s good about them, discussing them with people, and generally spending time on it.  I suppose I was looking for a bit of a magic cure, but much like development, being good at design takes time and effort.  However, after reading this book, I now believe I could get a decent design together, as long as I was willing to spend a bit of time on it.

7/10

.


.

Domain-Driven Design: Tackling Complexity in the Heart of Software

Eric Evans

Still reading…

?/10

  1. No comments yet.
  1. January 28, 2011 at 11:35 am

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: