Ruby Under a Microscope: An Illustrated Guide to Ruby Internals 1st Edition

by Pat Shaughnessy (Author)

28 ratings

ISBN-13: 978-1593275273

ISBN-10: 1593275277

Why is ISBN important?

Share <Embed>

Other Sellers

from

Other Sellers

See all 4 versions

Used: Very Good | Details

Sold by happycustomers

Fulfilled by Amazon

Access codes and supplements are not guaranteed with used items.

Get Fast, Free Shipping with Amazon Prime

FREE delivery: Friday, June 25 on orders over $25.00 shipped by Amazon. Details

Only 6 left in stock - order soon.

Ships from and sold by Amazon.com.

Available at a lower price from other sellers that may not offer free Prime shipping.

List Price: $39.95 Details

Save: $9.43 (24%)

FREE delivery: Friday, June 25 Details

Fastest delivery: Thursday, June 24
Order within 11 hrs and 19 mins Details

Savings Get 3 for the price of 2. Shop items

Available at a lower price from other sellers that may not offer free Prime shipping.

Ruby is a powerful programming language with a focus on simplicity, but beneath its elegant syntax it performs countless unseen tasks.

Ruby Under a Microscope gives you a hands-on look at Ruby's core, using extensive diagrams and thorough explanations to show you how Ruby is implemented (no C skills required). Author Pat Shaughnessy takes a scientific approach, laying out a series of experiments with Ruby code to take you behind the scenes of how programming languages work. You'll even find information on JRuby and Rubinius (two alternative implementations of Ruby), as well as in-depth explorations of Ruby's garbage collection algorithm.

Ruby Under a Microscope will teach you:

How a few computer science concepts underpin Ruby's complex implementation
How Ruby executes your code using a virtual machine
How classes and modules are the same inside Ruby
How Ruby employs algorithms originally developed for Lisp
How Ruby uses grammar rules to parse and understand your code
How your Ruby code is translated into a different language by a compiler

No programming language needs to be a black box. Whether you're already intrigued by language implementation or just want to dig deeper into Ruby, you'll find Ruby Under a Microscope a fascinating way to become a better programmer.

Covers Ruby 2.x, 1.9 and 1.8

Frequently bought together

Customers who viewed this item also viewed

Page 1 of 1 Start overPage 1 of 1

David A. Black
44
Paperback
$45.49
Sandi Metz
88
Paperback
$23.87
Russ Olsen
147
Paperback
$47.35
David Flanagan
173
Paperback
$23.72
Jay McGavren
68
Paperback
$47.93
Sam Ruby
38
Paperback
$51.49

More items to explore

Page 1 of 1 Start overPage 1 of 1

Erik Oberg
398
Hardcover
in Machinery Engineering
$100.62
1,951
in Microscope Sample Slides
$14.39
62
$22.99
93
7% off
$42.99 $45.99
Lowest price in 30 days
453
$109.99
208
5% off
$106.99 $112.99
Lowest price in 30 days

Special offers and product promotions

Get 3 for the price of 2. Offered by Amazon.com. Shop items

Amazon Business: Make the most of your Amazon Business account with exclusive tools and savings. Login now

Editorial Reviews

About the Author

Well known for his coding expertise and passion for the Ruby programming language, Pat Shaughnessy blogs and writes tutorials at https://patshaughnessy.net/. He also develops Ruby applications at management consulting firm McKinsey & Co. Shaughnessy is a regular presenter on the Ruby conference circuit, and his articles and presentations have been featured in the Ruby Weekly newsletter, the Ruby5 podcast, and The Ruby Show.

Product details

Publisher ‏ : ‎ No Starch Press; 1st edition (November 22, 2013)
Language ‏ : ‎ English
Paperback ‏ : ‎ 360 pages
ISBN-10 ‏ : ‎ 1593275277
ISBN-13 ‏ : ‎ 978-1593275273
Item Weight ‏ : ‎ 1.48 pounds
Dimensions ‏ : ‎ 7 x 0.88 x 9 inches

Best Sellers Rank: #1,134,282 in Books (See Top 100 in Books)
- #103 in Ruby Programming
- #268 in Object-Oriented Software Design
- #783 in Object-Oriented Design

Customer Reviews:
28 ratings

Customer reviews

5 star		78%
4 star		6%
3 star		8%
2 star 0% (0%)		0%
1 star		8%

How are ratings calculated?

Top reviews from the United States

There was a problem filtering reviews right now. Please try again later.

Fabulous, Readable, ENJOYABLE Language Internals Book

Reviewed in the United States on April 27, 2017

Verified Purchase

I've meant to buy this book for ages. I wish there were books like this for every programming language. It's very readable and approachable. Not dry zzz material at all. Contrary to what he says though, you cannot really be into it unless you're peeking at the C source :)
General lessons are learnable here that apply to lots of languages too.

One person found this helpful

Helpful

Great look at Ruby's internals

Reviewed in the United States on January 1, 2017

Verified Purchase

Great information about Ruby. Nice diagrams as well as experiments that show cool Ruby commands to peek into its internals. Highly recommend if you are interested in programming languages.

2 people found this helpful

Helpful

ndc

Fantastic book, great achievement

Reviewed in the United States on January 11, 2017

Verified Purchase

Amazing! Excellent! Fantastic! Whee!

Helpful

Amazon Customer

Pat Shaughnessy is a software engineering maven.

Reviewed in the United States on October 17, 2015

Verified Purchase

Learned things that the Ruby reference does not explain well enough. Also learned general software engineering concepts, not just Ruby. Does not cover the parser in depth, but that's expected as bison is quite complex.

One person found this helpful

Helpful

Lighthouse

Five Stars

Reviewed in the United States on July 31, 2014

Verified Purchase

Excellent read

One person found this helpful

Helpful

Jônatas Rancan

Five Stars

Reviewed in the United States on June 29, 2015

Verified Purchase

Very easy to read and understand.

One person found this helpful

Helpful

Federico Lucifredi

A technical deep dive that remains fun and enjoyable

Reviewed in the United States on November 17, 2013

Ruby Under a Microscope is a remarkable dissection of the internals of Ruby's runtime environment. Definitely too much for the casual user, but an absolute must for the power user - the dissection of how hash tables work in Ruby "under the hood" is worth the book in of itself. Coverage of the innards of the runtime's garbage collection process is equally useful.

The experiments the author carries out throughout the book to show the language's behavior, or to measure performance, are not only great explanation of how things operate, they are entertaining to read - at least for those with a performance tuning eye or a desire to really understand what is going on. I love it, I have seen this done in class, I have done it myself, but it is a teaching model rarely seen in writing that fits this technically deep subject very well.

Fans of lisp will appreciate the credit that the author gives the venerable language for closures and for McCarthy's garbage collection algorithm, among other things.

The book is richly illustrated, and the diagrams help a great deal in following the details being discussed - as you can imagine, pointers^Hreferences are everywhere, and diagrams really make decoding the lay of the land much easier.

A minor negative, looks like No Starch used a lighter paper choice than their regular, thick heavy paper - a fancy attribute of their books that I have come to look forward to. I would expect this was done to limit the heft of this particular tome, that at 330-plus pages would have come out rather thick in the usual paper choice.

18 people found this helpful

Helpful

Michael Larsen

See the wiring under the board

Reviewed in the United States on February 12, 2014

Let's start with a disclaimer. I'm not a Computer Science major, nor did I complete a Computer Science course of study in school. I'm a software tester, and one that finds themselves frequently using programming languages of various stripes for various purposes. Ruby is one of the most popular languages in current use, and for many, it's a language that allows them to learn some basic terms, some programming constructs, and then lets them just use it. It's clean, it's elegant, it's almost simple. It's a language that invites the user to just go with it.

For some, though, there's that sense of curiosity... what is my Ruby program really doing? How can I see what the system is actually doing with my code? What's going on underneath the hood? If such explorations interest you, then "Ruby Under a Microscope" by Pat Shaughnessy tackles that subject handily.

A word of warning going in. This is not a general language book. You will not learn much about programming in Ruby here. You should have a decent understanding of what Ruby syntax looks like and how it works. Having said that, you don't need to have years of experience with Ruby to appreciate this book for what it does. It takes some key areas of the language, and through examples, some small programs, and a variety of tools, lets you see and understand what Ruby actually looks like up close and personal.

Chapter 1 focuses on how Ruby understand the text that you type into your Ruby program. Ruby converts your source code first into tokens, and then converts that input stream into an "abstract syntax tree”. Through tools like “Ripper”, you can see this process and watch it in something resembling natural language (well, kind of. It’s still debug code, but it’s a lot less intimidating than one might think.

Chapter 2 covers how Ruby compiles code. Wait, isn’t Ruby a “scripting language, no compiler required? With 1.8 and earlier, yes, but with 1.9 and up, Ruby is compiled just like many other languages we are familiar with. The difference? Ruby does it automatically. You never need to invoke the compiler. Ruby also has its own “virtual machine” (YARV, or "Yet Another Ruby Virtual Machine) that it compiles its bytecode for. Ultimately, the byte code for YARV is what we witness running.

Chapter 3 goes into greater detail about how YARV runs our code. By comparing the steps necessary to run a simple program, we can compare the time it takes to run a program in Ruby 1.8 (which doesn’t have a compile sequence, it just runs) and Ruby 1.9 and 2.0, which do have compile sequences. For simple and brief interactions, it actually looks like Ruby 1.8 performs better, but for longer runs with more iterations, 1.9 and 2.0 have a huge advantage over 1.8 by virtue of its compile cycle.

Chapter 4 focuses more attention on the virtual machine and how control structures and methods are handled within the YARV. If statements, for loops and calls to various methods demonstrate how ruby breaks down the instructions, as well as how it utilizes its internal calls to “jump” from one piece of code to another. Ruby categorizes methods into 11 types, and labels its built-in methods as CFUNC methods, meaning they are implemented in C. Ruby also uses a hash to keep track of the number of arguments, her labels and what their default values should be.

Chapter 5 looks at objects and classes, specifically, Ruby’s internal objects and classes. Each Ruby object is, ultimately, a class pointer paired with an array of instance variables, and everything in Ruby is an object. Several generic objects are shown, along with their C structures (RString, RArray, RRegexp, etc.), and demonstrate how they, likewise, are also simple combinations of a class pointer and instance variables. Classes are a little more involved. Each Ruby class can be defined as Ruby object (with its class pointer & instance variables) plus method definitions, attribute names, a constants table and a “superclass” pointer.

Chapter 6 brings us deeper into methods and constants, specifically how these aspects are found and represented. Ruby lets a programmer look at programs with two contrasting paradigms. Code can be organized through classes and super-classes, or it can be organized through "lexical scope". Which approach makes the most sense? it depends on what you want to have your program accomplish.

Chapter 7 gets into one of the key attributes of Ruby internals, the Hash Table. These are interesting data structures that allow a program to return values quickly, and to automatically increase in size as more elements are added. the chapter takes a deep dive into Ruby’s hash function and how it allows for elements to be accessed quickly.

Chapter 8 covers blocks, and how the Blocks concept in Ruby borrows from the “closure” idea first prosed in the Lisp language several decades back. Blocks can be defined as “a combination of a function and an environment to use when calling that function”. Using “lambda”, a block can become a data value that can be passed, saved, and reused.

Chapter 9 discusses Metaprogramming, a means to program in a way that code can inspect and change itself, dynamically. In other words, by referencing itself, your program can change itself! I’ll admit, this is one of the aspects of Ruby (or any language) that I have trouble getting my head around, and while I won’t claim to have mastery of these ideas after this chapter, I feel I have a little better feel for what’s happening.

Chapter 10 takes us into the Java realm and shows us Ruby implemented in Java, as opposed to how we’ve been interacting with it thus far in C. The flow is similar, but each Ruby script gets compiled into a Java executable, and then is physically run by the Java Virtual Machine. We see how “Jay” parses the lines of code (much the way Bison does for MRI). By monitoring Java’s Just In time Compiler, we can see which class and structures are called whenever we create a script and run it. We can also see where, by focusing on various “hot spots in our program and compiling them into Java, we can save time in key areas compared to C implemented MRI.

Chapter 11 introduces Rubinious, a version of Ruby implemented with Ruby. Well, it’s actually a virtual machine using C++ to run Ruby code. What makes it different is that, rather than relying on C or Java Structures for the built in classes, Rubinious does it with Ruby code. What does this mean? we can see how Ruby works internally without having to know C or Java. It’s all done in Ruby, and we can see how by reading the source code.

Chapter 12 explores Ruby’s Garbage Collection, and how it differs, and is similar, in MRI, JRuby and Rubinious. Garbage collection helps us with three processes; allocating memory for use by new objects, identifying which objects a program is no longer using, and reclaiming memory from unused objects. Various programs and examples demonstrate which objets are mapped where, and how to see when they are deallocated and their memory freed. Various algorithms for the various virtual machines are explored, but this is just a cursory overview of all the options and how they are implemented. Still, it’s an interesting view into a process that many of us take for granted because Ruby and many other languages basically let us take them for granted.

Bottom Line:

"Ruby Under a Microscope" does something fairly ambitious. It attempts to write a system internals book in a language that non computer scientists can readily understand. While there are numerous code snippets and examples to try and examine, the ability to look at the various Ruby internals and systems and see how they fit together can be accomplished by someone with general skills and basic familiarity with programming at the script level (which for many of us is as far as we typically get). An old saying says you can’t tell where yo hare going if you don’t know where you’ve been. Similarly, we can’t expect to get the most out of languages like ruby without having a more clear idea what’s happening under the hood. It’s entirely possible to work with Ruby and never learn some of this stuff, but having a guide like "Ruby Under a Microscope” opens up a variety of avenues, and does so in a way that will make the journey interesting and, dare I say it, even a little fun.

8 people found this helpful

Helpful

Top reviews from other countries

Translate all reviews to English

Irsyad Asyhari Lubis

Good read. Very informative!

Reviewed in Germany on March 15, 2020

Verified Purchase

What I like about this book is that the author doesn't immediately jump into the technical details. But, instead, he explains the concept in a bigger picture first. From there, he introduces the technical detail one concept at a time.

Leandro Krug Wives

Conheça os bastidores da linguagem Ruby

Reviewed in Brazil on November 19, 2014

Verified Purchase

O livro é muito bom para quem quer entender como a linguagem funciona nos seus bastidores (mecanismos internos de funcionamento). É um livro importante para quem quer programar melhor em Ruby e compreender a melhor maneira de fazer alguma coisa, visto que entenderá quais são as abordagens usadas nos diferentes mecanismos adotados. Indispensável para todo profissional de computação que trabalhe com Ruby e também para os curiosos.

2 people found this helpful

Translate review to English

Mohsen Alizadeh

I love this book

Reviewed in Germany on February 6, 2019

Verified Purchase

Amazing book about ruby internals. It is complex may take some time to grasp all the concepts. You maybe need to read several times.

Jean

bien

Reviewed in France on June 18, 2018

Verified Purchase

correspond en tout point. a ce qui était attendu par mon fils qui l’a commandé sur le site. très bien.

Translate review to English

See all reviews

Customers who bought this item also bought

Page 1 of 1 Start overPage 1 of 1

Ruby Under a Microscope: An Illustrated Guide to Ruby Internals 1st Edition

Buy used: $24.14

Buy new: $30.52

Frequently bought together

Customers who viewed this item also viewed

More items to explore

Special offers and product promotions

Editorial Reviews

About the Author

Product details

Customer reviews

Top reviews from the United States

There was a problem filtering reviews right now. Please try again later.

Top reviews from other countries

Customers who bought this item also bought

Buy used:

$24.14

Buy new:

$30.52