I've just put this book down after reading it right through nonstop for four days. I haven't done that with a technical book since Learning Perl. Most techie book these days are quickie grab bags and you end up paying for a lot of dead trees that you aren't interested in.

Well, if you are interested in decompiling Java, then this book tell you exactly how to do that. There's no fluff and every chapter counts. You'd better be prepared for some serious hard core details, but then that's what you'd paid for. It is really great to read a book that doesn't end each chapter with a few links to the real material because the author could be bothered to write it up.

Generating code is a great way to be productive, but how can you productively generate code? Jack's book is a direct, practical guide to implementing and using code generators.

If there is only one book that you ever buy about programming, make it this one. This books cuts through all the methodology madness to the heart of programming. Programming is a craft and this book shows you the path to craftsmanship.

It is short, simple and sweet. It expresses clearly why certain things feel right and why others feel wrong. It expresses in plain language all the common sense you will ever need to be a great programmer.

This is one of those rare books that is a pleasure to read again and again.

Programming is as much about people as it is about code. Death March helps you tackle the people side of working as a programmer. I have certainly found this book to be a real eye-opener, especially when it comes to corporate politics.

This book will help you understand how to manage, negotiate and survive "impossible" projects. Its main benefit is an honest analysis of the many difficult situations that programmers face. It's really great to know you're not alone, and that others have seen it all before.

A classic work on all the small details of writing software. Every character counts when it comes to source code. This books explains how to lay out your code, how to name your variables and methods, and all the heuristics that experienced programmers use everyday.

Almost everything in this book will be familiar. Its value lies in the clear and thoughtful expositions of the author. Every aspect of writing source code is carefully and clearly examined.

If you are just starting out in software, this book will save you many hours of pain. If you are already a master, this book will give you a warm glow of confirmation.

This is an interesting book. It proposes an approach to software project management that is people focused. In fact, software development productivity is assumed to follow directly from creating open, honest and genuine teams. I am not entirely convinced that this vision is achievable in practice, but there are many good ideas here.

One proposition that is particularly striking is the insistence that all decisions are taken unanimously. This is achieved by allowing each team member an absolute veto. The idea is that, with a genuine team, this will not be a problem.

Like Extreme Programming this methodology works exponentially better when all parts are implemented at once. However, unlike XP, which can be modularised, the approach in this book is based on the emotional commitment of all team members. This can be difficult to get, to say the least.

A refreshing and alternative approach to managing software development teams.

A great guide to the practical ins and outs of CVS. All issues from the client to the server are explored and explained in an easy-going and clear manner. A book to have on your desk day (and night).

What makes this book special is that it also discusses in great depth how to run an open source project. There are discussions on politics, distributed development and release policies. This an invaluable guide if you are thinking of starting your own project. It will really help you to avoid many common pitfalls.

This is a great introduction to Generative Programming. You'll be taken step-by-step from domain analysis right through to designing your own template language. Although the focus is on using specific technologies (Java and XML) to generate programs, the discussion is also a good overview of the entire field.

The main strength of this work is its absolutely practical approach. Many examples are used to illustrate key points, so that the flow of the argument is easy to follow. All in all one of the more recent classics of Generative Programming.

David and Andrew strike gold again with this one. They really like Ruby and it shows. After reading this book, so will you. Their enthusiasm is infectious and you'll soon be lashing out closures and other Rubyisms like there's no tomorrow.

Ruby is a rare mixture of the functional and procedural/OO styles. If you've always wanted to try functional programming, but were too afraid to try, Ruby is the place to start and this book is the guide.

This book covers pretty much everything you need to know, and includes a comprehensive reference section.

Perhaps a precursor to Extreme Programming, Steve's practical down-to-earth approach will appeal to those who prefer or must use more traditional software development strategies. Nonetheless, there are lots of things you can do to "tame" your schedule, all detailed in this work.

I suppose the main message from this book is that you have to have to consider risk management to be your number one priority. This is essentially recognising the uncontrollable nature of the software development process, and being prepared. It's easy to fall into a sense of false security (or rather, wishful thinking) and a false hope that enough all-nighters will save the project. This book argues for a more practical and mature approach.

This is one book that every programmer should read. It's not about programming. It's about users. Users are people too. Before I read this book I had a pretty dim view of users. Now I realise that I am also a dumb user, and so are you. No? Well, OK, so you never Push when the sign says Pull...?

The Design of Everyday Things is everything a good book should be: it's short, it's direct, it's full of examples, and it's right. If you've never given much thought to usability then this book will guide your first steps. The principles it covers are universal and well tested. At the very least it will make you think in a new way, and there's not much more you can ask for from a book.

This is another short and sweet book. I like short books. If you can't say something with brevity then it's probably not worth saying. That said, Anna Karenina is good for a laugh... Where was I? Oh Yes, this is a lovely book. If you think you know something about fonts and layout and lashing together a bit of website think again. This book is great for people with no taste (like me). Full of practical, focused and useful tips and rules of thumb for producing something that is visually appealing.

So what does this have to do with programming? Go open up a random source file and stand about 10 feet away from the screen. Does the logic jump out at you? It should. I don't care what your bracketing style is. That's not important. What is important is readability. How do you get readability? Proximity and Alignment. How do you get Proximity and Alignment? Go read the book.

If you're serious about generative programming you have to read this book first. It's heavy going and very academic, but it does provide a good theoretical framework and a nice graphical language for feature models. The second half of the book goes into some serious C++ template work which I do not understand (not enough C++ experience, I'm afraid), but it looks kinda cool. It's a classic work, and rewards careful reading.

Another good one by Steve. Although described as a collection of essays, this short book (did I mention that I like short books?) is actually a very coherent and well structured argument for the introduction of a professional qualification for software engineering. Now, while I would have some reservations, I can recommend this work as a good exposition of one side of the argument. It nearly-but-not-quite convinces me that software development can be just like other branches of engineering. Maybe it'll convince you? It's a good debate; we really should decide what it is that programmers actually do.