... innovative techniques
that work ...

This is our compiled list of highly recommended books, articles and references that we think are worth the investment (time and in some cases $s). Many of these we bring with us to our training workshops as handouts or so you can take a bit of a look (for books). We're sure there are heaps of other useful books/articles out there - but these are the ones we know are good.

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

Posters

A result of collaborative work between Dwayne Read (Agile Coach), Scott Ambler (Senior IT Consultant and Principal) and Shawn Espenlaub (Agile Team Leader/Business Analyst) to provide a meta-model of Agile Modeling using real-world examples.

This is a FREE downloadable copy of the Agile Modeling by Example (pdf - 7.5MB) poster. Many thanks to the many Agile practitioners that have provided the examples (Fairpoint, Zoodata/2CC and PDC Consultants) and given feedback on the various versions to date (esp. the Perth Agile Meetup group).

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

The Scrum training workshop demonstrates the use of various styles of Retrospectives. We discuss the pros and cons of the styles and which style is best suited for particular situations. Here's a FREE downloadable copy of the handout (pdf) that summarises some of the Retro styles covered.

Agile

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).

Software in 30 Days, 2012, by Ken Schwaber and Jeff Sutherland

Clear and concise discussion of the Scrum practices and events in the overall context of being agile. Scrum has evolved over the years and this is the latest and refined version from Ken and Jeff who share their experiences in the applied use of Scrum and the real reason behind particular practices. A must read from cover to cover...

Lessons in Agile Management: on the road to Kanban, by David Anderson

An excellent guide to applying Kanban with a range of real-world examples and analogies to get the key principles across. It covers a range of agile practices in the context of managing developments using the pull-process of Kanban. Kanban is an excellent approach to portfolio & program management as well as for the more interrupt-driven support/BAU activities.

Agile Estimating and Planning, 2006, by Mike Cohn

Mike shares his wealth of experience in working with agile projects with a lot of clear and practical advice on applying a range of estimation and planning agile practices and techniques (e.g. Story Point and "ideal" day based estimation, prioritisation (themes, business features, stories), Planning Poker, etc) and how they relate to other common agile practices. Mike also highlights the people/role side of these activities as these techniques are so much more than just coming up with a number.

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).

Agile Analysis

Agile Modeling: Effective Practices for eXtreme Programming and the Unified Process, 2002, by Scott Ambler

Clear guidelines and useful examples for the communication tools of the Agile practitioner, from simple use-case diagrams and UI sketches for requirements understanding to class and sequence diagrams for design. The messages of "Simplest tool (eg. whiteboard)" and that "most models are temporary" are key.

Specification by Example, 2011, by Gojko Adzic

This is Acceptance Test Driven Development (ATDD) (or Spec by Eg - SBE) explained with real-world examples/case studies. The key process patterns are well articulated and provide a clear guide to maximise the benefits of ATDD. There's a range of practical hints that also give further insight into the practical application of this approach. This is what is meant by "concurrent testing" - it starts as an executable spec.

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).

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.

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.

People/Style

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 at the end of each chapter (you could almost just read these).

User Interface

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.

Envisioning Information. 1990, by Edward Tufte

A classic view to creating a range of visual representations. It's more about the fundamental concepts and reasons behind visual communication tools and uses a range of examples (maps, town layouts, art, tables, illustrations, etc) to get the point across. The "Micro/Macro Readings" and "Layering and Seperation" concepts are a good read. Thanks to Lee Campbell for suggesting this book.

Architecture

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...).