Some self-published programming books worth knowing about
I'm delighted when I see a self-published book on software development. To take the time and put one's technical expertise into a book seems to be quite an undertaking. But this is exactly what more developers are doing nowadays, and the web's distribution mechanisms ensure that valuable material gets the attention it deserves.
Speaking of attention, here is a list of self-published programming expertise that has gotten mine lately:
Kestrels, Quirky Birds, and Hopeless Egocentricity, by Reginald Braithwaite. A book about Combinatory Logic, but illustrated with runnable Ruby programs. That just hits the sweet spot between theory and application. Ruby meta-programming is woven into the themes. A winner.
Objects on Rails, by Avdi Grimm. This one is about putting OO good principles back in the process of web application development. True OO isn't easy to get right even when given good defaults. This book builds an application objects-first style, then builds the app infrastructure around it.
(I've done database-backed application development, implemented an ORM from scratch, and used the MVC pattern for web applications. At some point, it dawned on me that this kind of project should start its life as a small, well-designed Object-Oriented system that models the core logic. Persistence and user interaction should be added as the next step.
It makes more sense to develop one's models and business objects as working OO systems before persistence and interactivity are added. Why? For one, it makes for a more modular development process; therefore, better overview and rhythm. (To take time to focus on the core logic, and only it, will pay off as better design in the end). Secondly, this allows me to think more freely in the language of the domain I'm modeling. Thirdly, it is good for rapid prototyping, but on core logic level as opposed to the UI level.
It's great to have a book that can validate (or invalidate) these thoughts).
Clean Ruby, by Jim Gay. When Alan Kay was asked what Object-Orientation meant to him, he replied: "...messaging, local retention and protection and hiding of state-process, and extreme late binding of all things" (quoted from Cunningham & Cunningham, Inc).
Much of what passes as OO today is class-oriented development. Static typing, no messaging mechanism, early binding, objects and non-objects (including classes).
That's why Clean Ruby is interesting. It's about writing Ruby in accordance to the Data, Context, & Interaction (DCI) architectural pattern. DCI is about how an object's behavior is determined by roles the object can play. These roles can vary and they are typically acquired at runtime, ie when requested by other objects. Behavior is acquired, requested, and performed at runtime. DCI looks like OO.next() - taking the Smalltalk school of OO (from which Ruby has descended) to the extreme.
I listened to Trygve Reenskaug give a presentation on DCI at Öredev 2009, and was surprised to hear him say that this paradigm could be implemented in any language. For a long time afterward, I waited for DCI to be illustrated with actual code instead of theoretical discussion.
The fact that the first book on DCI comes from a Rubyist tells me that some languages might just be more OO than others.
Some more good ones:
The SPDY Book, by Chris Strom.
Working with Unix Processes, by Jesse Storimer. Unix concepts illustrated in Ruby - neat!
Software development knowledge is acquired through hard work. Support your local self-published software expert.