Favourite Software Books: Part 1, Programming, Development and Computer Science

This is the first of three posts about my favourite software books with the emphasis on favourite - I'm not claiming these are the best books in their respective areas, and certainly not the best books for you, only that I've found them useful, and most importantly enjoyable to read. Every book here has had a lasting beneficial influence on me.

The post is broken into three loose sections - Programming, Development and Computer Science, and if you want skip wading through the descriptions, there's a Goodreads list here



Agile Software Development

There's a tension between larger scale software development and coding practice. Bob Martin's book does a fine job, probably the best job in print, of mixing high level software design with implementation execution. Worth it alone for a good utilization of inheritance, one the most abused techniques in object oriented programming. You'll also get tests, implementation detail, even non-asinine UML that might just get you pick up a pen and paper sometime. Most of what are now called the SOLID principles are detailed here, as such it's the best book written about those principles. For me ASD hits a sweetspot in Martin's work, just midway between the design precepts put down in the The C++ Report and his later thinking on testing and professional conduct

Programming Pearls

The open parts on problem characterization and getting to a solution are pure gold. Later on, the book has a chapter binary search showing how easy it is to get wrong, as an exercise in understanding both detail and correctness against input. It's no small irony that years later, the program in the book was discovered to have a bug for large integer values. This book as much as any other told me I'd probably like programming, the followup is pretty good too. Aside from that Bentley is a wonderful writer who makes the details fun.

Framework Design Guidelines

For such an important aspect of the industry there's very little material on developing software APIs. This one doesn't seem to get much traction outside the .NET world, I suspect in part due to antipathy towards MSFT - that's a great pity because this is a wonderful book on software API design. Aside from very clear technical thinking, what makes this book exception is the commentary from the framwork team around the tradeoffs they made.  Highly recommended, even if you're not on the .NET platform and I think very valuable if you're designing software APIs for other people to use.   

Structure and Interpretation of Computer Programs

SICP is arguably the best programming book ever written. It's 30 years since the first edition, but it remains relevant, remains essential and will continue to do so long into the future. The chapter on state as the introduction of time into programming is a masterpiece. I like to say that I'll never finish it, because I keep coming back to it over the years. If there's a 100 year book on this list, it's this one.



By 'development' rather than 'programming' I mean books that have a stronger emphasis on organisation and approach towards commercial software.


Extreme Programming Explained (2d ed)

The first edition kickstarted a revolution in how software teams organised and approach themselves. The second edition dials it all back down to 10, truly reflects on what Beck learned between editions, and is much the better book for it. Essential reading for delivering software. 


Despite its age and focus on a specific technical practice, remains hugely relevant to this day. Not only has influenced how developers write code - refactoring is an expected part of your job - but it's also influened tooling - almost all IDEs now support some form of automated refactoring. The contributions by Kent Beck, especially 'putting it all together' are a welcome addition. It's extremely well written and unusually engaging for what's essentially an encyclpedia of techniques although I worry sometimes that like a classic novel, it's not as widely read as it is referenced. 

The Practice of Programming

A practical, intelligent book that teaches you how to think about software. The examples are C/Unix but the knowledge you'll gain from this book is highly applicable. For a period of time, very early in my career, The Practice of Programming, went everywhere with me - I can remember reading it on Saturdays meandering around the supermarket doing shopping. The chapter on debugging is probably the best you'll read anywhere. Kernighan's a brilliant writer and this generation will know Pike primararily from the Go language, which is to say, if you like Go, I think you'll like the philosophy and thinking in The Practice of Programming.

The Pragmatic Programmer

1999 was an extradinarily good year - Extreme Programming Explained, Refactoring, The Practice of Programming, and The Pragmatic Programmer were all published.  The Pragmatic Programmer is good to read when starting out, because it focuses on overall tradecraft and has plenty of immediately applicable advice - if nothing else you'll want to read because a lot of people you will work with have, and value its lessons greatly - basically it's on everyone's list. 

Clean Code

Despite the title I've found this more of a development process book than a programming one, and one which is better known than Martin's Agile Software Development. Where Clean Code becomes invaluable is how to orient yourself and get into the right frame of mind for professional software development. Bob Martin's got strong opinions, many of which are on the money and brilliantly articulated in this book. Before this was written, McConnell's Code Complete was the go to book and influenced me greatly and I'd still warmly recommend it, but today Clean Code is the one you should read first. It's probably the best book of its kind written in the last decade.

Working Effectively with Legacy Code

This is the best book I've read on getting to grips with and wrangling existing large codebases.  Nothing really prepares you coming out of education for production software. What's not always appreciated, perhaps because of the focus on new development or the never-ending software delivery crisis, is that most code in production is de-facto code in maintenance and it takes a duty of care to keep it healthy. If you missed this book, or were put off because of words like 'maintenance' or 'legacy', do please pick it up - it's really about developing, sustaining and improving mid to large size production codebases.


Computer Science

Artificial Intelligence, a Modern Approach (3rd ed)

I'm chancing my arm here by putting an AI text into the CS bucket, but this was a gateway book for me - any interest I had (or have) in general areas like algorithmics, grammars, computation came from AIMA, whether it was wanting to understand more about natural language parsing, the pseudo-code and algorithms, or a bit more of the math behind things like neural networks. I adore this book, it's still probably the most accessible introduction to AI and Machine Learning in print.

The Algorithm Design Manual (2nd ed)

I should probably recommend a more comprehensive text like Introduction to Algorithms or Algorithms and a long time ago I spent many hours pouring over Sedgewick's books. But Skienna is the one I tend to pull down even for casual read. There are lot of excellent algorithm texts but I wish more books in this aread were goal driven like Skienna's. It has that special property that very few CS-oriented books manage to achieve, which is to make the reader feel at ease and somewhat smarter for reading it. 

Concepts, Techniques, and Models of Computer Programming

A personal favourite due to the way it provides an overview of programming models and paradigms in a way that doesn't kill you with formalisms. There are chapters on object orientation, message passing, the relational model and prolog, constraint based programming - it even has a chapter on UI programming. The authors use a technique they call the kernel language approach to build up programming styles from a base and focus on underlying models rather than any particular language (making it different from a number of books on this list).

Programming Language Pragmatics

Prior to this book I would have had the dragon book as a favourite, but PLP is for me at least, better written and more accessible. It's a good companion book to CLTM above due to its focus on the mechanics of language implementation, overview of compilers and that way it dips into specific languages. It can be heavy going in places, but it's not a math textbook about automata. There's a new edition coming out at the end of 2015. 

Types and Programming Languages

I wasn't sure about putting this on a list. I'll admit to finding parts of it hard going; I've bounced off it more than once. But it's here because typed functional programming is poised to become a dominant software paradigm much the way object orientation and dynamic programming are and have been. I can't see a future where typed FP doesn't go mainstream, this is as good a foundational book on the paradigm as any. My older self regrets that my younger self didn't work harder, much harder, to read and understand this aspect of computing :)  



Next Up

Part 2: Systems, Networks and Architecture.

Part 3: Languages, Text, and Artificial Intelligence. Although, I wanted to throw in a few now that I've found great despite being oriented around a single language (plus I'm covered a bit if I don't get round to posting the next posts soon enough!).

The C Programming Language

Crisp, well written classic. There probably isn't a superfluous word in this book. C is less widely used in my domain (web and server systems) that it used to be, and generally I've had to read C rather than write C (that's probably a good thing, I wish I was better). But this book remains valuable over the years, because it provides clear explanation of lower level programming. Even if you never had to write a line of C in your life, it's still a great book to have read.

The Little Schemer

This (along with another in the series, A Little Java, a few Patterns) is one of the first books I read that made me appreciate programming and code for its own sake and as a medium, rather than a means to an end. There really isn't anything else like it, the book is organised completely around question and answer dialog and takes a succession of tiny steps, gradually boiling you in functional and recursive programming techniques. If it sounds good, get it and a grab a peanut butter sandwich, you're in for a treat. 

Functional Programming in Scala

Many of the books here are old, a decade or more. I had thought for some time that perhaps good books were dying out - there seemed to be fewer and fewer memorable books each year - a lot of the high quality material has moved online often in short form as posts and papers. Then this one turned up. Functional Programming in Scala is the best programming book I've read in years. Even if Scala is not your thing, it's worth a read - it uses Scala to teach FP much the same way Refactoring uses Java or SICP uses Scheme.