Click on the image (or link) below to have a read (or for the books to buy on-line from Fishpond.com.au).

Several of our training courses cover the applied use of UML 2.0. We provide a FREE downloadable copy of the UML 2.0 by Example (pdf - 3.2MB) A3 guide that is used throughout these courses. Enjoy!

myMART3 - Case Study, 2010, Fairpoint Corporation

A case study of the product development of an on-line enterprise school reporting system, highlighting the key Agile techniques adopted by Fairpoint to engage the "real" users in the scoping, prioritisation, prototyping and feedback on developed features (pdf - 903K).

Going Agile - A Case Study, 2008, by Dwayne Read and Grey Properjohn

A case study of the first 6 months of migration to agile techniques undertaken at Snowden Technologies, effectively introducing agile in an agile way (ie. iteratively, involving the users, communication, reflections, etc). This was presented at the ASWEC 2008 Conference (pdf - 1.6M).

Iterative Development: Key Technique for Managing Software Developments, 2005, by Dwayne Read

A paper on the key benefits of iterative development - risk management, progress monitoring, requirements management, software architecture and even testing. This was first presented at the ICT WA 2005 Conference (pdf - 408k).

eXtreme Programming virtues and benefits, 2003, by Tim Edwards

A case study of Seeing Machines' adoption of XP (and other) practices. It looks at how Seeing Machines applied the "basic idea of embracing and incorporating change" as well as the particular sub-set of XP practices that were employed, plus a few other techniques (esp. code inspections) that were also brought to bare (pdf - 120k).

OO Migration and Software Improvement Practices, 1996, by Dwayne Read and Val Veraart

A case study of the migration to OO and some of the early agile practices by Nautronix Ltd (now L-3 Nautronix). It's a few years old (pre-UML) but the approach to change management of software development practices is certainly applicable (just some of the technology and even techniques have changed/improved).

Extreme Programming Explained: Embracing Change (2nd Ed), 2004, by Kent Beck

XP is what really put agile on the map. This is an easy to digest description of all the key rules/practices that define XP. Ultimately, "pick the eyes" out of these to improve/introduce agile practices into your projects.

Test Driven Development: A Practical Guide, 2003, by David Astels

This is the most comprehensive and practical guide for TDD we know of. Excellent for the approach at the Unit, Integration and Acceptance testing levels. The chapter on Mock Objects is a good read. Good code examples (in various languages).

Domain-driven Design: Tackling Complexity in the Heart of Software, 2003, by Eric Evans

Effectively a nice merge of XP and FDD practices, emphasising the importance of the Domain Object Model (DOM).

The Pragmatic Programmer: From Journeyman to Master, 1999, by Andrew Hunt and David Thomas

The ins and outs of software development projects, from requirements through to release. Ideal for the new developer, but also useful for experienced developers that are in a team lead position. Looks at both the technical "tricks of the trade" as well as the people factors.

Peopleware: Productive Projects and Teams (2nd Ed), 1999, by Tom DeMarco and Timothy Lister

Another classic, covering all the important human-factors involved in software development. Looks at effective team structures, key roles and even the floor-plan layouts, as well as eliminating inappropriate interrupt factors. It's effectively the psychology behind good software development - a very interesting (and useful) read.

Code Complete: A Practical Handbook of Software Construction (2nd Ed), 2004, by Steven McConnell

This is the revised version of one of the original "classics" covering a wide range of software development techniques in a very practical way. Great summaries a the end of each chapter (you could almost just read these).

Don't Make Me Think!: A Common Sense Approach to Web Usability, 2nd Ed. 2006, by Steve Krug

Lots of tricks of the trade for designing effective user interfaces. It's focus is for web page design, but most of the guidelines are applicable for all types of software user interfaces. The "before" and "after" images are very useful.

Software Engineering Disposable Packages, 2002, by Michael Tan and Dwayne Read

An article examining the business drivers and technical approach to software architecture. The focus is to enable reuseable and disposable packages that can "bolt on" (and off) to a core system (pdf - 82k).

Pattern-Oriented Software Architecture, a System of Patterns, 1996, by Frank Buschmann, et al

This is the "bible" for Architectural Patterns - has MVC, Broker, Pipe and Filters/Dataflow, etc. Very easy to pick-up and digest. Easy reference (jump straight into a particular Arch. Pattern). It was written in 1996, but is still very relevant to today's software architectures. It is a similar style to the GOF's Design Patterns book, but at the architectural level. The group have written a few of these architectural patterns books now (five at the last count), but this was the starting point (and most useful).

Pattern-Oriented Software Architecture, Patterns for Concurrent and Networked Objects, 2000, by Douglas Schimdt, et al

This is Vol 2 from the same group of guys who produced the Pattern-Oriented Software Architecture, a System of Patterns. Same top-quality reference, but obviously with a focus on the multi-threading and distributed systems. If this is a major part of your system then this is a must read.

Patterns of Enterprise Application Architecture, 2002, by Martin Fowler

A very practical (easy to digest) explanation of architectural patterns. There is no real new architectural patterns here (ie. covered in the earlier Pattern-Oriented Software Architecture books - and others), but Martin does get into platform dependencies/limitations (which is both good (to know) and bad (as it may limit your view on the suitability of the pattern). Get either of the books above first, but if they are too expensive for you then this is usually a cheaper alternative.

Agile Software Development, Principles, Patterns and Practices, 2003, by Robert Martin

Covers quite a few concepts/areas. The most useful section is on the OO Design Principles. These are a must to fully understand to be a solid architect and OO designer. The agile stuff is good, just a bit of a "stop-start" read. Robert has written some good articles (SIGS) over the years on this stuff, and this is effectively the collection of these strung together to some extent.

The Timeless Way of Building, 1980, by Christopher Alexander

Yes - 1980!! It's the analogy from the civil engineering form of architecture into software architecture that is so useful. These guys/girls have been at it for centuries (building bridges, towns, etc) and have sorted out what makes good architecture. We (software folk) can learn so much from this. It's more the "philosophy" of architecture than any particular building block.

A Pattern Language: Towns, Buildings, Construction, 1978, by Christopher Alexander

Yes - 1978!! Same as the book above.

Component Software: Beyond Object-Oriented Programming, 1998, Clemens Szyperski

This is important to know for building effective frameworks. Components are the key for defining interfaces, achieving reuse and having effective build/release management.

Refactoring: Improving the Design of Existing Code, 2000, by Martin Fowler

The refactoring principle is so fundamental to keeping a healthy architecture. If you only read the first chapter, but fully understand the principle, then its been worth it. But, do read the design refactorings (you can skip the code refactorings as they are obvious...).

Applying Use Cases: A Practical Guide, 2001, bv Schneider, et al

An easy to digest (less volume) description of Jacoboson's style of use case modelling. This covers most of the key factors you need to know to do effective use case modelling.

The Unified Software Development Process, 1999, by Ivar Jacobson

This is predominantly the re-write of Jacobson's original works on use cases (Object-Oriented Software Engineering) but brought up to date with the UML. Read this one if you want to get the most in depth understanding of use case modelling (from the man who invented it). It's a bit of a heavy read but worth it if this is a major part of your job.

Writing Effective Use Cases, 2001, by Alistair Cockburn

Comprehensive coverage (with lots of examples) of use case scenarios. Note: Cockburn is not an advocate of the diagrammatic use case modelling (Jacobson's work), but prefers the detailed scenario scripts with pre and post conditions, plus capturing both the user and system behaviours in an iteration. We recommend the diagrammatic use case modelling first with expansion into the more detailed use case scenarios (following a cut-down form of Cockburn's approach) for the more complex interactions only.

Design Patterns: Elements of Reusable Object-Oriented Software, 1995, by Eric Gamma, et al

The original works that defined OO Design Patterns (and started the whole "movement"). This is another "bible" for OO designers. You can learn so much about good OO design by studying (and applying) these patterns. Easy to read, easy to jump straight into a pattern (once you've done your problem match). There are variants of this book out there for particular languages (some good, some really bad...). The examples in this book are in C++ and Smalltalk (50/50) depending on who they came from. An absolute must have (and read many times...). Don't be put of by the year it was published - this stuff is timeless.

UML Distilled: A Brief Guide to the Standard Object Modeling Language, 2003, by Martin Fowler

A light weight and easy to digest description of all the UML modelling notations. It is not comprehensive, but covers all the essential elements of each notation with reasonable/realistic examples. The first few "overview" chapters are a bit of a waste of space, but each chapter on the UML notations is very good.

Object-Oriented Design Heuristics, 1996, by Arthur Riel

A comprehensive coverage of many "rules" that govern good OO design. It's a bit of a hard read at times (jumps around a bit), but there are lots of "nuggets" of very useful stuff here - so it's worth the effort.

UML Bible, 2003, by Tom Pender

Very comprehensive coverage of all the UML notation. Covers both UML 1.4 and 2.0, which is actually quite useful (as many of the other books, mags, websites, etc have diagrams in UML 1.4). It is a large book (900+ pgs), but is well organised and easy to find the info you need when you're focusing on a particular notation set. I wouldn't try to read it from cover to cover...

Effective C++: 55 Specific Ways to Improve Your Programs and Designs, 2005, by Scott Meyers

A must read for all C++ developers. Well laid out, takes you through all the "gotchas" of C++ and how to avoid (or at least limit) them. Very insightful and practical advice at the design and implementation levels.

C++ Coding Standards: 101 Rules, Guidelines, and Best Practices, 2004, Herb Sutter and Andrei Alexandrescu

Heaps of tips/trick/advice in working with C++. What to avoid, what to utilise, etc. There is more breadth in this book as compared to Meyers' Effective C++, but not as much depth. Some of the examples are a bit too basic (or non-existent), however still a good/useful read.

Inside the C++ Object Model, 1996, by Stanley Lippman

If you need to get every last drop of performance in your C++ application then this is very insightful. Although its getting a little dated, the fundamental OO structures (overloading, inheritance, polymorphism, etc) are still handled the same by compilers and run-time executives. Lippman explains the typical implementation that is taken by compilers and therefore what to avoid if you want really fast code.