What's on my bedside and in my head

I'm always reading two or three development related books in parallel. I'm trying to keep the number down and aim at never working more than two books simultaneously. More than two will cause a tempo that's too slow and a momentum that's too low. That's usually what make me quit books. In a way I guess it's self adjusting but I usually want to finish the books I start.

Anyway...

Programming Pearls
I just finished reading the second edition of Programming Pearls by Jon Bentley. The first edition was written  1985 while this edition was written 1999. In other words, this is a real classic. :-)
The reason I got interested in the book was an anagram coding kata described by Dave Thomas. After doing the kata a few times with various approaches Goggled the problem to see what alternative solutions there were to the problem. I think that a post on Stack Overflow pointed me in the direction of this book which presents a complete and very elegant solution in less than 20 lines of C-code. In addition to being very elegant it's also very fast.

When reading that solution I felt I wanted to see more code like that and figured that there might be more of interest in the book. The book is focused on classic (but of course still very relevant) programming. By that I mean that it has a high focus on algorithms and data structures rather than program structures and and code organization (a.k.a Design Patterns et. al).
There are a lot of discussions covering various sorting and searching algorithms and suitable data structures therefor. There are also about a zillion references to Donald Knuths The Art of Computer Programming which is really dear to the author.
Other topics covered in the book include program verification, back of the envelope estimations and code tuning.
The verification parts were nice to read and (obviously) not fully aligned to today's TDD trends. Rather the author leans on setting up invariants describing facts that must hold at various places in the code to allow reasoning about the correctness of the code. To me this looks like something not too far away from what has been tried in formal program verification.
Back of the envelope estimations is a practice used far to seldomly when assessing if the system we've built (or are about to build) is up for the task it's meant for. The book gives some good estimates on which you can lean when doing these estimates as well as some good techniques and advises.

Overall the book was a nice read and there were some really nice pearls in there although I have to confess that I didn't find any other of them as nice as the anagram program.

Spring in Action
The other book I've been reading lately (and still am) is the third edition of Spring in Action by Craig Walls. I'm reading it more to try to grasp what the Enterprise Frameworks that are used in Java are all about rather than for Spring specific knowledge. I figured that since Spring is such a widespread and almighty framework an introduction to it would give me the introduction to the "Enterprise World" that I needed.

Even though I'm not a huge fan of these heavy duty frameworks with a ton of XML, annotations and even some byte code manipulation the book is a nice read. It serves my purposes quite well.
Spring is a topic far to wide for one book if you want to dig really deep but this introduction will show you the basics and allow you to attain the knowledge needed to search more information on you own.

What's next?
Now I will (finally!) allow myself to go Clojure in my reading but I'll tell you more about that in another post...