Everyday script with Ruby was a bit of let down for me. I normally really enjoy books from the Pragmatic Programmers series of books, but this one didn't do much for me. This certainly could be because my expectations were not quite in line the material.

I was hoping for a book that focused heavily on testing with ruby. Instead you get a VERY introductory book about programming, which happens to use ruby. It does cover a tiny bit of using subversion, and automating a few very simple tasks, but it's mostly and introduction to programming Ruby.

I am not saying the book is bad, it's not. It just wasn't what I was looking for. I probably could have done a little more research and found that out ahead of time. In the meantime, I will be passing this book out to my colleagues who are interested in learning programming and/or Ruby.

Unless you've been stuck programming mainframes in COBOL, experienced programmers should steer clear. I found the book to be very slow going and even condescending at times. It spent way too much time on basic concepts like how if/then/else works.

Were I in the target audience, I would probably find it useful, hence the 4 star rating. But if you passed Computer Literacy in 7th grade, some of this will be a refresher.

"Everyday Scripting With Ruby" addresses its three target audiences well:

The first audience: The person who is doing repetitive or manual tasks that could be automated by scripts, but "thinks programming is too hard."

For that audience, the book is a fine introduction to the Ruby language using practical scripts.

The major example scripts are:

* Comparing files in two different directories and reporting the differences.

* An example of automated testing.

* A reporting script for a version control system.

* A script that visits a web site, "scrapes" data from the page, and prepares it for import into a spreadsheet.

* A "watchdog" script that keeps an eye on long-running programs or tests and sends an email or instant message when they finish.

These scripts will be a fine start to your own scripting library, and portions of them will be useful in writing scripts to solve your own problems.

The scripts are improved iteratively, and each iteration provides compelling motivation and a context for learning the next set of Ruby language features.

The second audience: "The person who gets bogged down when writing or changing larger scripts."

This book teaches modern programming techniques that assist in managing complexity, such as test-driven development, "borrowing other people's work in bits in pieces, growing programs gradually, and constantly keeping them clean."

The third audience: "For the person who knows the wrong languages [for scripting purposes] well." It is much easier to write scripts in Ruby than in many other languages. Ruby also compares favorably to other scripting languages such as Perl, Python, or shell scripting (like Bash.) It is easy to read and make changes to a Ruby program that you wrote six months ago.

Ruby on Rails is the web framework that is driving a lot of interest in the Ruby language, and this book would serve as a good introduction to the Ruby language before tackling Rails. An understanding of the Ruby language is essential to understanding Rails.

"Everyday Scripting With Ruby" is well organized and well written. It's a very easy read, and a great introduction to Ruby and scripting.

It's been 12 years since Yukihiro Matsumoto released Ruby's first version. Now that Ruby has achieved mass popularity, more and more people are getting into this new, perhaps odd, programming language. Among other functionalities, Ruby is very suitable for developing lightning fast scripts and learning how to write these is this book's main purpose.

The book is written around four interesting projects that teach you from the basics of Ruby to some useful aspects of this language. Those are an uninstaller checker, a version control system, a web page information retriever and a system monitor for watching long-running programs and then forward information trough email or instant messaging.

Even though the graphics in the book's back says it is for people between beginner and expert level users, I find it specially good for beginners. I'd risk saying that it is even suitable for absolute beginners due to the fact that Brian Marick explains how to set up the language, use a system shell as well as what object oriented programming is, etc...
He does all this without appealing to other languages. This fact, although it is great for beginners, can sometimes annoy experienced developers a bit but it's nothing one cannot deal with.

Brian Marick lead us through the book using a simple and direct speech sometimes with a slight sense of humor to chill things out. He doesn't only teaches how to use the language but also encourage people using it referring to eventual "bugs" and other things that may appear to be odd for beginners.
Another good characteristics are the "Ruby Facts" chapters, it's like an intermission that briefly introduces some concepts as in chapter 10 - "Ruby Facts: Regular Expressions".

The book intends that the reader goes programming along with it as it is a practical book. No deep and extensive concepts are taught here, there's not even an introduction reminding of Ruby's history. Therefore this is a straight practice oriented hands-on book with it's main target being testers that might want to automate some of their work.

Concluding, despite the fact that the book's name ends with "for Teams, Testers and You", all the book seems to be written thinking about testers. I recommend the book specially for beginners who want to learn Ruby as their first programming language and for people who don't know Ruby and want to learn quickly how to write Ruby scripts. Therefore I give this book an overall classification of 4/5.

Review by
Joaquim Rocha (NEEI)

It's been 12 years since Yukihiro Matsumoto released Ruby's first version. Now that Ruby has achieved mass popularity, more and more people are getting into this new, perhaps odd, programming language. Among other functionalities, Ruby is very suitable for developing lightning fast scripts and learning how to write these is this book's main purpose.

The book is written around four interesting projects that teach you from the basics of Ruby to some useful aspects of this language. Those are an uninstaller checker, a version control system, a web page information retriever and a system monitor for watching long-running programs and then forward information trough email or instant messaging.

Even though the graphics in the book's back says it is for people between beginner and expert level users, I find it specially good for beginners. I'd risk saying that it is even suitable for absolute beginners due to the fact that Brian Marick explains how to set up the language, use a system shell as well as what object oriented programming is, etc...
He does all this without appealing to other languages. This fact, although it is great for beginners, can sometimes annoy experienced developers a bit but it's nothing one cannot deal with.

Brian Marick lead us through the book using a simple and direct speech sometimes with a slight sense of humor to chill things out. He doesn't only teaches how to use the language but also encourage people using it referring to eventual "bugs" and other things that may appear to be odd for beginners.
Another good characteristics are the "Ruby Facts" chapters, it's like an intermission that briefly introduces some concepts as in chapter 10 - "Ruby Facts: Regular Expressions".

The book intends that the reader goes programming along with it as it is a practical book. No deep and extensive concepts are taught here, there's not even an introduction reminding of Ruby's history. Therefore this is a straight practice oriented hands-on book with it's main target being testers that might want to automate some of their work.

Concluding, despite the fact that the book's name ends with "for Teams, Testers and You", all the book seems to be written thinking about testers. I recommend the book specially for beginners who want to learn Ruby as their first programming language and for people who don't know Ruby and want to learn quickly how to write Ruby scripts. Therefore I give this book an overall classification of 4/5.

Review by
Joaquim Rocha (NEEI)

This book teaches the Ruby language by working through a series of practical scripts. These scripts accomplish everyday tasks that every tester can relate to: comparing file lists, monitoring code changes, scraping web pages, and using a notification framework. The book covers not only the Ruby language, including an excellent chapter on regular expressions, but also provides detailed advice on how to develop reusable libraries, something that Watir users are always asking for help with. If you are a serious Watir user, don't hesitate to get this book.

During the mid- and late-1980s I was was working in C and eventually C++. During that period I devoured any programming book I could get my hands on. My favorites were very practical books--those books that built real, working examples. Herb Schildt and Al Stevens were the best at this. I've often wished for such books on the newer languages as I learn them. Brian Marick has given us exactly this type of book with his "Everyday Scripting with Ruby."

I'm one of those programmers who read a little bit about Ruby and was only mildly intrigued until I read about Rails. Once I read about Rails I just dove in--I didn't bother to learn much Ruby, only looking something up in "Programming Ruby" when I couldn't figure it out by trial and error. I became proficient enough at getting things done in Rails but certainly didn't have a solid, comfortable feeling for Ruby itself. This book fills in those gaps for me. This is the Ruby book I wish I'd read first.

"Everyday Scripting with Ruby" covers four very real-life small projects, each of a decent size. The projects are small enough that you don't need to remember every detail from the prior 100 pages but are big enough that you can learn real lessons from them. This is absolutely the best beginner book on Ruby available.

When I first heard that the Pragmatic Programmers were putting out a book on Ruby oriented towards testers, I thought to myself that I knew a few testers who might be able to benefit. I was a bit surprised when I received the book and the focus changed from that of testing to something a bit more generic. And after flipping through it I was afraid this would be just yet another book teaching Ruby.

Despite my initial misgivings, as I read through the book its value became apparent. This is not a book aimed at teaching people who are interested in developing complex systems in Ruby; this title is aimed squarely at using Ruby for scripting. "Everyday Scripting with Ruby" is a task-oriented tutorial that will help the reader quickly become productive writing useful scripts. The examples throughout the book are truly indicative of the types of problems that scripts are written to solve, and the book doesn't waste much time on fluff or things that are otherwise not likely to be of interest to the scripter.

While "Everyday Scripting with Ruby" isn't much of a reference manual, it does work pretty well as a tutorial. Readers will typically get the most value from the book by reading it cover-to-cover and following along by getting the examples working on their own computers. Many of the chapters finish with problems for the reader to try out on their own, with the solutions to the problems being detailed in the back of the book. Through reading the text, trying the examples, and further exploration of the material through tackling the end-of-chapter problems, the reader will come away confidant that they can use Ruby to successfully write scripts to solve their problems. You can't ask for much more than that.

Everyday Scripting With Ruby is a book that is geared toward the computer user who is not afraid to scale new heights to try to improve their skills. The premise is that people who use computers routinely do many repetitive tasks that would be better offloaded for a computer to do. Often they think that programming it themselves is too hard, and they cannot justify hiring someone to write a program to handle their menial tasks. Using the Ruby language, anyone who is comfortable with a computer can now learn automate these tasks with a little training.

Ruby is an object-oriented scripting language that originated from Japan. It takes some of the best features from some of the best languages and combines them to make a simple and easy to use yet powerful system for processing tasks. It is freely available as open source software and is available on many platforms including Windows, Mac OS X and Linux.

Everyday Scripting With Ruby targets three audiences. First the "Tester," the person who is involved with the development of software but thinks that programming is too hard. The second target audience is the "Analyst" or someone who manipulates a lot of data. With Ruby scripts, they can automate mundane tasks and free up more time for more rewarding things. Finally, this book is for the programmer who hates to use complex programming languages to accomplish these smaller tasks.

As I said in my full review at Blogcritics, Everyday Scripting With Ruby is a well written introduction to the Ruby language. While it may be too simple for an experienced Ruby developer, an experienced programmer coming to Ruby would find it easy to read and a good place to learn Ruby incrementally. Some one who is not a programmer by avocation, but enjoys mucking around a computer, will find it a wonderful treat!

My son and I have been reading Everyday Scripting with Ruby by Brian Marick. I really like Brian's way of teaching Ruby, and plan on recommending this book widely. (I may need to just buy a stack of copies to give out at work.) This is one of the best books from the 'Facets of Ruby' series by the Pragmatic Programmers.

My favorite feature of the book is the incremental approach. In the first two sections ('The Basics' and 'Growing a Script') he writes a very pragmatic chapter showing how to do something, then a 'referency' (I know, it's not a real word) chapter that goes into more depth about the concept just introduced. The third section ('Working in a World Full of People') follows the pattern less strictly, but still pulls in both the pragmatic and the reference material.

If you're getting started with Ruby, or know someone who is, this is a great book for you.

This book is evidence of everything wrong with the Pragmatic Programmers today. The book is rife with formatting problems. For example, I can't tell if it was accidental, but all the code samples in the book are in small, proportionally-spaced type. Not helpful - who uses proportional fonts in their text editor? Many chapters are extremely short, some consisting of just a bunch of one-line Ruby examples that could be summed up by a paragraph of explanation. It's schizophrenic - I'm having trouble figuring out exactly who would benefit from the book. And their books are printed so cheaply that I get light-headed from the horrible smell when trying to read them!

I received this book along with an O'Reilly book, and the differences couldn't have been more striking. O'Reilly puts so much more time and effort into every aspect of their books - the design, the technical editing, the screen shots and example code - that it's hard to look at a Pragmatic Programmers book afterwards. Many of the Pragmatic titles are excellent, and worth the trouble of dealing with the poor presentation, but this is not one of them. Save your money.

I'm only about two thirds of the way through "Everyday Scripting With Ruby", but I feel qualified to leave commentary already. If you've already read books published by the Pragmatic Programmers, then you're likely used to the sort of writing style that their authors seem to use- generally very practical, to the point, and a bit informal. If you've attempted to dive into Ruby you probably also have at least passing acquaintance with the "Pickaxe"- Programming Ruby- by Dave Thomas and Andy Hunt.

If you're a systems administrator, and a shell scripter, or if you're used to lower level languages like C and the like.. you may have had the instinct "great book, but where do I start?", when reading through the Pickaxe. This particular book is exactly the starting point for a knowledgeable technician or tester with a hands-on, intuition driven learning style, who may or may not be familiar with another scripting or programming languages, but for whom "Learn to Program" is too much of a step back, and "Programming Ruby" is too dense. There's no "Well, that's easy but where do I go from here" as with the former title, nor is there, "Well, that's amazing, powerful, and spiff, but where do I start", as with the latter. The book is all meat, no bones, no gristle, all useful.


The teaching method that Brian Marick uses isn't too dissimilar from the method used in C by Dissection, by Ira Pohl, in that it shows working code pieces in context and derives rules for use from empirical use, but it's better in that all of the examples are tied to particular project themes by section and/or chapter. The tools that are developed as part of the book are tools you can and perhaps will use in your day-to-day processes, and provide a smart foundation for further exploration.

The exercises are also not trivial, but not too abstract, nor are there too many of them.. I can't really think of a way to describe the book better than "pragmatic". Which is exactly what you should expect from this press.

I'm rating 5 out of 5 for now, but may drop to 4 out of 5 for lack of end-book depth, but that's not really exactly fair. I wish I could drop a 4.5 / 5 on the book. For learning to use Ruby for practical non-rails-oriented, actual -WORK- tasks, and swiftly, I don't think there's a better bet for now.