This is the second Olsen’s book about Ruby. In 2007 he published Design Patterns in Ruby, an other great example of how common programming practices like Design Patterns apply to the Ruby world.

Eloquent Ruby is a very lightweight and pleasant reading. The colloquial tone is friendly and engrossing. The books has plenty of code snippets and it requires only a few days to read it from start to end.

Be prepared, this is an unconventional Ruby book. To use author’s words

This is a book about making that final leap, about absorbing the Ruby programming culture, about becoming truly fluent in Ruby.

This is something I have been claiming for the last 5 years. Learning Ruby is not difficult, start thinking in Ruby and becoming a Rubyist is the real challenge.

A formal understanding of the mechanics of Ruby isn’t the same as really looking at the programming world through Ruby-colored glasses. You need to absorb the cultural part of Ruby, to see how real Rubyist use the language to solve problems.

This is one of the reasons that convinced me to create the Rubyist.

Structure

The book is divided into 4 parts:

1. The Basics
2. Classes, Modules, and Blocks
3. Metaprogramming
4. Pulling It All Together

Each part is divided into chapters. The book counts 31 chapters and about 400 pages.

The first part covers some basic Ruby features in a way you normally won’t read in any other Ruby reference. Ah, if I only had the Symbol chapter available when I started learning Ruby!

The second part covers Classes, Modules and Blocks and it explains how to use modules successfully, how to deal with inheritance, equality and operators. This is by far my most favorite section.

The third part is about Metaprogramming. Whilst the name of the section is technically correct, it can be misleading. If you are looking for a complete Ruby and Metaprogramming course, check out Metaprogramming Ruby (US | UK). This section covers common Ruby metaprogramming topic such as hooks, method_missing (a must read!) and monkey patching.

The forth part wraps several topics all together and talks about creating and implementing a DSL in Ruby.

The book ends with a rich list of books about Ruby and programming in general. The list contains amazing Ruby titles like Ruby Best Practices (US | UK) or The Ruby Way Second Edition (US | UK), as well programming masterpieces like The Elements of Programming Style (US | UK). If you are looking for some inspiration about your next reading, you might probably find some there.

Chapters

1. Write Code That Looks Like Ruby
2. Choose the Right Control Structure
3. Take Advantage of Ruby’s Smart Collections
4. Take Advantage of Ruby’s Smart Strings
5. Find The Right String With Regular Expressions
6. Use Symbols to Stand for Something
7. Treat Everything Like an Object – Because Everything Is
8. Embrace Dynamic Typing
9. Write Specs!
10. Construct Your Classes from Short, Focused Methods
11. Define Operators Respectfully
12. Create Classes That Understand Equality
13. Get The Behavior You Need with Singleton and Class Methods
14. Use Class Instance Variables
15. Use Modules as Name spaces
16. Use Modules as Mixins
17. Use Blocks to Iterate
18. Execute Around with a Block
19. Save Blocks to Execute Later
20. Use Hooks to Keep Your Program Informed
21. Use method_missing for Flexible Error Handling
22. Use method_missing for Delegation
23. Use method_missing to Build Flexible APIs
24. Update Existing Classes with Monkey Patching
25. Create Self-Modifying Classes
26. Create Classes That Modify Their Subclasses
27. Invent Internal DSLs
28. Build External DSLs for Flexible Syntax
29. Package Your Programs as Gems
30. Know Your Ruby Implementation
31. Keep An Open Mind to Go With Those Open Classes

Requirements

This book assumes that you have a basic knowledge of the Ruby language. You don’t need to be a Ruby master, but some advanced sections such as Metaprogramming and DSL may require you to stop for a moment and refresh or improve your specific knowledge of Ruby on that topic.

Don’t expect this book to explain you the basic details of Ruby or its syntax, this is behind the scope of this publication. There are plenty of commented examples, but if you want to learn about a specific Ruby feature make sure you keep a reference like Programming Ruby (US | UK) or The Ruby Way (US | UK) handy.

Another requirement is that you must be ready to read printed source code: this book is full or Ruby code. At least the 50% of the pages contain code, making this book a valuable practical reference.

Plus

Aside from being an excellent resource to help you thinking Ruby and programming in the Ruby way, this book constantly adopts a practical approach providing tons of examples to read. Every chapter ends with an In the Wild section containing examples extracted from real Ruby libraries, and a Wrapping up section that helps you to fix the concepts in mind.

As as long time Ruby developer I really loved the Use Symbols to Stand for Something, object and block chapters. Some of them didn’t necessary teach anything new, but the way used to present the concepts was very helpful and understandable.

I appreciate the focus on tests and the RSpec chapter. The most part of Ruby books dedicate a specific section about tests, then seem to forget them for the rest of the chapters. This is not the case of this book, where several examples are verified by tests.

Finally, the simple colloquial tone makes the book really friendly. It seems like a person you always worked with is now teaching you programming and thinking in the Ruby way.

Minus

It’s really hard to find some real negative in this book.

I found the Regular Expression chapter pretty boring and misplaced. In fact, it was the only chapter in the book where the main focus was teaching Regular Expression basics, instead of focusing on using Regular Expressions in the right way.

The same applies to the RubyGems sections. There have been several changes in the Gems community in the last years and the chapter appears to be slightly outdated. Again, I would have left this topic outside the book.

Finally, I would have appreciated a wider usage of Ruby 1.9 over 1.8 in order to discourage the adoption of Ruby 1.8.

In Conclusion

If you are a beginner to intermediate level Ruby programmer, this book is a must read that it’s likely to help you improving your Ruby skill and writing code in the Ruby way.

If you are completely new to Ruby, personally don’t recommend this book as a first reading. You might want to start with a Ruby reference to learn how programming in Ruby, then read Eloquent Ruby to learn how programming in the Ruby way. Also, don’t forget about the Rubyist, you’ll find several Ruby common practices and coding conventions.

If you are a Ruby expert and you have been writing Ruby for the last 5 years, don’t be too self-confident. I’m quite sure the book will be able to provide you some valuable advice more than once.

Where to Find Eloquent Ruby

You can get a printed or Kindle copy at Amazon.com, Amazon.co.uk, or at your other favorite book seller.

Kindle Preview

Related posts

1. Design Patterns in Ruby Book Review
2. Learning jQuery 1.3 Book Review
3. Getting Real Book Review

Mark is the author of several other publications including Dive Into Accessibility, Dive into Python, Dive Into Greasemonkey. Not surprisingly, his site is called Dive Into Mark.

But hey. Why isn’t this book called Dive Into HTML 5? I’m glad you asked. Actually, this appears to be the original title. The book is entirely available for free on the web at the Dive Into HTML 5 website. Honestly, I don’t know the reason why the title was changed for the printed version.

HTML5 Up and Running provides a practical overview of the new features already available in HTML 5. HTML 5 is not a standard (yet), but browsers such as Safari, Firefox, Opera and Chrome already support many if its feature.

One of the first things you’ll learn reading this book, is that HTML 5 is not one big thing. Here’s what Mark said in the introduction.

You may well ask: “How can I start using HTML5 if older browsers don’t support it?” But the question itself is misleading. HTML5 is not one big thing; it is a collection of individual features. So you can’t detect “HTML5 support,” because that doesn’t make any sense. But you can detect support for individual features, like canvas, video, or geolocation.

HTML 5 is closer than you think.

For example, by reading this book you will learn that the iPhone and the iPad already support the new HTML 5 input features and attempt to adapt the keyboard layout according to the input type.

An email input type, like this following one

on the iPhone and iPad will trigger the email-keyboard that contains a smaller-than-usual space bar, plus dedicated keys for the @ and . characters.

Isn’t this amazing?

Structure

HTML5 Up and Running is divided into an introduction, 11 chapters, and 2 appendix.

Here’s the table of content:

• Introduction: Five Things You Should Know About HTML
• A Quite Biased History of HTML5
• Detecting HTML5 Features: It’s Elementary, My Dear Watson
• What Does It All Mean?
• Let’s Call It a Draw(ing Surface)
• Video in a Flash (Without That Other Thing)
• You Are Here (And So Is Everybody Else)
• A Place To Put Your Stuff
• Let’s Take This Offline
• A Form of Madness
• “Distributed”, “Extensibility”, And Other Fancy Words
• Manipulating History for Fun & Profit
• The All-In-One Almost-Alphabetical No-Bullshit Guide to Detecting Everything
• HTML5 Peeks, Pokes and Pointers

The book is very easy to read. It contains tons of examples, a very simple tone and several references. However, previous programming experience is recommended, especially if you plan to use advanced JavaScript-oriented features.

Examples, Examples and Examples

As I already mentioned, the book is full of contextual hints and examples. This is really cool because examples help you to remember an information.

You don’t need to trust me, you can check with your own eyes. Go for example to the Canvas chapter and see how well it is explained. I honestly can’t imagine a better way to do this.

This is not a book to learn HTML

Remember, even if HTML5 Up and Running is easy to read and full of examples, it isn’t the right book to start learning HTML. This book assumes you already know about HTML, CSS and JavaScript.

Nevertheless, the How did we get there chapter is one of the best article I ever read about the history of HTML.

And if you happened to migrate all your websites to XHTML (like the 90% of developers did) in the last 5 years, you might probably want to read the everything you know about xhtml is wrong paragraph — *sigh*.

Remember, JavaScript is the future

Since I mentioned JavaScript, let me take the time to highlight a very important concept: JavaScript is the future.

It doesn’t matter if you are developing a mobile web site, an iPad product, a Rails application, an interactive HTML 5 interface. JavaScript is the future.

JavaScript stands to development like parsley stands to kitchen. You find it almost everywhere. Think about jQuery Mobile, Sencha Touch, unobtrusive Rails 3 helpers, Cappucino, HTML 5 Modernizr library, etc. these are just a few examples of how JavaScript is evolving and entering our life.

If you are a developer or designer, you can’t continue to ignore JavaScript. And JavaScript appears to be even more important in HTML 5 because several features are designed to work with JavaScript. I’m talking about Geo Localization, Canvas and Local Storage, just to name a few.

So do yourself a favor: take the time to start learning and experimenting with JavaScript.

In conclusion

I enjoyed this book. I appreciated the HTML 5 introduction, the history of HTML and the tutorial about detecting HTML 5 features. But the chapter I enjoyed the most is the one about the new HTML 5 form inputs, probably because I have been able to start experimenting with them immediately.

Where to Find HTML 5 Up and Running

You can get a printed or Kindle copy at Amazon.com, Amazon.co.uk, or at your other favorite book seller.

Related posts

1. Learning jQuery 1.3 Book Review
2. Design Patterns in Ruby Book Review
3. Eloquent Ruby Book Review

Getting Real was published in 2006 but if you start reading it today, you will probably find it more relevant than several other programming and development books written in the last two months. This is because Getting Real is not about a language or technology. It isn’t about the latest cutting-edge development framework. Getting Real describes a way of thinking, describes an effective approach ideally suited to develop web based software.

To describe the book with the authors’ words

Getting Real is about skipping all the stuff that represents real and actually building the real things.

Getting Real is less. Less mass, less software, less of everything that’s not essential.

Getting Real is about iterations and lowering the cost of change.

Structure

The book is organized in 16 chapters, each one containing several essays.

Here’s the table of content:

1. Introduction
2. The Starting Line
3. Stay Lean
4. Priorities
5. Feature Selection
6. Process
7. The Organization
8. Staffing
9. Interface Design
10. Code
11. Words
12. Pricing and Signup
13. Promotion
14. Support
15. Post-Launch
16. Conclusion

If you want to get a preview of the content or read it online, the complete book is available online for free.

Essays

An essay is usually no more than 2 pages long. The essay size is one of the best aspects of the book. Keeping essays short actually make it possible to read them very quickly. You can easily schedule your reading. Do you have only 15 minutes available? Open the book, pick the next essay and changes are you will finish it in 10 minutes.

Short chapters help you to stay focused on the content. When it takes 30 minutes or longer to read a chapter, you might lose the concentration. How many times in the middle of a chapter and did you realize you didn’t remember what was written at the beginning of it?

Essays contain ideas, suggestions and examples to help you Getting Real. The book focus is on building software and web applications, but reading the book you will immediately realize that several topics are applicable to non-software activities too.

As the authors say, this book doesn’t have to be an all or nothing proposition. Even if you can’t embrace Getting Real fully, there are bound to be at least a few ideas in here you can sneak past the powers that be.

Who should read this book?

So, is Getting Real for you? For me, Getting Real is one of the best books I ever read about development methodologies since a long time. When I was reading the book, I had the same awesome feeling I first noticed when I read The Pragmatic Programmers book.

As an entrepreneur and the co-founder of RoboDomain, Getting Real has been a valuable resource. I discovered that several techniques and processes we applied to RoboDomain are proven to be successful and there’s still plenty of new things to be done to improve ourself and our product.

Getting Real is not the kind of book you can read and say “from tomorrow we have to start following all these guidelines”. You need to be ready to acknowledge the ideas it contains.

If you ever developed a web application or if you’re going to develop one. If you are an entrepreneur, designer or programmer. If concepts like versioning, agile development, iterations, continuous integration, testing and customer satisfaction mean something for you, then you will probably appreciate Getting Real.

And if you love meetings, spend several time writing specs, work several months before having a working version of your product, Getting Real might be a good book for, you provided that you read it by trying to understand why a specific approach has proven to be successful, rather than assuming this is just hot air.

In conclusion

As you might understand, I really enjoyed this book and I strongly recommend it.

I want to close this book review by quoting a couple of sentences that, in my opinion, better represent Getting Real.

Don’t be a yes-man

Each time you say yes to a feature, you’re adopting a child. You have to take your baby through a whole chain of events (e.g. design, implementation, testing, etc.). And once that feature’s out there, you’re stuck with it. Just try to take a released feature away from customers and see how pissed off they get.

Pay off your code and design “bills”

We usually think of debt in terms of money but it comes in other forms too. You can easily build up code and design debt. Hack together some bad code that’s functional but still a bit hairy and you’re building up debt.

The same way you should regularly put aside some of your income for taxes, regularly put aside some time to pay off your code and design debt. If you don’t, you’ll just be paying interest (fixing hacks) instead of paying down the principal (and moving forward).

Where to Find Getting Real

You can get a printed copy at Amazon.com, Amazon.co.uk, or at your other favorite book seller. The complete book is also available online for free.

Related posts

1. Design Patterns in Ruby Book Review
2. Learning jQuery 1.3 Book Review
3. Eloquent Ruby Book Review

Learning jQuery 1.3 (US | UK) is one of the most famous books about jQuery, the popular JavaScript framework. It’s written by Karl Swedberg & Jonathan Chaffer and published by Packt.

Structure

The book is implicitly divided into tree parts:

• The first part, from chapter 1 to 6, provides an introduction to the framework. You’ll learn the philosophy behind jQuery, how to use it and how jQuery can help you to write more powerful user interactions.
• The second part, from chapter 7 to 9, contains several real-world examples, pulling together what you’ve learned in the previous part. Most of the examples are actually overtaken by existing jQuery plugins, however creating something from scratch it’s an important training and it forces you to have your finger in the pie.
• The third part, from chapter 10 to 11, shows you how to extend the jQuery core library using existing plugins or creating and packaging your own extensions.

Requirements

You don’t have to be a JavaScript master to read this book, though some JavaScript skills might be helpful. Moreover, a basic programming knowledge can help you to better understand the examples.

If you want to leverage your JavaScript skills, jump to Appendix C. It offers a really interesting overview about Closures: what they are and how you can use them to your advantage.
Reading this section before the other chapters can make the difference later, when you’ll have to understand the usage of anonymous functions and callbacks in the examples throughout the book.

Quite obviously, you need a good HTML and CSS knowledge.

If you are looking for a JavaScript reference, this isn’t the book for you. Remember, this book covers the jQuery JavaScript framework, not the JavaScript language.

Plus

One of the aspects of the book I appreciate the most is the number of examples. You don’t have to wait more than ten pages to see the first example of a HTML page enriched by a jQuery effect. Examples are clear, effective and they never overshadow the narration.

Also, this book is not merely a learn-by-example publication. The authors never delegate to the example the role of teaching you how to learn jQuery but they always use them in support of the theoretical explanation. For me, this is a really important point. The risk of learn-by-example books is that, at the end, you are just able to reproduce what the examples show you without having a global mastery of the argument.

Two other important concepts I learned reading this book are graceful degradation and progressive enhancement. I must admin I didn’t care too much about them before reading the book.
The authors remarked these concepts multiple times throughout the book underlining the importance of using JavaScript and jQuery to improve interaction and usability ensuring that a page will render as accurately, even if not as beautifully, with JavaScript disabled as it does with JavaScript turned on.

Minus

The book does a good job to introduce jQuery and its most important features. However, I would have dedicated more pages to plugins.

Plugins are one of the reasons of the success of jQuery. The books dedicates two chapters to plugins: the first on using plugins and the second on developing plugins. Whilst the list of jQuery plugins continue to grow up and it’s impossible to keep a book up-to-date with it, I would have appreciated a more deep overview about authoring a plugin.

Something like plugin best practices, suggestions and why not, plugin development patterns.

In conclusion

If you are an user interface designer or interaction designer, the first part teaches you how to alter the structure of an HTML document attaching or moving page elements, fire off behaviors responding to user events and interact with server-side functionalities.

If you are a programmer, the third part offers some precious suggestions to package your scripts making your code more reusable and maintainable.

Regardless your activity, if you are looking for a book to better understand how jQuery works, Learning jQuery is definitely a recommended reading. Someone can argue that online you can easily find tons of articles and discussions about jQuery that make a book quite useless. In my opinion, this is exactly the reason why a book can make the difference. When reading a book, you find all the information you need concentrated in a single source, organized into a logical learning flow and you don’t need to waste your time searching for information, verifying blog credibility or discarding outdated solutions. A good book if often the preferred starting point if you want to learn a new technology in the minimum amount of time.

Where to Find Learning jQuery

You can get a printed copy at Amazon.com, Amazon.co.uk, or at your other favorite book seller.

Related posts

1. HTML 5 Up and Running Book Review
2. Design Patterns in Ruby Book Review
3. Eloquent Ruby Book Review

Compared to my last readings, this publication was decisively less time consuming. I finished the book in no more than a week, dedicating an hour a day in tram. On condition that you have a certain familiarity with Ruby and Object Oriented Programming, Design Patterns in Ruby is a quick and involving reading.

Structure

The book is divided in three parts.

The first part, Patterns and Ruby, is a quick introduction to the design patterns and the Ruby programming language. As I said before, you should not rely too much on the second chapter. A single section is not enough to demonstrate the power of the Ruby language.

The second part, Patterns in Ruby, is the heart of the book. Each chapter covers one of the different patterns originally discussed by the GoF, providing a brief introduction, practical examples of the Ruby implementation and a few real world examples, inspired by famous Ruby libraries such as Rails and URI. At the end of each chapter, a summarizing paragraph wraps up the most important Design Pattern elements.

The third part, Pattern for Ruby, takes into consideration three patterns not included in the original book but emerged with the introduction and the development of the Ruby language.

Design Pattern discussed

This is the list of all design patterns discussed in the book:

• Template
• Strategy
• Observer
• Composite
• Iterator
• Commands
• Adapter
• Proxy
• Decorator
• Singleton
• Factory
• Builder
• Interpreter

These are the Ruby-oriented patterns covered in the third chapter:

• Domain-Specific Language (DSL)
• Meta-Programming
• Convention Over Configuration

Requirements

As stated in the preface of the author, in order to read this book you don’t need to hold any particular competence either in Ruby or Design Pattern. Even so, you should have a certain familiarity with the dynamics of the object oriented programming. I confess to finding myself partially disagreeing. Tackling the reading in this book without a certain amount of knowledge of Ruby could prove itself as counter-productive, considering that some design patterns use characteristics like meta-programming, reflection, modules, symbols, Mixins, blocks, and procedures. While the previous can be considered common aspects in many languages, starting from symbols onwards, you find yourself entering in the Ruby world.

The second chapter of the book offers a brief introduction to Ruby, but these 30 minutes of reading are nothing compared with the experience you can learn with a day-by-day programming or a Ruby book such as the excellent Learn to Program or Programming Ruby, one of the most complete Ruby references.

You don’t need any specific Design Pattern knowledge in order to appreciate this book. I agree with the author in this case. It covers all Design Patterns from theory to the practical implementation providing you with a full overview of the subject.

In conclusion

Once more, the Addison-Wesley and the Professional Ruby Series completely met my expectations. I strongly suggest the book Design Patterns in Ruby (US | UK) to all those programmers who wish to improve their Ruby development knowledge and leverage their skills to an even more professional level. Design Patterns are an advanced and professional solution to the most common software development problems and should be part of every professional developer.

Russ Olsen had the ability to write an easily readable publication, without compromising the quality of the book. Each chapter is self-contained and they can be read in no specific order. If I must find a dislike, then I would say the price could be lower, compared to the average price of similar books. But you know, quality has its price.

Where to Find Design Patterns in Ruby

You can get a printed or Kindle copy at Amazon.com, Amazon.co.uk, or at your other favorite book seller.

Kindle Preview

Related posts

1. Eloquent Ruby Book Review
2. Learning jQuery 1.3 Book Review
3. Getting Real Book Review