NoSQL Distilled: A Brief Guide to the Emerging World of Polyglot Persistence (February 2013)

Quick read, comparing current NoSQL options objectively, discussing cases when and when not to use a certain kind of store. Main concepts of different kinds of storage technologies are presented by presenting concrete products as examples (MongoDB, Riak, Neo4J, Cassandra). Additional thought is given on how to actually use these non-RDBMS stores in a software design (Aggregates, Repositories, Services).

Objective-C Programming: The Big Nerd Ranch Guide (November 2012)

This is a short, well-written book. My Kindle says it has 263 pages, but a lot of pages contain screenshots and other helpful pictures.

The book can roughly be divided into three parts.

The first part is an introduction to the C programming language. It introduces concepts like functions, variables, expressions, conditionals and requires no prior programming knowledge. Only little Objective-C is sprinkled in at this point.

The second third deals with Objective-C. The language is not only demonstrated theoretically but by writing small amounts of code directly in the Xcode IDE. That way you will learn the important language concepts and navigating Xcode along the way. This repeated ‘concept, code, compile in Xcode’ cycle helped me a lot in getting up to speed with the language very quickly.

The last third applies that new knowledge by building two applications, one for iOS and one for Cocoa. It ends with some advanced topics on C and Objective-C.

After reading this book I am tempted to think I could have picked up Objective-C from Wikipedia and the official Apple documentation on my own; Objective-C feels like such a modest but well-designed step away from C that it is not very hard to learn if you already know some C. But the bits of information on iOS and especially Xcode that are additionally explained make me glad I chose this book so I could learn Objective-C directly within the ecosystem I plan to use.

I highly recommend this very motivational book.

Seven Databases in Seven Weeks: A Guide to Modern Databases and the NoSQL Movement (October 2012)

This book is a great introduction to the world of ‘polyglot persistence’. Seven different database technologies are presented ranging from a classical relational database (PostgreSQL) over key-value stores, document and column stores (Riak, MongoDB, CouchDB, etc.) and a graph database (Neo4J) makes an appearance.

Each chapter is dedicated to one of the databases. It explains basic installation and how to fill the database with (sometimes large amounts of) data to play with in the remainder of the chapter. During the course, the reader not only learns about the database itself but also about techniques such as SAX XML parsing or asynchronous file operation APIs. In that sense, this is a real hands-on book.

The theory behind each technology is described, but the explanations do not go too deep. I found the presentation of pros and cons of each technology a little bit too vague and at times lacking important detail.

Overall the tone of the book is very neutral, and none of the databases is presented as the best solution. This book contains a lot of knowledge on the current state of database technologies and trains a ‘right tool for the job’ attitude along the way. I recommend it.

Java Concurrency in Practice (July 2012)

This book gives a detailed look into the tools the Java platform provides to write concurrent programs. It explains techniques to write correct and efficient thread-safe code and the necessary basic theory behind them.

I very much liked the style; it is very readable, not casual but not dry either.

The trend these days clearly leans towards languages and platforms that aim to give their users ‘out of the box’ solutions to concurrency-related problems. This book helps to understand where the limits lie in writing highly performant concurrent programs - in general and especially on the Java platform.

Working Effectively with Legacy Code (June 2012)

I was somewhat disappointed by this book. The advice presented boils down to:

  1. Use good object-oriented design.
  2. Know your programming language.
  3. Apply test-driven development.

The book assumes the reader is new to OOP. Concepts like TDD, Liskov substitution principle, decorator pattern, and command-query separation are explained in boxes spread throughout the book.

Many techniques are shown for breaking up dependencies and getting your code under test. Most of them rely on common sense advice such as:

  • Make your dependencies explicit (e.g., using dependency injection).
  • Consider wrapping external code.
  • Separate concerns, strive for high cohesion, and low coupling.

In general, the book is well written, has a direct style, and stays true to its title. This is a good book, especially recommended to everyone new to TDD or OOP working on C/C++ systems.

The Mythical Man-Month (May 2012)

Being released in 1975, this title is a long-time classic in software engineering and project management. Brooks describes his insights gained from developing the OS/360 at IBM in the 1960s.

His central claim, Brooks’ Law, is that adding manpower to a late software project makes it later. He goes on to explain which forces in developing software systems lead to this effect in a way that resembles my experience from the present.

Many of the technical aspects of this book are outdated by now. However, the central learnings on how to assemble teams effectively and how to help them build large software systems still seem utterly relevant today.