Book Review: Beginning Ruby: From Novice to Professional

I think Beginning Ruby: From Novice to Professional is a better first Ruby book than the venerable Pickaxe.

The previous statement is almost heresy in the Ruby community. Don’t get me wrong, you should own the Pickaxe. It’s a great book and certainly lives up to it’s description as “the definitive reference to Ruby”. However it’s much more of a reference book than an introduction to the language. And it’s huge - 864 pages. This is not a book you can just throw in your bag and carry around with you. It’s a book you would keep at your desk perhaps, dog-eared and coffee stained. In this role, it is ideal. As an introduction to the language, however, it leaves something to be desired.

Beginning Ruby, on the other hand, is an excellent (and I would argue more approachable) introduction to the Ruby language, written by one of it’s more notable users. Peter Cooper is well known, in both the Ruby and Rails community. He runs the Ruby-centered blog Ruby Inside, and has developed a number of applications in Rails, including the Snippets code repository, which was subsequently sold to DZone. Peter also has done a fair amount of writing over the years for a variety of sites.

The book is broken up into three primary sections, plus a handful of appendices:

  • Part 1: Foundations and Scaffolding - This is an introduction to the Ruby language. Starting with installation, and going through the basic structure of the language and it’s elements: strings, containers, and the like. There is a chapter on building basic Ruby programs that puts all of these concepts together. One nice bonus was a chapter on the Ruby ecosystem, which covers the various websites, irc channels, and other resources for Ruby developers.
  • Part 2: The Core of Ruby - This section covers the meat and potatoes of Ruby. It covers classes, modules, libraries, debugging and testing, databases, and advanced features. This is all tied together with a nice example application that implements a text-parsing bot. I liked that this application included unit tests, but it would have been nice if the testing was done test-first. This is a personal preference, but I think it’s a best practice and would like to see it demonstrated more in books like this.

  • Part 3: Ruby Online - As you would expect, this section includes some coverage on Rails. Its not exhaustive, and isn’t intended to replace a full-blown book on Rails. It does offer a thorough overview though. That’s not the sole focus of this section, however. Ample coverage is given to FTP, HTTP, and email, as well as raw TCP sockets and other networking type things. There is also a good chapter in here called “Useful Ruby Libraries and Gems”. The chapter itself is a bit misplaced as it has very little to do with the internet, but it is a very useful overview of a lot of the third party gems that you can install. I found myself using this section regularly on a recent project.

In addition to these sections, there are three appendices. The third appendix, called “Useful Resources” contains pointers to a lot of online resources which would likely be unknown to someone new to Ruby. I didn’t find much in there I hadn’t seen already, but I’ve been using Ruby for a little while. The first two appendices are a primer and reference for Ruby. These are both very good, and would be useful as references for a new developer (or someone who doesn’t have the entire ruby syntax committed to memory yet, like me).

Weighing in at over 600 pages, this is a comprehensive book. At the same time, it’s quite a bit smaller than the Pickaxe, which makes it much more portable (there’s also a PDF version available for $10 if you’ve purchased the dead-tree edition, for the ultimate in portability).

As with the last book I reviewed, this one appears to have been well technical reviewed. I didn’t notice any errors. I also enjoyed Peter’s writing style, which is concise but not dry.

In summary, if you want to learn Ruby, Beginning Ruby: From Novice to Professional is the book to buy.

Disclaimer: I received a free copy of this book from the publisher in exchange for a review. There were no conditions other than that, but in the interest of full disclosure, now you know.

Book Review: Practical Rails Social Networking Sites

Summary

Rails Social Networking Sites walks you through the process of building a Web 2.0 social networking site (something like MySpace), called Rails Coders that includes the features you would expect in that sort of site:

  • User signup and management (based on restful_authentication)
  • Content management
  • Blogging (with web services)
  • Markup languages like Textile and Liquid
  • Mashups using Google Maps and Flickr
  • photo management (attachment_fu and RMagick)
  • Tagging

This book is not, of course, about building social networking sites, though that does serve as the exercise in the book. It’s about going beyond the basics with Ruby on Rails, and building something useful.

Rails Social Networking Sites is targeted at developers who have some experience with developing Rails applications. That said, you don’t need much. If you have read one of the other books on Rails or developed a couple of play applications, you’ll be fine.

Pros

There’s a lot to like about this book. It’s well written, and covers a broad range of useful topics. Here’s the things I really liked:

  • It covers useful topics in the context of a real-world application. Most of the Rails books out there (at least the ones I own or have looked through) cover the basics of Rails, and maybe a few additional plugins. Anyone building a real-world application will need to scour the internet for help with the other plugins available to do things like handle file uploads, user authentication, and the like. While this book doesn’t cover everything you could possible want to do, it covers a lot.

  • There is a very big emphasis on testing. It’s not TDD (see my note in the cons below), but in every chapter you will be shown how to build something, and then how to test what you built.

  • It’s current. The application is built in a RESTful style, and there is frequent mention of the changes/deprecations coming in the Rails 2.0 release.

Cons

There’s really very little wrong with this book. It appears to have been technical reviewed thoroughly, and as a result I didn’t find any glaring technical errors. That said, there are a few things about the book that I took some issue with:

  • The book frequently references blog posts as resources. This seems like a bad practice to me, as these urls tend to have a short lifespan. It’s very likely that many of these urls will be dead links within a year or so. To be fair, this is a book covering a rapidly moving technology, and it’s likely to be largely out of date in 18-24 months. Therefore, this may not be much of an issue. Still, it might be a better idea to link to the book’s website instead.

  • While the book does give ample coverage to testing (more than most books), it would have been nice if the testing was done Test First, rather than bolted on after the fact.

All in all, these are really minor points.

Conclusion

Overall, I really liked this book, and I believe it will be very useful to anyone developing with Ruby on Rails. Whether you’re on your first application or you’ve been developing for a while, you will find useful information in Rails Social Networking Sites.

Disclaimer: I received a free copy of this book from the publisher in exchange for a review. There were no conditions other than that, but in the interest of full disclosure, now you know.

What I've Been Reading

Never Eat Alone: And Other Secrets to Success, One Relationship at a Time by Keith Ferrazzi and Tahl Raz

:http://www.amazon.com/gp/product/0385512058?ie=UTF8&tag=approachingno-20&linkCode=as2&camp=1789&creative=9325&creativeASIN=0385512058

Geeks are, generally speaking, much better with technology than people - I’m no different. But the fact is your ability to build and maintain relationships with other people will take you farther in life than any technical skill you can acquire. For a lot of people, myself included, these are just not skills that come naturally. Fortunately for us, this book was written. Never Eat Alone does a very good job of explaining the hows and whys of developing and maintaining relationships over the long term. The book is a quick read, but explains very well some important concepts of “networking” (I term I don’t care much for, but that’s neither here nor there). Mr. Ferrazzi discusses why it’s important to build a network of associates, and then immediately delves into the the how. He also explains how to leverage your network when you need to, like looking for that new job, or when you need the help of a friend of a friend of a friend to close a big deal. This book is written in a casual style, and is peppered with real-world examples of what works and what doesn’t. If developing and maintaining relationships with people is not something that comes naturally to you, then you need to read Never Eat Alone

Developing The Leader Within You by John C. Maxwell

:http://www.amazon.com/gp/product/0785281126?ie=UTF8&tag=approachingno-20&linkCode=as2&camp=1789&creative=9325&creativeASIN=0785281126

John Maxwell is one of the best authors on the topic of leadership. Developing The Leader Within You is easily the best book I’ve read on leadership. Mr. Maxwell covers how to develop influence with people, creating positive change, problem solving, and developing people - among other things. If you were to only read one book on the subject of leadership, this is the one I would recommend. Developing The Leader Within You covers the fundamentals of leadership, does it well, and does it in an easy to read manner. If you are (or aspire to be) a leader, you need to read this book.

Founders at Work: Stories of Startups’ Early Days by Jessica Livingston

:http://www.amazon.com/gp/product/1590597141/104-3429296-6459107?ie=UTF8&tag=approachingno-20&linkCode=xm2&camp=1789&creativeASIN=1590597141

This book is, very simply, a collection of interviews with the founders of successfull internet companies, such as del.icio.us, 37Signals, Craigslist, Flickr, and more. As such, it’s easy to read this book in small chunks - most interviews are only 3-4 pages long. It was written by Sarah Livingston, who is one of the founding partners at Y-Combinator, best known as “that VC firm Paul Graham runs” (Paul is one of the interviews in this book, naturally).

I really enjoyed reading this book. It gives a rarely-seen perspective on what it’s like in the early days of a startup. If you’re interested in starting a startup of your own (or even joining one), buy this book - it’s always better to learn from other people’s mistakes.

Note: The links to Amazon are affiliate links. If you buy a book, or anything else (need a copy of OS X - Leopard or a MacBook Pro to run it on?), I get a small commission. You too, can help feed my book addiction :)

What I'm Reading

I tend to read a lot. I’m one of those people who has four or five books in various states of being read at all times. I’m always interested in what other people are reading, so I thought I’d share the books that I’m currently reading, or have just finished:

Practices of an Agile Developer - I’m about 12 way done with this one. I like it so far, but I’ve liked every book from the Pragmatics that I’ve read. This is a great introduction to what Agile development looks like from the perspective of a developer, rather than a manager. Even if you’re not doing Agile development, it’s a great book on the foundations of being a great programmer.

The Tipping Point - I swear I’m probably the last person to read this. Great read, and definitely an interesting concept.

Pragmatic Version Control Using Subversion - I use Subversion on a daily basis, but this has helped with some of the advanced features.

Developing the Leader Within You - John Maxwell is my favorite author on leadership. I’ve read several of his books, and I’ve found every one very usefull.

CSS Mastery: Advanced Web Standards Solutions - CSS isn’t my strong suit, so this book has helped quite a bit. It’s not a CSS 101 book, it’s for taking your use of CSS to the next level.

Yes, those are affiliate links. Help feed my addiction.

What books are you reading? Leave a comment and let me know what’s on your reading list.

Book Review - Ship It!

Ship It! By Jared Richardson and William Gwaltney Jr.

Introduction

Ship It! is a book about basics. It’s an education in the fundamental practices that are needed to develop software successfully. This is the stuff they don’t teach you in college. Ship It doesn’t espouse a particular methodology (such as Scrum or XP). Rather, it is a set of practices. The advantage of this is that you don’t have to adopt everything in an all-or-nothing fashin. In fact the authors state explicitly that you should use the things that work and don’t use the things that don’t work. This will work particularly well in situations where someone works in an environment that has an entrenched methodology. While management might not be willing to buy off on a wholesale switch to a different methodology, many of the practices outlined in this book don’t require you to spend any money. Therefore, individual developers, leads, or managers can implement a couple of practices (say “The List”, and daily meetings) without needing management approval.

Let me start off by saying that I’m a huge fan of the Pragmatic Programmers. The original book completely changed the way I approached programming. I’ve bought several books from them since then, and have been extremely happy with them all. This is rare. Even O’Reilly has a few stinkers amongst all of their great books. The point is, I started reading this book with high expectations.

The book is divided into four basic sections:

  1. Tools and Infrastructure
  2. Pragmatic Project Techniques
  3. Tracer Bullet Development
  4. Common Problems and How to Solve Them

The first section, Tools and Infrastructure, covers the basics of software development tools. It not only covers what you need, but how you should use it. The tools covered here include source control (with an emphasis on Subversion), build scripts (using tools like Ant and NAnt), continuous integration, defect and feature tracking, and more. The book obviously can’t go into each tool in great depth, but there is enough there for you to get a good understanding of why you would want to use these tools.

The section on Pragmatic Project Techniques is equally interesting. As I said before, Jared and William don’t advocate any particular methodology, but have acquired a collection of practices over their years of software development that work. That said, there’s a fair amount of overlap with traditional agile methods. It covers techniques such as daily meetings (aka Daily Standups in XP), a shared list of work referred to as “The List”, among others. I would imagine that this section of the book would be the most useful to the majority of people reading this book. Geeks tend to focus on tools (section 1), but often ignore the processes that make a project successfull (or not).

Tracer Bullet Development was covered in the original Pragmatic Programmers book, though this book covers it in much greater depth. It’s very useful in situations where the client doesn’t fully know what he/she wants. You essentially build a prototype, and use it to draw out the requirements from your customer. It’s more involved than that (it warranted its own section in the book), you’ll need to read the book to gain a full understanding.

Common Problems and How to Solve Them was probably my favorite section of the book. It’s a collection of 18 recipes for how to handle a given situation using the principles outlined previously in the book. It covers situations like “The customers are unhappy” and “Features keep creeping in” with practical advice for how to deal with them. All of us find ourselves in these kind of situations from time to time, and this book would come in very handy when they do arise.

Summary

In summary, I think this is an excellent book. It’s not billed as such, but it could almost be considered a sequel to the original Pragmatic Programmers book. While the original focused on the tools and techniques of the trade, this book elaborates on those and adds a lot of information on processes. Combine this with the “Common Problems” section, and you have a very useful book indeed. The writing style is somewhat casual, similar to the other books from the Pragmatic Programmers, and the book is filled with real-world examples from the authors. I would highly recommend Ship It! to anyone interested in improving their software development skills.