Book Reviews
Book Review: Design Patterns In Ruby
Mar 28th
For many the idea of bringing design patterns to ruby is a terrifying one. Having taken refuge from over-engineered java projects (or for that matter, attempts to apply java engineering approaches to a somewhat dynamic language like PHP) the baggage that often goes along with design patterns isn’t what a recent convert is looking for. But as I mentioned in my last review of a design patterns volume, and series editor Obie Fernandez highlights in his foreword, design patterns don’t have to be used that way and maintain merit when used as a source of collective experience and shared language.
Russ Olsen’s book does a good job of stepping through the key patterns from the Gang of Four’s initial offering, showing how they can be applied to and simplified with Ruby, introducing along the way various uses of blocks, mix-ins, and other powerful features of the language that may be unfamiliar to newcomers. Each chapter highlights how the pattern can be used or abused, sounding a note of caution to dissuade unthinking embrace of every pattern between its covers. It’s clearly written with a nice balance of code to prose.
Towards the end of the book a couple of “new” patterns are offered, particularly “internal DSLs”, “meta-programming” and “convention over configuration.” Opinions differ over whether of those can really be considered patterns in the general sense of the term. Certainly those concepts are examples of a community gradually refining its approaches to common problems, but at least two of them are considerably more conceptual and abstract than most of the other patterns in the book. Perhaps the best way to understand them is as giving an insight into the working patterns of the ruby community approaches problems, and pointers to topics worthy of more exploration.
That usage of the final few chapters gives some indication of the probable audience for this book. It seems best suited to those who have dabbled with ruby but don’t yet have much experience. A general sense of syntax is all you’ll need going in, but you’ll come away with a much stronger sense of the language’s features than that. Similarly it’ll work well for those with a general sense of the major patterns but who could do with a refresher, maybe while transitioning from java or other “enterprisey” development to ruby.
While it won’t have the same general appeal of other titles in the series like The Ruby Way and The Rails Way, this is a handy volume in a series that is making strong contributions to the ruby book market.
Disclaimer: I was sent a copy of this book for review by the publisher. There were a few pages missing due to a printing defect so I wan’t able to read parts of chapters 13 or 14. You can find it at amazon US, amazon UK and all sorts of other places.
Book Review: The Definitive Guide to Django
Feb 22nd
Django is a framework I’ve long (in web years) held in some esteem, despite never having used it before the past few weeks. The framework’s creators’ many well reasoned contributions on all manner of debates about the web suggested a thoughtful approach, and the range of high quality sites powered by Django has kept growing, with the recent launch of EveryBlock being a prime example of its capabilities. So I was delighted to receive a copy of The Definitive Guide to django: Web Development Done Right for review.
Authored by two of the creators of Django: Adrian Holovaty and Jacob Kaplan-Moss, the book is carefully structured, initially placing django in context by exploring various approaches to web development, and then stepping through initial project creation, templates, models, url configuration, django’s famed admin interface, and so on. After eight chapters it changes tack and switches from basic tutorial to more in-depth exploration of areas like the ORM, session handling, caching and deployment. Several appendices provide supplementary material.
The first few chapters do a good job of laying out the foci of the framework’s architecture and it’s Model Template View (MTV) approach. Its pace is measured and while I wonder if it might be a little too much too soon for those totally new to full stack web frameworks, it would work well for those coming from a background building web apps with PHP, Java, or for those of us who are used to working with Rails. There are new techniques to learn and I found the book particularly useful for grasping the deeply pythonic approach, favouring flexibility over convention.
A clear example of that comes in the use of Context objects for passing values between Views and Templates. The authors initially show us the most verbose and rudimentary way to do it and gradually develop that to show how they’ve provided for various common cases. By going through those steps there’s a good chance the reader will be well equipped to work out ways to simplify their own workflow and/or create new subclasses to promote reuse in their code.
Where the book is lacking is in the examples. The introductory material, and much of the reference content is excellent, but as a newcomer to the framework I felt a little lost in how I should structure my code and how different components relate; it’s clear how models relate to the database, but how do I pass them around when building associations?
I recognise that django deliberately avoids the strong conventions of the Rails community (though even there you frequently find newcomers unsure where in the directory structure to place certain components) and there’s no need for lengthy tutorials on building a shop or how a magazine cms could work, but when I come to a book like this I’m looking for a guide to best practices at the project architecture level, not just the component level, and I was sorry not to find it. The authors clearly have a lot of experience of structuring django sites of all shapes and sizes and it would be good to learn more about how they keep those sites organised.
That said, this is a solid introduction to django for web developers; a solid contribution in a so-far underserved market and it’s likely to come in handy for a number of people. Just be prepared to supplement it with a fair amount of time in search engines working out good strategies for connecting the pieces.
Disclaimer: I was sent a copy of this book for review by the publisher. You can read it for free online or find it at apress, amazon US, amazon UK and all sorts of other places.
Book Review: Drupal 5 Themes
Feb 5th
Aimed at those with a knowledge of HTML and CSS but with no prior experience of programming, Drupal 5 Themes sets out to show you how you can quickly and easily get a drupal site up and running with a highly customised look and feel.
Drupal is highly themeable, with most aspects of the user interface being accessible purely in the theme layer without needing to dip into module development or the CMS’ core. The book takes the user through the various theme hooks and introduces the simple PHP code needed to override them, add new ‘regions’ (in which blocks can be displayed), customise existing themes and create your own (almost) from scratch. The primary focus is on the default theme engine, PHPTemplate, but others are referenced and a little time is spent on the options for building your own theme using raw PHP (without the extra layer of a theme engine).
For the most part the content is straightforward, and the reader should quickly get a feel for the naming conventions that drive the PHPTemplate approach. While not much programming knowledge is needed, it would be helpful for the reader to have a basic grasp of PHP and introductory programming constructs such as loops and conditionals. I was also surprised to find recommendations to name functions phptemplate_* within theme-specific template.php files, where they could instead be prefixed with the theme’s name rather than ‘phptemplate’. PHP’s not fond of functions that share names within the same context, and it is best to give those functions the most specific name available to you in order to avoid errors.
Given the fact that only HTML and CSS are listed as pre-requisites I was a little surprised that the PHP code wasn’t introduced in a more focussed section. Given its simplicity it’s to be hoped that anyone intending to spend much time building drupal sites would be able to figure it out, but while time is spent picking apart example code little time is spent actually giving a conceptual introduction or, for that matter, on explaining how to install drupal in the first place. Surprisingly, space was given to explaining how cascades work in CSS, which you would think is a fundamental part of a knowledge of CSS and unnecessary in this context.
This is the second book in a row that Packt has sent me for review where it has seemed that reference material is scattered too freely amongst the tutorial-style chapters. Significant chunks of space are given over to listing off functions, the locations of stylesheets, and so on, which is useful information but breaks up the flow of the book unhelpfully. It’s surprising that that content wasn’t moved to an appendix or, as with their jQuery books, a separate volume. Sitting in the middle of the book it feels like unnecessary filler (just one or two examples would do, along with a reference to an appendix, other volume, or online source) and the space could helpfully be given to more detailed tutorial material. That coupled with poor print quality and light paper stock (both also an issue with that previous book) gives the book a lightweight feel and reinforce its weaknesses.
This book should get an HTML/CSS developer who’s not afraid to dip their toes into some PHP up to speed with customising a drupal site, and its worth considering if you’ve been mostly building static sites or customising wordpress and need a content management system with a wider range of features. Unfortunately it’s still fairly weak structurally, and you may well find yourself needing to combine it with quite a bit of online documentation to properly cover the topics under discussion.
Disclaimer: I was sent a copy of this book for review by the publisher. You can find it at packt publishing, amazon US, amazon UK and all sorts of other places.
Book Review: Practical Ruby Projects
Jan 31st
The past few years have seen the English-language Ruby book market explode. Before the phenomenal success of Rails it was perfectly possible to own every available title (and not use much storage space), but now that would be quite a challenge and lead to considerable redundancy. Having worked my way through quite a few Rails books of late, reading Practical Ruby Projects—a Ruby book that doesn’t even mention web frameworks—was both a pleasant diversion and a highly illuminating experience.
Like the last volume I reviewed, this book is unabashedly aimed at experienced programmers. There’s a brief paragraph on “getting set up”, but no detailed guide to obtaining the tools. Instead we dive right in to a sequence of projects that includes: making music (dipping into calling C code from ruby), animation, simulation, building a strategy game (and adding a RubyCocoa frontend), genetic algorithms, and even implementing lisp and parsers. Once again the “apress roadmap,” a diagram intended to show how the skillsets in their different volumes build on one another, is misleading pitching this between “Beginning Ruby” and other volumes I’ve reviewed like Practical Ruby for System Administration and Pro Active Record. Don’t believe it. Though there’s little overlap in the material, this is a more advanced volume than either of those and readers should be prepared.
The pace of the book is measured and Topher Cyll does a good job of gradually building up the projects a step at a time. Along the way a variety of practices are demonstrated with many methods stubbed out for demonstration purposes before being filled in when they are needed, and considerable time spent on decoupling code. That latter piece is particularly in evidence in the chapters on building a turn-based strategy game and then developing a RubyCocoa front-end. Despite careful design early on further refactoring is needed to make it easy to apply the front-end and that process is carefully worked through.
Most of the book makes some use of existing libraries. The initial lisp chapter uses the sexp library and the subsequent section on writing a parse relies on rparsec. For the most part, however, use of the libraries is kept to a minimum, allowing for fairly self-contained code. Unit testing is largely ignored until the last chapter, where the need for tests when constructing a grammar/parser is explained and a test-first development model is encouraged. That works well to demonstrate the power of tests for complex (and often brittle) code.
This is not a book designed for public transport reading. Working through chapters on the bus I frequently found myself wanting to reach for my laptop to get a better grasp of how a piece of code worked. While the explanation is generally very good, with material of this complexity there is nothing like running the code and tweaking it to make sure you’ve understood exactly what each transformation does. It’s a book to take your time over, so be prepared!
A few editorial errors have crept in, suggesting a re-organisation of the contents late in the day. In particular an early reference to s-expressions seemed to presume that the lisp and/or parsing chapters were featured early. That’s not a big deal and will hopefully be corrected in later printings; the author does encourage skipping around within the book, but there is value in working through it roughly in order, and not just for the two “paired” chapters that explicitly build on one another.
Perhaps the most striking thing about this book is the reminder that even for those of us whose primary programming activity is web development, studying other areas can be extremely helpful. Not only is it helpful to see how other developers structure their code, but tools like genetic algorithms and parsers are likely to be very helpful where web applications require sophisticated processing and/or backend systems. And it never hurts to learn a little lisp. For the ruby developer who’s comfortable with the language and wants to stretch out a little, this book would be an excellent investment.
Disclaimer: I was sent a copy of this book for review by the publisher. You can find it at apress, amazon US, amazon UK and all sorts of other places. Pat Eyler’s review can be found here.
Book Review: Pro Javascript Design Patterns
Jan 20th
According to wikipedia:
In software engineering, a design pattern is a general repeatable solution to a commonly occurring problem in software design. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations. Object-oriented design patterns typically show relationships and interactions between classes or objects, without specifying the final application classes or objects that are involved. Algorithms are not thought of as design patterns, since they solve computational problems rather than design problems.
Design patterns, and particularly their application in dynamic languages can be a controversial topic, and every now and again another round of blog posts bubbles up appalled at the way a new group of programmers have become infatuated with design patterns. Applied without care design patterns can quickly lead to over-engineered code that seems designed as much to draw on as many of the established patterns as possible as to solve the intended problem. But if applied with care, and with consideration of how a pattern applies in the context of your chosen language they can be a helpful way to draw on the wisdom of the coders that came before you, and make your code easier to understand to those who may inherit it.
Written by Dustin Diaz (of Google) and Ross Harmes (of Yahoo), Pro Javascript Design Patterns builds on experience of building complex, high profile javascript applications. That experience shows as each pattern is introduced with solid examples and sample code and then refined to provide looser-coupling, more flexibility and/or better performance.
Early on in the book I was concerned that some of the solutions could become too heavy and the early introduction of interfaces hinted at something akin to the early approaches to pattern usage in PHP, which often looked more like an attempt to turn PHP into Java than a way to use PHP’s own features better. As the book goes on the usefulness of those interfaces, particularly for large development teams, becomes clear and most of those concerns are allayed, especially as the authors offer pros and cons for the use of each pattern and are clearly focussed on how these patterns can help produce more robust solutions.
Most of the patterns will have a fairly immediate impact for developers new to them, and even for those who have used them in other contexts it is helpful to see how they have been applied in JavaScript. Most modern JavaScript libraries rely on several of these patterns to abstract out handling of different browser quirks or adding new event types, and even if you rely heavily on one or more of the major libraries this guide may well help you understand their internals better.
I’ve sometimes been skeptical about books claiming to be targeted at an advanced target. Labels like “pro” are often handed out far too easily. But in this case it seems deserved. While the book does a good job of quickly introducing approaches to object-oriented programming in JavaScript, that’s based on an assumption of a solid knowledge of the language and of OO development in at least one language. If you’re a newcomer to JavaScript or just looking for a way to add a few fancy features to your web pages this isn’t be book for you. But if you have some serious JavaScript development experience and are needing a way to tighten up your code to make it more modular and more maintainable, this book is well worth your time.
Disclaimer: I was sent a copy of this book for review by the publisher. You can find it at apress, amazon US, amazon UK and all sorts of other places.