Ruby Cookbook

( 3 )

Overview

Push Ruby to its limits. Ruby Cookbook is the most comprehensive problem-solving guide to this popular language, with hundreds of solutions to real-world problems. Each detailed recipe provides code that you can use in your own projects right away, as well as a discussion on why the solution works.

Updated to include Ruby 1.9 and 2.0, the second edition includes recipes for the Rails framework and other projects involving Ruby. From data structures and algorithms to integration ...

See more details below
Other sellers (Paperback)
  • All (28) from $3.66   
  • New (8) from $28.14   
  • Used (20) from $3.66   
Ruby Cookbook

Available on NOOK devices and apps  
  • NOOK Devices
  • Samsung Galaxy Tab 4 NOOK 7.0
  • Samsung Galaxy Tab 4 NOOK 10.1
  • NOOK HD Tablet
  • NOOK HD+ Tablet
  • NOOK eReaders
  • NOOK Color
  • NOOK Tablet
  • Tablet/Phone
  • NOOK for Windows 8 Tablet
  • NOOK for iOS
  • NOOK for Android
  • NOOK Kids for iPad
  • PC/Mac
  • NOOK for Windows 8
  • NOOK for PC
  • NOOK for Mac
  • NOOK for Web

Want a NOOK? Explore Now

NOOK Book (eBook)
$22.99
BN.com price
(Save 42%)$39.99 List Price

Overview

Push Ruby to its limits. Ruby Cookbook is the most comprehensive problem-solving guide to this popular language, with hundreds of solutions to real-world problems. Each detailed recipe provides code that you can use in your own projects right away, as well as a discussion on why the solution works.

Updated to include Ruby 1.9 and 2.0, the second edition includes recipes for the Rails framework and other projects involving Ruby. From data structures and algorithms to integration with cutting-edge technologies, Ruby Cookbook covers a wide range of programming topics for beginners and advanced Rubyists alike.

With the introduction of Ruby on Rails, the Ruby scripting language has been a rising star among programmers over the past year. This new book covers all aspects of the language, from the basics to more advanced issues, so that programmers of any level can learn by example and improve their skills.

Read More Show Less

Product Details

  • ISBN-13: 9780596523695
  • Publisher: O'Reilly Media, Incorporated
  • Publication date: 7/1/2006
  • Series: Cookbooks (O'Reilly) Series
  • Edition number: 1
  • Pages: 910
  • Sales rank: 1,328,394
  • Product dimensions: 6.96 (w) x 9.32 (h) x 1.58 (d)

Meet the Author

Lucas Carlson founded AppFog, a PaaS company that leveraged Cloud Foundry and was acquired by CenturyLink. Lucas has been a professional developer for 20 years and specializes in Ruby on Rails development. Lucas has authored Programming for PaaS and the Ruby Cookbook and has written half a dozen libraries in various programming languages and contributed to many others, including Rails and RedCloth.

Leonard Richardson (http://www.crummy.com/) is the author of the Ruby Cookbook (O'Reilly) and of several open source libraries, including Beautiful Soup. A California native, he currently lives in New York.

Read More Show Less

Table of Contents

Dedication;
Preface;
Life Is Short;
Audience;
The Structure of This Book;
How the Code Listings Work;
Installing the Software;
Platform Differences, Version Differences, and Other Headaches;
Other Resources;
Conventions Used in This Book;
Using Code Examples;
Comments and Questions;
Acknowledgments;
Chapter 1: Strings;
1.1 Building a String from Parts;
1.2 Substituting Variables into Strings;
1.3 Substituting Variables into an Existing String;
1.4 Reversing a String by Words or Characters;
1.5 Representing Unprintable Characters;
1.6 Converting Between Characters and Values;
1.7 Converting Between Strings and Symbols;
1.8 Processing a String One Character at a Time;
1.9 Processing a String One Word at a Time;
1.10 Changing the Case of a String;
1.11 Managing Whitespace;
1.12 Testing Whether an Object Is String-Like;
1.13 Getting the Parts of a String You Want;
1.14 Handling International Encodings;
1.15 Word-Wrapping Lines of Text;
1.16 Generating a Succession of Strings;
1.17 Matching Strings with Regular Expressions;
1.18 Replacing Multiple Patterns in a Single Pass;
1.19 Validating an Email Address;
1.20 Classifying Text with a Bayesian Analyzer;
Chapter 2: Numbers;
2.1 Parsing a Number from a String;
2.2 Comparing Floating-Point Numbers;
2.3 Representing Numbers to Arbitrary Precision;
2.4 Representing Rational Numbers;
2.5 Generating Random Numbers;
2.6 Converting Between Numeric Bases;
2.7 Taking Logarithms;
2.8 Finding Mean, Median, and Mode;
2.9 Converting Between Degrees and Radians;
2.10 Multiplying Matrices;
2.11 Solving a System of Linear Equations;
2.12 Using Complex Numbers;
2.13 Simulating a Subclass of Fixnum;
2.14 Doing Math with Roman Numbers;
2.15 Generating a Sequence of Numbers;
2.16 Generating Prime Numbers;
2.17 Checking a Credit Card Checksum;
Chapter 3: Date and Time;
3.1 Finding Today's Date;
3.2 Parsing Dates, Precisely or Fuzzily;
3.3 Printing a Date;
3.4 Iterating Over Dates;
3.5 Doing Date Arithmetic;
3.6 Counting the Days Since an Arbitrary Date;
3.7 Converting Between Time Zones;
3.8 Checking Whether Daylight Saving Time Is in Effect;
3.9 Converting Between Time and DateTime Objects;
3.10 Finding the Day of the Week;
3.11 Handling Commercial Dates;
3.12 Running a Code Block Periodically;
3.13 Waiting a Certain Amount of Time;
3.14 Adding a Timeout to a Long-Running Operation;
Chapter 4: Arrays;
4.1 Iterating Over an Array;
4.2 Rearranging Values Without Using Temporary Variables;
4.3 Stripping Duplicate Elements from an Array;
4.4 Reversing an Array;
4.5 Sorting an Array;
4.6 Ignoring Case When Sorting Strings;
4.7 Making Sure a Sorted Array Stays Sorted;
4.8 Summing the Items of an Array;
4.9 Sorting an Array by Frequency of Appearance;
4.10 Shuffling an Array;
4.11 Getting the N Smallest Items of an Array;
4.12 Building Up a Hash Using Injection;
4.13 Extracting Portions of Arrays;
4.14 Computing Set Operations on Arrays;
4.15 Partitioning or Classifying a Set;
Chapter 5: Hashes;
5.1 Using Symbols as Hash Keys;
5.2 Creating a Hash with a Default Value;
5.3 Adding Elements to a Hash;
5.4 Removing Elements from a Hash;
5.5 Using an Array or Other Modifiable Object as a Hash Key;
5.6 Keeping Multiple Values for the Same Hash Key;
5.7 Iterating Over a Hash;
5.8 Iterating Over a Hash in Insertion Order;
5.9 Printing a Hash;
5.10 Inverting a Hash;
5.11 Choosing Randomly from a Weighted List;
5.12 Building a Histogram;
5.13 Remapping the Keys and Values of a Hash;
5.14 Extracting Portions of Hashes;
5.15 Searching a Hash with Regular Expressions;
Chapter 6: Files and Directories;
6.1 Checking to See If a File Exists;
6.2 Checking Your Access to a File;
6.3 Changing the Permissions on a File;
6.4 Seeing When a File Was Last Used Problem;
6.5 Listing a Directory;
6.6 Reading the Contents of a File;
6.7 Writing to a File;
6.8 Writing to a Temporary File;
6.9 Picking a Random Line from a File;
6.10 Comparing Two Files;
6.11 Performing Random Access on "Read-Once" Input Streams;
6.12 Walking a Directory Tree;
6.13 Locking a File;
6.14 Backing Up to Versioned Filenames;
6.15 Pretending a String Is a File;
6.16 Redirecting Standard Input or Output;
6.17 Processing a Binary File;
6.18 Deleting a File;
6.19 Truncating a File;
6.20 Finding the Files You Want;
6.21 Finding and Changing the Current Working Directory;
Chapter 7: Code Blocks and Iteration;
7.1 Creating and Invoking a Block;
7.2 Writing a Method That Accepts a Block;
7.3 Binding a Block Argument to a Variable;
7.4 Blocks as Closures: Using Outside Variables Within a Code Block;
7.5 Writing an Iterator Over a Data Structure;
7.6 Changing the Way an Object Iterates;
7.7 Writing Block Methods That Classify or Collect;
7.8 Stopping an Iteration;
7.9 Looping Through Multiple Iterables in Parallel;
7.10 Hiding Setup and Cleanup in a Block Method;
7.11 Coupling Systems Loosely with Callbacks;
Chapter 8: Objects and Classes;
8.1 Managing Instance Data;
8.2 Managing Class Data;
8.3 Checking Class or Module Membership;
8.4 Writing an Inherited Class;
8.5 Overloading Methods;
8.6 Validating and Modifying Attribute Values;
8.7 Defining a Virtual Attribute;
8.8 Delegating Method Calls to Another Object;
8.9 Converting and Coercing Objects to Different Types;
8.10 Getting a Human-Readable Printout of Any Object;
8.11 Accepting or Passing a Variable Number of Arguments;
8.12 Simulating Keyword Arguments;
8.13 Calling a Superclass's Method;
8.14 Creating an Abstract Method;
8.15 Freezing an Object to Prevent Changes;
8.16 Making a Copy of an Object;
8.17 Declaring Constants;
8.18 Implementing Class and Singleton Methods;
8.19 Controlling Access by Making Methods Private;
Chapter 9: Modules and Namespaces;
9.1 Simulating Multiple Inheritance with Mixins;
9.2 Extending Specific Objects with Modules;
9.3 Mixing in Class Methods;
9.4 Implementing Enumerable: Write One Method, Get 22 Free;
9.5 Avoiding Naming Collisions with Namespaces;
9.6 Automatically Loading Libraries as Needed;
9.7 Including Namespaces;
9.8 Initializing Instance Variables Defined by a Module;
9.9 Automatically Initializing Mixed-In Modules;
Chapter 10: Reflection and Metaprogramming;
10.1 Finding an Object's Class and Superclass;
10.2 Listing an Object's Methods;
10.3 Listing Methods Unique to an Object;
10.4 Getting a Reference to a Method;
10.5 Fixing Bugs in Someone Else's Class;
10.6 Listening for Changes to a Class;
10.7 Checking Whether an Object Has Necessary Attributes;
10.8 Responding to Calls to Undefined Methods;
10.9 Automatically Initializing Instance Variables;
10.10 Avoiding Boilerplate Code with Metaprogramming;
10.11 Metaprogramming with String Evaluations;
10.12 Evaluating Code in an Earlier Context;
10.13 Undefining a Method;
10.14 Aliasing Methods;
10.15 Doing Aspect-Oriented Programming;
10.16 Enforcing Software Contracts;
Chapter 11: XML and HTML;
11.1 Checking XML Well-Formedness;
11.2 Extracting Data from a Document's Tree Structure;
11.3 Extracting Data While Parsing a Document;
11.4 Navigating a Document with XPath;
11.5 Parsing Invalid Markup;
11.6 Converting an XML Document into a Hash;
11.7 Validating an XML Document;
11.8 Substituting XML Entities;
11.9 Creating and Modifying XML Documents;
11.10 Compressing Whitespace in an XML Document;
11.11 Guessing a Document's Encoding;
11.12 Converting from One Encoding to Another;
11.13 Extracting All the URLs from an HTML Document;
11.14 Transforming Plain Text to HTML;
11.15 Converting HTML Documents from the Web into Text;
11.16 A Simple Feed Aggregator;
Chapter 12: Graphics and Other File Formats;
12.1 Thumbnailing Images;
12.2 Adding Text to an Image;
12.3 Converting One Image Format to Another;
12.4 Graphing Data;
12.5 Adding Graphical Context with Sparklines;
12.6 Strongly Encrypting Data;
12.7 Parsing Comma-Separated Data;
12.8 Parsing Not-Quite-Comma-Separated Data;
12.9 Generating and Parsing Excel Spreadsheets;
12.10 Compressing and Archiving Files with Gzip and Tar;
12.11 Reading and Writing ZIP Files;
12.12 Reading and Writing Configuration Files;
12.13 Generating PDF Files;
12.14 Representing Data as MIDI Music;
Chapter 13: Databases and Persistence;
13.1 Serializing Data with YAML;
13.2 Serializing Data with Marshal;
13.3 Persisting Objects with Madeleine;
13.4 Indexing Unstructured Text with SimpleSearch;
13.5 Indexing Structured Text with Ferret;
13.6 Using Berkeley DB Databases;
13.7 Controlling MySQL on Unix;
13.8 Finding the Number of Rows Returned by a Query;
13.9 Talking Directly to a MySQL Database;
13.10 Talking Directly to a PostgreSQL Database;
13.11 Using Object Relational Mapping with ActiveRecord;
13.12 Using Object Relational Mapping with Og;
13.13 Building Queries Programmatically;
13.14 Validating Data with ActiveRecord;
13.15 Preventing SQL Injection Attacks;
13.16 Using Transactions in ActiveRecord;
13.17 Adding Hooks to Table Events;
13.18 Adding Taggability with a Database Mixin;
Chapter 14: Internet Services;
14.1 Grabbing the Contents of a Web Page;
14.2 Making an HTTPS Web Request;
14.3 Customizing HTTP Request Headers;
14.4 Performing DNS Queries;
14.5 Sending Mail;
14.6 Reading Mail with IMAP;
14.7 Reading Mail with POP3;
14.8 Being an FTP Client;
14.9 Being a Telnet Client;
14.10 Being an SSH Client;
14.11 Copying a File to Another Machine;
14.12 Being a BitTorrent Client;
14.13 Pinging a Machine;
14.14 Writing an Internet Server;
14.15 Parsing URLs;
14.16 Writing a CGI Script;
14.17 Setting Cookies and Other HTTP Response Headers;
14.18 Handling File Uploads via CGI;
14.19 Running Servlets with WEBrick;
14.20 A Real-World HTTP Client;
Chapter 15: Web Development: Ruby on Rails;
15.1 Writing a Simple Rails Application to Show System Status;
15.2 Passing Data from the Controller to the View;
15.3 Creating a Layout for Your Header and Footer;
15.4 Redirecting to a Different Location;
15.5 Displaying Templates with Render;
15.6 Integrating a Database with Your Rails Application;
15.7 Understanding Pluralization Rules;
15.8 Creating a Login System;
15.9 Storing Hashed User Passwords in the Database;
15.10 Escaping HTML and JavaScript for Display;
15.11 Setting and Retrieving Session Information;
15.12 Setting and Retrieving Cookies;
15.13 Extracting Code into Helper Functions;
15.14 Refactoring the View into Partial Snippets of Views;
15.15 Adding DHTML Effects with script.aculo.us;
15.16 Generating Forms for Manipulating Model Objects;
15.17 Creating an Ajax Form;
15.18 Exposing Web Services on Your Web Site;
15.19 Sending Mail with Rails;
15.20 Automatically Sending Error Messages to Your Email;
15.21 Documenting Your Web Site;
15.22 Unit Testing Your Web Site;
15.23 Using breakpoint in Your Web Application;
Chapter 16: Web Services and Distributed Programming;
16.1 Searching for Books on Amazon;
16.2 Finding Photos on Flickr;
16.3 Writing an XML-RPC Client;
16.4 Writing a SOAP Client;
16.5 Writing a SOAP Server;
16.6 Searching the Web with Google's SOAP Service;
16.7 Using a WSDL File to Make SOAP Calls Easier;
16.8 Charging a Credit Card;
16.9 Finding the Cost to Ship Packages via UPS or FedEx;
16.10 Sharing a Hash Between Any Number of Computers;
16.11 Implementing a Distributed Queue;
16.12 Creating a Shared "Whiteboard";
16.13 Securing DRb Services with Access Control Lists;
16.14 Automatically Discovering DRb Services with Rinda;
16.15 Proxying Objects That Can't Be Distributed;
16.16 Storing Data on Distributed RAM with MemCached;
16.17 Caching Expensive Results with MemCached;
16.18 A Remote-Controlled Jukebox;
Chapter 17: Testing, Debugging, Optimizing, and Documenting;
17.1 Running Code Only in Debug Mode;
17.2 Raising an Exception;
17.3 Handling an Exception;
17.4 Rerunning After an Exception;
17.5 Adding Logging to Your Application;
17.6 Creating and Understanding Tracebacks;
17.7 Writing Unit Tests;
17.8 Running Unit Tests;
17.9 Testing Code That Uses External Resources;
17.10 Using breakpoint to Inspect and Change the State of Your Application;
17.11 Documenting Your Application;
17.12 Profiling Your Application;
17.13 Benchmarking Competing Solutions;
17.14 Running Multiple Analysis Tools at Once;
17.15 Who's Calling That Method? A Call Graph Analyzer;
Chapter 18: Packaging and Distributing Software;
18.1 Finding Libraries by Querying Gem Respositories;
18.2 Installing and Using a Gem;
18.3 Requiring a Specific Version of a Gem;
18.4 Uninstalling a Gem;
18.5 Reading Documentation for Installed Gems;
18.6 Packaging Your Code as a Gem;
18.7 Distributing Your Gems;
18.8 Installing and Creating Standalone Packages with setup.rb;
Chapter 19: Automating Tasks with Rake;
19.1 Automatically Running Unit Tests;
19.2 Automatically Generating Documentation;
19.3 Cleaning Up Generated Files;
19.4 Automatically Building a Gem;
19.5 Gathering Statistics About Your Code;
19.6 Publishing Your Documentation;
19.7 Running Multiple Tasks in Parallel;
19.8 A Generic Project Rakefile;
Chapter 20: Multitasking and Multithreading;
20.1 Running a Daemon Process on Unix;
20.2 Creating a Windows Service;
20.3 Doing Two Things at Once with Threads;
20.4 Synchronizing Access to an Object;
20.5 Terminating a Thread;
20.6 Running a Code Block on Many Objects Simultaneously;
20.7 Limiting Multithreading with a Thread Pool;
20.8 Driving an External Process with popen;
20.9 Capturing the Output and Error Streams from a Unix Shell Command;
20.10 Controlling a Process on Another Machine;
20.11 Avoiding Deadlock;
Chapter 21: User Interface;
21.1 ;
21.2 Getting Input One Line at a Time;
21.3 Getting Input One Character at a Time;
21.4 Parsing Command-Line Arguments;
21.5 Testing Whether a Program Is Running Interactively;
21.6 Setting Up and Tearing Down a Curses Program;
21.7 Clearing the Screen;
21.8 Determining Terminal Size;
21.9 Changing Text Color;
21.10 Reading a Password;
21.11 Allowing Input Editing with Readline;
21.12 Making Your Keyboard Lights Blink;
21.13 Creating a GUI Application with Tk;
21.14 Creating a GUI Application with wxRuby;
21.15 Creating a GUI Application with Ruby/GTK;
21.16 Creating a Mac OS X Application with RubyCocoa;
21.17 Using AppleScript to Get User Input;
Chapter 22: Extending Ruby with Other Languages;
22.1 Writing a C Extension for Ruby;
22.2 Using a C Library from Ruby;
22.3 Calling a C Library Through SWIG;
22.4 Writing Inline C in Your Ruby Code;
22.5 Using Java Libraries with JRuby;
Chapter 23: System Administration;
23.1 Scripting an External Program;
23.2 Managing Windows Services;
23.3 Running Code as Another User;
23.4 Running Periodic Tasks Without cron or at;
23.5 Deleting Files That Match a Regular Expression;
23.6 Renaming Files in Bulk;
23.7 Finding Duplicate Files;
23.8 Automating Backups;
23.9 Normalizing Ownership and Permissions in User Directories;
23.10 Killing All Processes for a Given User;
Colophon;

Read More Show Less

Customer Reviews

Average Rating 5
( 3 )
Rating Distribution

5 Star

(3)

4 Star

(0)

3 Star

(0)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing all of 3 Customer Reviews
  • Posted February 5, 2009

    Great Cookbook

    Published by acclaimed authors Lucas Carlson and Leonard Richardson, The Ruby Cookbook is an excellent learning tool and reference manual. It is organized into 23 chapters delineating all capabilities of the object-oriented scripting language. Each chapter is broken down into numerous subcategories describing operations, tips and tricks, common problems and their solutions, and other concepts pertaining to the topic of the chapter. Finding what you are looking for is not an issue since all topics are structured seamlessly.<BR/><BR/>Unlike many other programming books I have read, this one does not cut corners and overlook the menial steps experts, such as the authors themselves, would assume the reader to know intuitively. I find this aspect to be exceedingly beneficial in learning how the language behaves and what discrepancies may present themselves as a result of coding between a number of programming languages. While reading this book and learning the language, I had never been confused as a result of missing or vague information. The writing style is captivating, concise, and understandable. I enjoyed reading this book.<BR/><BR/>What I like most about this manual is that it is suited for newbies as well as experts. The introductory topics include the common data structures and how they are implemented, while the later chapters specify advanced functionality and extensions to the language. I recommend this book for all of those who have had some object-oriented programming experience as well as to those who have not but are interested in learning a computing language.

    Was this review helpful? Yes  No   Report this review
  • Posted January 29, 2009

    Ruby for beginners and experts

    Published by acclaimed authors Lucas Carlson and Leonard Richardson, The Ruby Cookbook is both an excellent learning tool and reference manual. It is organized into 23 chapters delineating all capabilities of the object-oriented scripting language. Each chapter is broken down into numerous subcategories describing operations, tips and tricks, common problems and their solutions, and other concepts pertaining to the topic of the chapter. Finding what you are looking for is not an issue since all topics are structured seamlessly.<BR/><BR/>Unlike many other programming books I have read, this one does not cut corners and overlook the menial steps experts, such as the authors themselves, would assume the reader to know intuitively. I find this aspect to be exceedingly beneficial in learning how the language behaves and what discrepancies may present themselves as a result of coding between a number of programming languages. While reading this book and learning the language, I had never been confused as a result of missing or vague information. The writing style is captivating, concise, and understandable. I enjoyed reading this book.<BR/><BR/>What I prefer most about the manual is that it is suited for newbies as well as experts. The introductory topics include the common data structures and how they are implemented, while the later chapters specify advanced functionality and extensions to the language. I recommend this book for all of those who have had some object-oriented programming experience as well as to those who have not but are interested in learning a computing language.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted February 25, 2007

    COOKING WITH RUBY!!

    Do you know just a little bit about Ruby? If you do, then this book is for you. Authors Lucas Carlson and Leonard Richardson, have done an outstanding job of writing a book that includes recipes suitable for all skill levels. Carlson and Richardson, begin by covering Ruby¿s built-in data structures and algorithmic problems. Then, the authors discuss the Ruby idiom and philosophy. Next, they explore popular ways of storing data. They also look at different types of applications. Finally, the authors cover the auxiliary tasks that surround the main programming work of a project. This most excellent book focuses mainly on generic programming techniques. Perhaps more importantly, this book covers specific application frameworks and best practices.

    Was this review helpful? Yes  No   Report this review
Sort by: Showing all of 3 Customer Reviews

If you find inappropriate content, please report it to Barnes & Noble
Why is this product inappropriate?
Comments (optional)