Skip to content

Programming Ruby 1.9 & 2.0: The Pragmatic Programmers' Guide

Spend $50 to get a free movie!

ISBN-10: 1937785491

ISBN-13: 9781937785499

Edition: 2013

Authors: Dave Thomas, Andy Hunt, Chad Fowler

List price: $50.00
Shipping box This item qualifies for FREE shipping.
Blue ribbon 30 day, 100% satisfaction guarantee!
what's this?
Rush Rewards U
Members Receive:
Carrot Coin icon
XP icon
You have reached 400 XP and carrot coins. That is the daily max!


Ruby is the fastest growing and most exciting dynamic language out there. If you need to get working programs delivered fast, you should add Ruby to your toolbox. This book is the only complete reference for both Ruby 1.9 and Ruby 2.0, the very latest version of Ruby. 2013 marks the 20th anniversary of the Ruby language. We're proud that throughout its history, we've continued to cover the latest version of Ruby.Would you like to go from first idea to working code much, much faster? Do you currently spend more time satisfying the compiler instead of your clients or end users? Are you frustrated with demanding languages that seem to get in your way, instead of getting the work done? Are you…    
Customers also bought

Book details

List price: $50.00
Copyright year: 2013
Publisher: Oreilly & Associates Inc
Binding: Paperback
Pages: 888
Size: 7.25" wide x 9.00" long x 1.50" tall
Weight: 2.860
Language: English

Foreword to the Third Edition
Road Map
Facets of Ruby
Getting Started
The Command Prompt
Installing Ruby
Running Ruby
Ruby Documentation: RDoc and ri
Ruby Is an Object-Oriented Language
Some Basic Ruby
Arrays and Hashes
Control Structures
Regular Expressions
Blocks and Iterators
Reading and 'Riting
Command-Line Arguments
Onward and Upward
Classes, Objects, and Variables
Objects and Attributes
Classes Working with Other Classes
Access Control
Containers, Blocks, and Iterators
Blocks and Iterators
Containers Everywhere
Sharing Functionality: Inheritance, Modules, and Mixins
Inheritance and Messages
Iterators and the Enumerable Module
Composing Modules
Inheritance, Mixins, and Design
Standard Types
Regular Expressions
What Regular Expressions Let You Do
Ruby's Regular Expressions
Digging Deeper
Advanced Regular Expressions
More About Methods
Defining a Method
Calling a Method
Operator Expressions
Miscellaneous Expressions
Conditional Execution
Case Expressions
Variable Scope, Loops, and Blocks
Exceptions, catch, and throw
The Exception Class
Handling Exceptions
Raising Exceptions
catch and throw
Basic Input and Output
What Is an IO Object?
Opening and Closing Files
Reading and Writing Files
Talking to Networks
Parsing HTML
Fibers, Threads, and Processes
Controlling the Thread Scheduler
Mutual Exclusion
Running Multiple Processes
Unit Testing
The Testing Framework
Structuring Tests
Organizing and Running Tests
RSpec and Shoulda
Test::Unit assertions
When Trouble Strikes!
Ruby Debugger
Interactive Ruby
Editor Support
But It Doesn't Work!
But Ifs Too Slow!
Ruby in Its Setting
Ruby and Its World
Command-Line Arguments
Program Termination
Environment Variables
Where Ruby Finds Its Libraries
RubyGems Integration
The Rake Build Tool
Build Environment
Namespaces, Source Files, and Distribution
Organizing Your Source
Distributing and Installing Your Code
Character Encoding
Source Files
Input and Output Encoding
Default External Encoding
Encoding Compatibility
Default Internal Encoding
Fun with Unicode
Interactive Ruby Shell
Command Line
Documenting Ruby
Adding RDoc to Ruby Code
Adding RDoc to C Extensions
Running RDoc
Ruby source file documented with RDoc
C source file documented with RDoc
Ruby and the Web
Writing CGI Scripts
Using cgi.rb
Templating Systems
Choice of Web Servers
Ruby and Microsoft Windows
Running Ruby Under Windows
Windows Automation
Ruby Crystallized
The Ruby Language
Source File Encoding
Source Layout
The Basic Types
Variables and Constants
Expressions, Conditionals, and Loops
Method Definition
Invoking a Method
Class Definition
Module Definitions
Access Control
Blocks, Closures, and Proc Objects
catch and throw
Duck Typing
Classes Aren't Types
Coding like a Duck
Standard Protocols and Coercions
Walk the Walk, Talk the Talk
Objects and Classes
Inheritance and Visibility
Modules and Mixins
Metaprogramrriing Class-Level Macros
Two Other Forms of Class Definition
instance_eval and class_eval
Hook Methods
One Last Example
Top-Level Execution Environment
The Turtle Graphics Program
Reflection, ObjectSpace, and Distributed Ruby
Looking at Objects
Looking at Classes
Calling Methods Dynamically
System Hooks
Tracing Your Program's Execution
Behind the Curtain: The Ruby VM
Marshaling and Distributed Ruby
Compile Time? Runtime? Anytime!
Locking Ruby in the Safe
Safe Levels
Tainted Objects
Trusted Objects
Definition of the safe levels
Ruby Library Reference
Built-in Classes and Modules
Standard Library
Web Sites
Usenet Newsgroup
Mailing Lists
Bug Reporting