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.
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.
: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
: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.
: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 :)
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 1/2 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.
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:
- Tools and Infrastructure
- Pragmatic Project Techniques
- Tracer Bullet Development
- 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.
Steve Krug’s classic book Don’t Make Me Think
has been released in a second edition. This book helped me understand
web design and usability better than any other.
via
