Software Engineering Book Recommendations

I always find it fascinating what books people prefer on various topics. I put together the following list of books I really enjoy, broken down by category. Please feel free to add to the list, or to comment on the selections.

People, Projects and surviving them both

If only software development were as simple as writing a bit of code. Here are some good books that help us better understand and survive our evolving landscape.

• Getting Things Done (@amazon)
  Sure, it’s not specifically written with the software developer in mind, but is surely one of the best personal productivity methods out there. Yes, I drank the kool-aid fullstop!
• Peopleware (@bookpool )(@amazon)
  There is a good reason why everybody and their brother recommends this book. A great book that clearly discusses the human element of software development. It’s somehow reassuring to read this classic again and again, knowing that some things never change. (the new edition has some chapters ©2000).
• Ship It! (@bookpool) (@amazon)
  Simple common-sense advice for development teams to instill a repeatable sense of quality in their projects.
• Applied Software Project Management (@bookpool) (@amazon)
  Going with another simple recommendation here. PM books can make your eyes bleed and from the perspective of Agile development most of those same books tend to be full of useless metrics anyway. This is another common-sense book that serves as a good reminder of the no-fuss basics of good project management are.
• Crystal Clear: A Human-Powered Methodology for Small Teams (@amazon)
  Another small yet very useful book on things that will allow you to make good software. The author even distills the book into a single page as a super quick overview. One issue that we see affecting us is the physical separation of teams – this is seen as a critical element to making good software in the book; unfortunately we’re not in a place to have that option.

Creating better software

It’s been said that every single piece of software on earth could be written a little smaller, run a little faster and it’s documentation could always be a wee bit better. Here are some books that aim to help in that noble pursuit.

• Refactoring: Improving the Design of Existing Code (@bookpool) (@amazon)
  Because all code can be better. I think this is the single greatest book on improving software that has ever been written. I can’t possibly love this book more.
• Code Complete (@bookpool) (@amazon)
  An award winning guide on software best practices.
• The Pragmatic Programmer (@bookpool) (@amazon)
  A true must-read for everyone involved in the craft of software engineering.

Architecture and Design

Focusing on beautiful, thoughtful and elegant object oriented design.

• Head First Design Patterns (@bookpool) (@amazon)
  A nice gentle guide through the ever-popular design patterns made popular by the GoF
• Thinking in Java (@bookpool) (@amazon)
  An incredibly detailed and well written journey through the world of Java.
• Object-Oriented Design Heuristics (@bookpool) (@amazon)
  This book outlines nearly 100 heuristics for object oriented design. The inside cover of this book lists the heuristics described within, which is a great reference when performing code reviews, or looking to refactor your own code.
• The Object Primer: Agile Model-Driven Development with UML (@bookpool) (@amazon)
  A great read and a wonderful reference for object oriented design, along with best practices for modeling those designs with UML.
• A Software Architecture Primer (@amazon)
  A truly simple approach to describing the art of software architecture. A really great book to skim through at the beginning of every project.
• Database Design for Mere Mortals (@bookpool) (@amazon)
  Because databases, like the software they support, are as different as snowflakes. A great guide to the multitude of database design concepts and their appropriate uses.

Technology Specific

• Effective Java (@amazon)
  This book goes beyond Java grammar and vocabulary (e.g. if and public class Foo to language usage. e.g. Always override hashcode() when you override equals. Joshua Bloch designed and implemented the 1.2 Collections framework, so he is considered not only a scholar on the subject of writing good java code, but also one of its most authoritative practitioners.
• Agile Development with Rails (@bookpool) (@amazon)
  The definitive, Jolt-award winning guide to learning and using Rails is now in its Second Edition. Rails is a new approach to web-based application development that enables developers to create full-featured, sophisticated web-based applications using less code and less effort. Now programmers can get the job done right and still leave work on time. – lofty book description from the publisher.
• Pro Spring (@bookpool) (@amazon)
  An intense, detailed book on the framework everybody loves to love(?). This book does not cover Spring 2, but is a fine upstanding reference anyway.
• Java Persistence with Hibernate (@bookpool) (@amazon)
  Hibernate, everybody’s favorite java-based ORM persistence tool, and a lovely deep dive into how to make the most of it in your applications. ORM is tough enough, but to then attempt to design that layer in tandem with your fancy polymorphic class hierarchy? This book helps if you like to model your classes first, or your database first.
• Struts: The Complete Reference (@bookpool) (@amazon)
  A quite-complete reference to the Struts framework.
• sed & awk (@bookpool) (@amazon)
  sed & awk describes two text processing programs that are mainstays of the UNIX programmer’s toolbox.” A great reference for these elusive tools, and a good reminder of the tenets of unix sensibilities.
• jUnit pocket reference (@bookpool) (@amazon)
  A lovely pocket reference for a tool we just can’t get enough of.
• The Elements of UML Style (@bookpool) (@amazon)
  An important book for developing accurate and expressive UML diagrams that have a solid sense of style. We’ve all seen those all-too-correct UML diagrams that felt like having a fork stuck in your eye. This is a great book for sharpening up your UML skills while taking some pointers on how to soften the edges a bit.

Thoughts from Twitter