book

The Ruby Way: Solutions and Techniques in Ruby Programming, Third Edition

Name: The Ruby Way: Solutions and Techniques in Ruby Programming, Third Edition
ISBN: 9780132480352

by Hal Fulton, André Arko

March 2015

Intermediate to advanced

816 pages

22h 33m

English

Addison-Wesley Professional

Read now

Unlock full access

About This eBook
Title Page
Copyright Page
Praise for The Ruby Way, Third Edition
Praise for Previous Editions of The Ruby Way
Dedication Page
Contents
Foreword
Foreword to the Third EditionForeword to the Second EditionForeword to the First Edition
Acknowledgments
Acknowledgments for the Third EditionAcknowledgments for the Second EditionAcknowledgments for the First Edition
About the Authors

Introduction
About the Third EditionHow This Book WorksAbout the Book’s Source CodeWhat Is the “Ruby Way”?
Chapter 1. Ruby in Review
1.1 An Introduction to Object Orientation1.1.1 What Is an Object?1.1.2 Inheritance1.1.3 Polymorphism1.1.4 A Few More Terms1.2 Basic Ruby Syntax and Semantics1.2.1 Keywords and Identifiers1.2.2 Comments and Embedded Documentation1.2.3 Constants, Variables, and Types1.2.4 Operators and Precedence1.2.5 A Sample Program1.2.6 Looping and Branching1.2.7 Exceptions1.3 OOP in Ruby1.3.1 Objects1.3.2 Built-in Classes1.3.3 Modules and Mixins1.3.4 Creating Classes1.3.5 Methods and Attributes1.4 Dynamic Aspects of Ruby1.4.1 Coding at Runtime1.4.2 Reflection1.4.3 Missing Methods1.4.4 Garbage Collection1.5 Training Your Intuition: Things to Remember1.5.1 Syntax Issues1.5.2 Perspectives in Programming1.5.3 Ruby’s case Statement1.5.4 Rubyisms and Idioms1.5.5 Expression Orientation and Other Miscellaneous Issues1.6 Ruby Jargon and Slang1.7 Conclusion
Chapter 2. Working with Strings
2.1 Representing Ordinary Strings2.2 Representing Strings with Alternate Notations2.3 Using Here-Documents2.4 Finding the Length of a String2.5 Processing a Line at a Time2.6 Processing a Character or Byte at a Time2.7 Performing Specialized String Comparisons2.8 Tokenizing a String2.9 Formatting a String2.10 Using Strings as IO Objects2.11 Controlling Uppercase and Lowercase2.12 Accessing and Assigning Substrings2.13 Substituting in Strings2.14 Searching a String2.15 Converting Between Characters and ASCII Codes2.16 Implicit and Explicit Conversion2.17 Appending an Item onto a String2.18 Removing Trailing Newlines and Other Characters2.19 Trimming Whitespace from a String2.20 Repeating Strings2.21 Embedding Expressions within Strings2.22 Delayed Interpolation of Strings2.23 Parsing Comma-Separated Data2.24 Converting Strings to Numbers (Decimal and Otherwise)2.25 Encoding and Decoding rot13 Text2.26 Encrypting Strings2.27 Compressing Strings2.28 Counting Characters in Strings2.29 Reversing a String2.30 Removing Duplicate Characters2.31 Removing Specific Characters2.32 Printing Special Characters2.33 Generating Successive Strings2.34 Calculating a 32-Bit CRC2.35 Calculating the SHA-256 Hash of a String2.36 Calculating the Levenshtein Distance Between Two Strings2.37 Encoding and Decoding Base64 Strings2.38 Expanding and Compressing Tab Characters2.39 Wrapping Lines of Text2.40 Conclusion
Chapter 3. Working with Regular Expressions
3.1 Regular Expression Syntax3.2 Compiling Regular Expressions3.3 Escaping Special Characters3.4 Using Anchors3.5 Using Quantifiers3.6 Positive and Negative Lookahead3.7 Positive and Negative Lookbehind3.8 Accessing Backreferences3.9 Named Matches3.10 Using Character Classes3.11 Extended Regular Expressions3.12 Matching a Newline with a Dot3.13 Using Embedded Options3.14 Using Embedded Subexpressions3.14.1 Recursion in Regular Expressions3.15 A Few Sample Regular Expressions3.15.1 Matching an IP Address3.15.2 Matching a Keyword-Value Pair3.15.3 Matching Roman Numerals3.15.4 Matching Numeric Constants3.15.5 Matching a Date/Time String3.15.6 Detecting Doubled Words in Text3.15.7 Matching All-Caps Words3.15.8 Matching Version Numbers3.15.9 A Few Other Patterns3.16 Conclusion
Chapter 4. Internationalization in Ruby
4.1 Background and Terminology4.2 Working with Character Encodings4.2.1 Normalization4.2.2 Encoding Conversions4.2.3 Transliteration4.2.4 Collation4.3 Translations4.3.1 Defaults4.3.2 Namespaces4.3.3 Interpolation4.3.4 Pluralization4.4 Localized Formatting4.4.1 Dates and Times4.4.2 Numbers4.4.3 Currencies4.5 Conclusion
Chapter 5. Performing Numerical Calculations
5.1 Representing Numbers in Ruby5.2 Basic Operations on Numbers5.3 Rounding Floating Point Values5.4 Comparing Floating Point Numbers5.5 Formatting Numbers for Output5.6 Formatting Numbers with Commas5.7 Working with Very Large Integers5.8 Using BigDecimal5.9 Working with Rational Values5.10 Matrix Manipulation5.11 Working with Complex Numbers5.12 Using mathn5.13 Finding Prime Factorization, GCD, and LCM5.14 Working with Prime Numbers5.15 Implicit and Explicit Numeric Conversion5.16 Coercing Numeric Values5.17 Performing Bit-Level Operations on Numbers5.18 Performing Base Conversions5.19 Finding Cube Roots, Fourth Roots, and So On5.20 Determining the Architecture’s Byte Order5.21 Numerical Computation of a Definite Integral5.22 Trigonometry in Degrees, Radians, and Grads5.23 Finding Logarithms with Arbitrary Bases5.24 Finding the Mean, Median, and Mode of a Data Set5.25 Variance and Standard Deviation5.26 Finding a Correlation Coefficient5.27 Generating Random Numbers5.28 Caching Functions with Memoization5.29 Conclusion
Chapter 6. Symbols and Ranges
6.1 Symbols6.1.1 Symbols as Enumerations6.1.2 Symbols as Metavalues6.1.3 Symbols, Variables, and Methods6.1.4 Converting to/from Symbols6.2 Ranges6.2.1 Open and Closed Ranges6.2.2 Finding Endpoints6.2.3 Iterating Over Ranges6.2.4 Testing Range Membership6.2.5 Converting to Arrays6.2.6 Backward Ranges6.2.7 The Flip-Flop Operator6.2.8 Custom Ranges6.3 Conclusion
Chapter 7. Working with Times and Dates
7.1 Determining the Current Time7.2 Working with Specific Times (Post-Epoch)7.3 Determining the Day of the Week7.4 Determining the Date of Easter7.5 Finding the Nth Weekday in a Month7.6 Converting Between Seconds and Larger Units7.7 Converting to and from the Epoch7.8 Working with Leap Seconds: Don’t!7.9 Finding the Day of the Year7.10 Validating a Date or Time7.11 Finding the Week of the Year7.12 Detecting Leap Years7.13 Obtaining the Time Zone7.14 Working with Hours and Minutes Only7.15 Comparing Time Values7.16 Adding Intervals to Time Values7.17 Computing the Difference in Two Time Values7.18 Working with Specific Dates (Pre-Epoch)7.19 Time, Date, and DateTime7.20 Parsing a Date or Time String7.21 Formatting and Printing Time Values7.22 Time Zone Conversions7.23 Determining the Number of Days in a Month7.24 Dividing a Month into Weeks7.25 Conclusion
Chapter 8. Arrays, Hashes, and Other Enumerables
8.1 Working with Arrays8.1.1 Creating and Initializing an Array8.1.2 Accessing and Assigning Array Elements8.1.3 Finding an Array’s Size8.1.4 Comparing Arrays8.1.5 Sorting an Array8.1.6 Selecting from an Array by Criteria8.1.7 Using Specialized Indexing Functions8.1.8 Implementing a Sparse Matrix8.1.9 Using Arrays as Mathematical Sets8.1.10 Randomizing an Array8.1.11 Using Multidimensional Arrays8.1.12 Finding Elements in One Array But Not Another8.1.13 Transforming or Mapping Arrays8.1.14 Removing nil Values from an Array8.1.15 Removing Specific Array Elements8.1.16 Concatenating and Appending onto Arrays8.1.17 Using an Array as a Stack or Queue8.1.18 Iterating over an Array8.1.19 Interposing Delimiters to Form a String8.1.20 Reversing an Array8.1.21 Removing Duplicate Elements from an Array8.1.22 Interleaving Arrays8.1.23 Counting Frequency of Values in an Array8.1.24 Inverting an Array to Form a Hash8.1.25 Synchronized Sorting of Multiple Arrays8.1.26 Establishing a Default Value for New Array Elements8.2 Working with Hashes8.2.1 Creating a New Hash8.2.2 Specifying a Default Value for a Hash8.2.3 Accessing and Adding Key-Value Pairs8.2.4 Deleting Key-Value Pairs8.2.5 Iterating Over a Hash8.2.6 Inverting a Hash8.2.7 Detecting Keys and Values in a Hash8.2.8 Extracting Hashes into Arrays8.2.9 Selecting Key-Value Pairs by Criteria8.2.10 Sorting a Hash8.2.11 Merging Two Hashes8.2.12 Creating a Hash from an Array8.2.13 Finding Difference or Intersection of Hash Keys8.2.14 Using a Hash as a Sparse Matrix8.2.15 Implementing a Hash with Duplicate Keys8.2.16 Other Hash Operations8.3 Enumerables in General8.3.1 The inject Method8.3.2 Using Quantifiers8.3.3 The partition Method8.3.4 Iterating by Groups8.3.5 Converting to Arrays or Sets8.3.6 Using Enumerator Objects8.4 More on Enumerables8.4.1 Searching and Selecting8.4.2 Counting and Comparing8.4.3 Iterating8.4.4 Extracting and Converting8.4.5 Lazy Enumerators8.5 Conclusion
Chapter 9. More Advanced Data Structures
9.1 Working with Sets9.1.1 Simple Set Operations9.1.2 More Advanced Set Operations9.2 Working with Stacks and Queues9.2.1 Implementing a Stricter Stack9.2.2 Detecting Unbalanced Punctuation in Expressions9.2.3 Understanding Stacks and Recursion9.2.4 Implementing a Stricter Queue9.3 Working with Trees9.3.1 Implementing a Binary Tree9.3.2 Sorting Using a Binary Tree9.3.3 Using a Binary Tree as a Lookup Table9.3.4 Converting a Tree to a String or Array9.4 Working with Graphs9.4.1 Implementing a Graph as an Adjacency Matrix9.4.2 Determining Whether a Graph Is Fully Connected9.4.3 Determining Whether a Graph Has an Euler Circuit9.4.4 Determining Whether a Graph Has an Euler Path9.4.5 Graph Tools in Ruby9.5 Conclusion
Chapter 10. I/O and Data Storage
10.1 Working with Files and Directories10.1.1 Opening and Closing Files10.1.2 Updating a File10.1.3 Appending to a File10.1.4 Random Access to Files10.1.5 Working with Binary Files10.1.6 Locking Files10.1.7 Performing Simple I/O10.1.8 Performing Buffered and Unbuffered I/O10.1.9 Manipulating File Ownership and Permissions10.1.10 Retrieving and Setting Timestamp Information10.1.11 Checking File Existence and Size10.1.12 Checking Special File Characteristics10.1.13 Working with Pipes10.1.14 Performing Special I/O Operations10.1.15 Using Nonblocking I/O10.1.16 Using readpartial10.1.17 Manipulating Pathnames10.1.18 Using the Pathname Class10.1.19 Command-Level File Manipulation10.1.20 Grabbing Characters from the Keyboard10.1.21 Reading an Entire File into Memory10.1.22 Iterating Over a File by Lines10.1.23 Iterating Over a File by Byte or Character10.1.24 Treating a String As a File10.1.25 Copying a Stream10.1.26 Working with Character Encodings10.1.27 Reading Data Embedded in a Program10.1.28 Reading Program Source10.1.29 Working with Temporary Files10.1.30 Changing and Setting the Current Directory10.1.31 Changing the Current Root10.1.32 Iterating Over Directory Entries10.1.33 Getting a List of Directory Entries10.1.34 Creating a Chain of Directories10.1.35 Deleting a Directory Recursively10.1.36 Finding Files and Directories10.2 Higher-Level Data Access10.2.1 Simple Marshaling10.2.2 “Deep Copying” with Marshal10.2.3 More Complex Marshaling10.2.4 Marshaling with YAML10.2.5 Persisting Data with JSON10.2.6 Working with CSV Data10.2.7 SQLite3 for SQL Data Storage10.3 Connecting to External Data Stores10.3.1 Connecting to MySQL Databases10.3.2 Connecting to PostgreSQL Databases10.3.3 Object-Relational Mappers (ORMs)10.3.4 Connecting to Redis Data Stores10.4 Conclusion
Chapter 11. OOP and Dynamic Features in Ruby
11.1 Everyday OOP Tasks11.1.1 Using Multiple Constructors11.1.2 Creating Instance Attributes11.1.3 Using More Elaborate Constructors11.1.4 Creating Class-Level Attributes and Methods11.1.5 Inheriting from a Superclass11.1.6 Testing Classes of Objects11.1.7 Testing Equality of Objects11.1.8 Controlling Access to Methods11.1.9 Copying an Object11.1.10 Using initialize_copy11.1.11 Understanding allocate11.1.12 Working with Modules11.1.13 Transforming or Converting Objects11.1.14 Creating Data-Only Classes (Structs)11.1.15 Freezing Objects11.1.16 Using tap in Method Chaining11.2 More Advanced Techniques11.2.1 Sending an Explicit Message to an Object11.2.2 Specializing an Individual Object11.2.3 Nesting Classes and Modules11.2.4 Creating Parametric Classes11.2.5 Storing Code as Proc Objects11.2.6 Storing Code as Method Objects11.2.7 Using Symbols as Blocks11.2.8 How Module Inclusion Works11.2.9 Detecting Default Parameters11.2.10 Delegating or Forwarding11.2.11 Defining Class-Level Readers and Writers11.2.12 Working in Advanced Programming Disciplines11.3 Working with Dynamic Features11.3.1 Evaluating Code Dynamically11.3.2 Retrieving a Constant by Name11.3.3 Retrieving a Class by Name11.3.4 Using define_method11.3.5 Obtaining Lists of Defined Entities11.3.6 Removing Definitions11.3.7 Handling References to Nonexistent Constants11.3.8 Handling Calls to Nonexistent Methods11.3.9 Improved Security with taint11.3.10 Defining Finalizers for Objects11.4 Program Introspection11.4.1 Traversing the Object Space11.4.2 Examining the Call Stack11.4.3 Tracking Changes to a Class or Object Definition11.4.4 Monitoring Program Execution11.5 Conclusion
Chapter 12. Graphical Interfaces for Ruby
12.1 Shoes 412.1.1 Starting Out with Shoes12.1.2 An Interactive Button12.1.3 Text and Input12.1.4 Layout12.1.5 Images and Shapes12.1.6 Events12.1.7 Other Notes12.2 Ruby/Tk12.2.1 Overview12.2.2 A Simple Windowed Application12.2.3 Working with Buttons12.2.4 Working with Text Fields12.2.5 Working with Other Widgets12.2.6 Other Notes12.3 Ruby/GTK312.3.1 Overview12.3.2 A Simple Windowed Application12.3.3 Working with Buttons12.3.4 Working with Text Fields12.3.5 Working with Other Widgets12.3.6 Other Notes12.4 QtRuby12.4.1 Overview12.4.2 A Simple Windowed Application12.4.3 Working with Buttons12.4.4 Working with Text Fields12.4.5 Working with Other Widgets12.4.6 Other Notes12.5 Swing12.6 Other GUI Toolkits12.6.1 UNIX and X1112.6.2 FXRuby (FOX)12.6.3 RubyMotion for iOS and Mac OS X12.6.4 The Windows Win32API12.7 Conclusion
Chapter 13. Threads and Concurrency
13.1 Creating and Manipulating Threads13.1.1 Creating Threads13.1.2 Accessing Thread-Local Variables13.1.3 Querying and Changing Thread Status13.1.4 Achieving a Rendezvous (and Capturing a Return Value)13.1.5 Dealing with Exceptions13.1.6 Using a Thread Group13.2 Synchronizing Threads13.2.1 Performing Simple Synchronization13.2.2 Synchronizing Access with a Mutex13.2.3 Using the Built-in Queue Classes13.2.4 Using Condition Variables13.2.5 Other Synchronization Techniques13.2.6 Setting a Timeout for an Operation13.2.7 Waiting for an Event13.2.8 Collection Searching in Parallel13.2.9 Recursive Deletion in Parallel13.3 Fibers and Cooperative Multitasking13.4 Conclusion
Chapter 14. Scripting and System Administration
14.1 Running External Programs14.1.1 Using system and exec14.1.2 Capturing Command Output14.1.3 Manipulating Processes14.1.4 Manipulating Standard Input and Output14.2 Command-Line Options and Arguments14.2.1 Working with ARGV14.2.2 Working with ARGF14.2.3 Parsing Command-Line Options14.3 The Shell Library14.3.1 Using Shell for I/O Redirection14.3.2 Other Notes on Shell14.4 Accessing Environment Variables14.4.1 Getting and Setting Environment Variables14.4.2 Storing Environment Variables as an Array or Hash14.5 Working with Files, Directories, and Trees14.5.1 A Few Words on Text Filters14.5.2 Copying a Directory Tree14.5.3 Deleting Files by Age or Other Criteria14.5.4 Determining Free Space on a Disk14.6 Other Scripting Tasks14.6.1 Distributing Ruby Programs14.6.2 Piping into the Ruby Interpreter14.6.3 Testing Whether a Program Is Running Interactively14.6.4 Determining the Current Platform or Operating System14.6.5 Using the Etc Module14.7 Conclusion
Chapter 15. Ruby and Data Formats
15.1 Parsing JSON15.1.1 Navigating JSON Data15.1.2 Handling Non-JSON Data Types15.1.3 Other JSON Libraries15.2 Parsing XML (and HTML)15.2.1 Document Parsing15.2.2 Stream Parsing15.3 Working with RSS and Atom15.3.1 Parsing Feeds15.3.2 Generating Feeds15.4 Manipulating Image Data with RMagick15.4.1 Common Graphics Tasks15.4.2 Special Effects and Transformations15.4.3 The Drawing API15.5 Creating PDF Documents with Prawn15.5.1 Basic Concepts and Techniques15.5.2 An Example Document15.6 Conclusion
Chapter 16. Testing and Debugging
16.1 Testing with RSpec16.2 Testing with Minitest16.3 Testing with Cucumber16.4 Using the byebug Debugger16.5 Using pry for Debugging16.6 Measuring Performance16.7 Pretty-Printing Objects16.8 Not Covered Here16.9 Conclusion
Chapter 17. Packaging and Distributing Code
17.1 Libraries and Rubygems17.1.1 Using Rubygems17.1.2 Creating Gems17.2 Managing Dependencies with Bundler17.2.1 Semantic Versioning17.2.2 Dependencies from Git17.2.3 Creating Gems with Bundler17.2.4 Private Gems17.3 Using RDoc17.3.1 Simple Markup17.3.2 Advanced Documentation with Yard17.4 Conclusion
Chapter 18. Network Programming
18.1 Network Servers18.1.1 A Simple Server: Time of Day18.1.2 Implementing a Threaded Server18.1.3 Case Study: A Peer-to-Peer Chess Server18.2 Network Clients18.2.1 Retrieving Truly Random Numbers from the Web18.2.2 Contacting an Official Timeserver18.2.3 Interacting with a POP Server18.2.4 Sending Mail with SMTP18.2.5 Interacting with an IMAP Server18.2.6 Encoding/Decoding Attachments18.2.7 Case Study: A Mail-News Gateway18.2.8 Retrieving a Web Page from a URL18.2.9 Using the Open-URI Library18.3 Conclusion
Chapter 19. Ruby and Web Applications
19.1 HTTP Servers19.1.1 A Simple HTTP Server19.1.2 Rack and Web Servers19.2 Application Frameworks19.2.1 Routing in Sinatra19.2.2 Routing in Rails19.2.3 Parameters in Sinatra19.2.4 Parameters in Rails19.3 Storing Data19.3.1 Databases19.3.2 Data Stores19.4 Generating HTML19.4.1 ERB19.4.2 Haml19.4.3 Other Templating Systems19.5 The Asset Pipeline19.5.1 CSS and Sass19.5.2 JavaScript and CoffeeScript19.6 Web Services via HTTP19.6.1 JSON for APIs19.6.2 REST (and REST-ish) APIs19.7 Generating Static Sites19.7.1 Middleman19.7.2 Other Static Site Generators19.8 Conclusion
Chapter 20. Distributed Ruby
20.1 An Overview: Using drb20.2 Case Study: A Stock Ticker Simulation20.3 Rinda: A Ruby Tuplespace20.4 Service Discovery with Distributed Ruby20.5 Conclusion
Chapter 21. Ruby Development Tools
21.1 Using Rake21.2 Using irb21.3 The Basics of pry21.4 The ri Utility21.5 Editor Support21.5.1 Vim21.5.2 Emacs21.6 Ruby Version Managers21.6.1 Using rvm21.6.2 Using rbenv21.6.3 Using chruby21.7 Conclusion
Chapter 22. The Ruby Community
22.1 Web Resources22.2 Mailing Lists, Podcasts, and Forums22.3 Ruby Bug Reports and Feature Requests22.4 IRC Channels22.5 Ruby Conferences22.6 Local Ruby Groups22.7 Conclusion
Index
Code Snippets

Overview

For more than a decade, Ruby developers have turned to The Ruby Way for reliable “how-to” guidance on effective Ruby programming. Now, Hal Fulton and André Arko have thoroughly updated this classic guide to cover new language enhancements and developers’ experiences through Ruby 2.1.

The new edition illuminates Ruby 2.1 through 400+ examples, each answering the question: “How do I do this in Ruby?” For each example, they present both a task description and realistic technical constraints. Next, they walk step-by-step through presenting one good solution, offering detailed explanations to promote deeper understanding.

Conveniently organized by topic, The Ruby Way, Third Edition makes it easier than ever to find the specific solution you want—and to write better code by reflecting Ruby’s unique philosophy and spirit.

Coverage includes

Ruby 2.1 overview: terminology, philosophy, and basic principles

Best practices for strings and regular expressions

Efficiently internationalizing your code

Performing calculations (including trigonometry, calculus, statistics, and time/date calculations)

Working with “Rubyesque” objects such as symbols and ranges

Using arrays, hashes, stacks, queues, trees, graphs, and other data structures

Efficiently storing data with YAML, JSON, and SQLite3

Leveraging object-oriented and dynamic features, from multiple constructors to program inspection

Building GUIs with Shoes 4, Ruby/Tk, Ruby/GTK3, QtRuby, and other toolkits

Improving thread performance by understanding Ruby’s synchronization methods and avoiding its pitfalls

Automating system administration with Ruby

Data formats: JSON, XML, RSS, Atom, RMagick, PDF, and more

Testing and debugging with RSpec, Minitest, Cucumber, byebug, and pry

Measuring Ruby program performance

Packaging and distributing code, and managing dependencies with Bundler

Network programming: clients, time servers, POP, SMTP, IMAP, Open-URI

Web applications: HTTP servers, Rails, Sinatra, HTML generation, and more

Writing distributed Ruby software with drb

Choosing modern development tools that maximize your productivity

All source code for this book may be downloaded at www.rubyhacker.com.

informit.com/aw

informit.com/ruby

rubyhacker.com/therubyway

therubyway.io

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

The Ruby Way: Solutions and Techniques in Ruby Programming, Second Edition

Publisher Resources

ISBN: 9780132480352Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills