Customer Reviews

Programming Ruby: The Pragmatic Programmers' Guide, Second Edition

5 star:		(37)
4 star:		(12)
3 star:		(7)
2 star:		(2)
1 star:		(3)

 

 

If you are like me, a busy programmer, I know you are wondering when you hear about Ruby, "Do I really have to learn yet another programming language?" I mean, Java, C#, Python? When will it ever end?

Well, it ends when you die, and yes, you do have to learn another programming language :-) But you'll like Ruby, I promise. Things I like about Ruby:

0. As easy to write scripts in as Perl, but it really scales.

1. Exceedingly self-consistent. Ruby has fewer syntactic warts than any programming language I'm familier with. All the features hang together very nicely.

2. Duck Typing: If you use a variable like a string, its a string. If you use it like a float, its a float. If you are familier with Haskell or or similarly typed languages, you get the idea. Ruby gives you about 80% of what Haskell gives you here.

3. Nice module system. This implements a nice mix-in facility--which gives you the power of C++ templates, with more structure. Also eliminates the need for multiple inheritance.

4. Wacky features like call/cc for the true language freaks.

Oh, so you want to know about the book too? Well, I agree with some of the reviewers here who describe the book as less of a tutorial/visionary screed/inspiring gospel and more of a reference manual. But I don't think this is a fair critique of the book. Back in the 60's, before the internet, a language needed a book to do for it what K&R did for C, or what Clocksin & Mellish did for prolog.

But today, you learn about a language by surfing the web. Instead of just duplicating what is available on the internet, this book complements the web, by supplying in a nice portable package what you need to know about Ruby which _can't_ be (easily) gotten from the web. Its a "post-internet" volume in this fashion.

Really the only critique of the book I can offer is that its description of Ruby/TK, the default GUI programming library for Ruby, is a bit abrieviated. It gives you the basics and the refers you a book about Perl/TK for the details. Please guys, in the next edition expand on this!

Ruby is a language which is as object-oriented as smallTalk, as flexible as Scheme, has the scriptibility of Perl, and a nice C-ish syntax. What's not to like? This book is the book to buy if you decide to learn Ruby.

Dave has done it again. Taking what was already an excellent first edition and growing it by 50%. He has updated all of the original chapters, the language walkthrough and the library reference.

Like most language books Programming Ruby starts with installing Ruby and then goes into a language reference; strings, classes, blocks, regular expressions, etc. It's all covered step by step with examples. The second part, Ruby and It's World, is a grab bag of chapters on more complex Ruby topics like graphical user interfaces, Ruby GEMs, and embedding Ruby.

Part III is a concise reference for Ruby that is handy when you already know the language but need a refresher. And the final part is a library reference with examples of using each method. This is the invaluable reference that you will use in every Ruby project.

This is the book to buy to learn Ruby, and to use as a desk reference. There is no question about that.

This is the book you want if you're learning Ruby. It's four books in one! There's a tutorial-style introduction and overview of the language, new to this edition. There's more comprehensive, best-practices kind of coverage. There's a very complete reference to the language. And finally, there's lots of information on packages you might also want, for features outside the scope of the core language.

Ruby is the most inspiring language I've learned, and I've learned quite a few. I can't imagine learning this language without this book. Nor programming in this language without it as a handy reference!

I am a successful self taught programmer. I have learned C/C++, Java, Perl, and now Ruby all from books and reading other people's code. I have to say this is the best book on programming for a particular language that I have ever read. And I have read quite a few.

The book itself is very well written, easy to understand, has a little humour every now and then, but not too much to be annoying.

Some of the other reviews say the chapters of the book are not layed out very well and they don't understand what the Ruby Crystallized section is for. I would have to strongly disagree with this. It starts out with installation, Hello World, then it gets right into classes, methods, variables, etc. All the good stuff. The Ruby Crystallized section is basically to be used as a reference manual to the language. Basically, if you want to skip all of the "whys" and "how-tos", just read this section and learn some of the standard API and you're good to go. But if you want a little more in depth ( which is what I want ), start from the beginning of the book. I think the book was designed so that you really don't have to read the entire thing to get a good grasp of the Ruby language and it's concepts. The cool thing about this book is that it has most of the Ruby standard libraries in the back for easy reference. Not a lot of programming books have this.

I had the opportunity to hear Dave and Andy at a conference just recently and I tell you these are 2 really intelligent, great guys. It was a real joy reading this book. And Ruby is really a joy to learn and program!

I'd suggest already knowing an OO language before you start reading this book. The book approaches its concepts backwards: It starts with the complexities (except for that intro chapter) and then teaches you the simple concepts. One of the things that was completely stupid was that it showed examples of using regular expressions for 1.5 chapters and then explained what regular expressions were afterwards. The authors do not have the common couresy to let you know they'll explain what their stuff means later.

I also agree with a previous review that says this book should be 1/3rd as long as it ended up being.

Now if you already know OO concepts, this book is great. The authors explain everything in as much detail as necessary or more (and i'd rather have more than less). They often explain something and compare it to C or C++ or Java which I like. And the book seems to be absolutely complete. You'll feel like a Ruby MASTER when you finish it. For someone that already knows OOP, the only way this book could be better would be if it were more concise.

If you're a programmer and you want to pick up Ruby, I suggest it.

After having just finished reading the excellent "Programming in C" by Stephen Kochan, I find "Programming Ruby" a bit lackluster. Like a previous reveiwer noted, the Jukebox example in the beginning several chapters is contrived, and frankly, annoying. Many of the code snippets are dependent on one another and it's not intuitive to figure out how they all come together to make a program, especially when one snippet is given and then an alternate is immediately provided - neither of which can exist independently.

I'd be more interested in a straight-forward and thorough approach. For example, the use of symbols is a little confusing (that partly appears to just be Ruby). In the introduction "notation" section, the use of the '#' versus the "." to differentiate types of methods just really got me off on the wrong foot - particularly when it was noted that one notation would be used despite it being invalid Ruby syntax. From that point on I had a bit of symbol overload trying to figure out what the '@', '@@', '#@', '#@@', '$', etc. meant. At one point, a string is referred to as "[#@lyrics]". The brackets were meant to be printed literally and had no programmatic meaning, but just seeing that typed made me do a double take trying to figure out what the square brackets were supposed to indicate. To answer, nothing.

I intend to complete this book, because I can foresee that the knowledge of the language will be worth it. I'm hoping the next edition can draw the reader in a bit better and will provide the information in a more thorough and consistent manner.

If you're comfortable with a programming language like Java or C++, then Programming Ruby: The Pragmatic Programmers' Guide, Second Edition by Dave Thomas with Chad Fowler and Andy Hunt is pretty much a single stop source for everything you'll need to know to get going with Ruby.

Contents:
Part 1 - Facets of Ruby: Getting Started; Ruby.New; Classes, Objects, and Variables; Containers, Blocks, and Iterators; Standard Types; More About Methods; Expressions; Exceptions, Catch, and Throw; Modules; Basic Input and Output; Threads and Processes; Unit Testing; When Trouble Strikes
Part 2 - Ruby In Its Setting: Ruby and Its World; Interactive Ruby Shell; Documenting Ruby; Package Management with RubyGems; Ruby and the Web; Ruby Tk; Ruby and Microsoft Windows; Extending Ruby
Part 3 - Ruby Crystallized: The Ruby Language; Duck Typing; Classes and Objects; Locking Ruby in the Safe; Reflection, ObjectSpace, and Distributed Ruby
Part 4 - Ruby Library Reference: Built-in Classes and Modules; Standard Library
Part 5 - Appendixes: Socket Library; MKMF Reference; Support; Bibliography
Index; Summary Tables

The first think I noticed is that this isn't a "beginner's guide to Ruby". Yes, you may be a beginner to Ruby, but the material is written at a level that assumes you are comfortable with the concept of programming and application development. As such, there's not any time wasted on fluffy stories and rabbit trails. The layout of the material is very similar to what you'd expect to find in a tutorial work for a language like Java. The basic syntax and constructs are covered first, followed by more architectural concepts like objects and typing. Again, if you have a background in an object-oriented programming language already, this is all going to fall into place for you quickly. Once you learn how to work with Ruby, the book continues to retain its usefulness by including all the language reference material you'll need on a day-to-day basis. It's complete enough to give you the answers you need, but concise enough to scan through to get ideas from classes and libraries that you may not have used or known about before.

Given Ruby's background coming from Unix-type environments, many of the examples and writings tend towards that platform (although they aren't "Unix only"). I liked the Windows chapter they included, as there are some interesting ways that you can use Ruby and COM to get some automation of applications going. Hooking into the Windows API is an intriguing concept also, as you can start scripting some tasks you do on a regular basis. There weren't as many "example A does ..." illustrations as I would have liked. It seemed that most of the code snippets were bits and pieces of things that would likely be parts of larger programs. If you're looking for something akin to a Ruby cookbook, this isn't it.

I can understand why this is considered one of the classic Ruby books on the market. It's definitely an option to consider if and when you're ready to start moving to Ruby.

This was another book that I picked up with the expectation that it would introduce me to a whole new programming language. It did. And it did it well. The overall quality of the writing is top notch and the pragmatic approach simply works. Not too much memorizing the language syntax, not too much talk about the history of computers. Instead, the book jumps to the Ruby world head on.

So I just said "not too much memorizing the language syntax". What does that mean? Well, the first part of the book does indeed teach the reader to write syntactically correct Ruby code. However, the way it accomplishes this is not by focusing on the syntax but on the function behind the syntax. Also, the authors have paced the chapters so that you won't be spending too long a time reading about some single specific thing. For me, this approach fits like an old glove. I usually read books in short sprints, be it in a bathtub, a bus, or in bed. Having said that, I do believe that you can get the most out of this book by alternating with reading the book and the interactive Ruby interpreter. There is a downside to the fast pace, though. At times, a specific chapter doesn't quite give you the kind of sense of belonging as the others around it do.

Looking at the wide range of topics listed in the table of contents, the book definitely looks like it covers everything under the Sun. Some of the topics got me panting, almost. Developing web applications with Ruby (one of my motivations behind deciding to read the book in the first place) and unit testing Ruby classes, for example, were topics that I was a bit disappointed about not getting more focus.

Another thing I didn't like too much is the size. At 800+ pages, you're not likely to carry this book around with you. I would've personally preferred putting the 300-page the language/API reference online and left it out from the hardcopy. With the size thing out of my way, I have to admit that the reference certainly looks great compared to what I've seen in most Java books, for example.

All in all, I'm confident that this is one of the best Ruby books out there if not the best, even. Regardless of the few gripes I listed above, there's more than enough absolute gems hidden within these covers. I am certain you won't have second thoughts picking this one to get started on your Ruby way.

This book is probably the authoritative English text on Ruby. It is fondly referred to as the pickax book by many Rubyists. The second edition has been updated to include the improvements in Ruby 1.8. It is organized into five parts with the first three being instructional from different perspectives and the last two being a library reference and the appendices.

However, the first part focuses on introducing Ruby. Running short examples that demonstrates the syntax of Ruby, but the text gives more insight into the concepts behind Ruby. As a tutorial, this part works very well in that the examples add complexity in an iterative fashion. Being as the authors are the pragmatic programmers, there is a chapter on unit testing in Ruby.

With all the excitement about "Ruby on Rails" and other Ruby projects, it is a great time to look into Ruby. This volume is a solid way to get started. In addition to being a good tutorial, it is also an excellence reference. Its only flaw may be that at 800+ pages, it has transitioned to the "luggable" category.

I taught myself to program in Ruby using this book. I was already experienced in Fortran and IDL, but Ruby is my first object-oriented language. Although the book can be confusing, and is not written at a beginner level, I was able to get what I needed from it, and still enjoy cruising through the book to learn more about Ruby. I keep it on my nightstand, but hey...I'm a geek.

If you are new to object-oriented programming I would first recommend reading "The Object Oriented Thought Process" by Matt Weisfeld before actually learning Ruby.