Programming Ruby 4 (6th edition)

The Pragmatic Programmers' Guide

by Noel Rappin with Dave Thomas

Learn Ruby from the sixth edition of the book that first introduced Matz’s amazing language to the world, and that has taught hundreds of thousands of developers since. Updated to include all the new Ruby 4 features, this is the book to get to learn Ruby, and to stay up-to-date as Ruby evolves.

Ruby is a fully object-oriented programming language and one of the most important programming languages for web development. It powers the Rails framework, which backs some of the most high-traffic sites on the web. This updated edition of The Pickaxe Book is a comprehensive guide to the language through Ruby 4.0. This definitive Ruby reference contains a tutorial for learning the Ruby language from scratch, an introduction to the most widely used third-party tools, and a guide to the most valuable parts of the Ruby standard library.

Ruby is a language designed for programmer happiness. It enables you to express your business logic clearly and succinctly, going from your first idea to working code quickly and confidently. Ruby also powers the Rails web framework, and learning Ruby completely can help you more fully unlock Rails’ power to build amazing things.

This book contains a comprehensive Ruby tutorial starting with the basics of Ruby through its logic, its object model, and all the way to its most advanced metaprogramming capabilities. Ruby’s standard library contains dozens of useful classes; The Pickaxe Book guides you to the most valuable features. You’ll discover the most important tools in Ruby’s extensive ecosystem, including testing, project management, web development, documentation, and much more. This updated edition includes all the new and changed syntax and semantics introduced through Ruby 4.0.

Ruby is a fully object-oriented language. The combination of the power of a pure object-oriented language with the convenience of a scripting language makes Ruby a favorite tool of programmers who want to get things done quickly and cleanly. Wherever you are in your Ruby knowledge, Programming Ruby is your complete guide to fully realizing the power of Ruby.

What You Need

Resources

• Source Code (zip file)

Releases:

Contents & Extracts

Note: Contents and extracts of beta books will change as the book is developed.

Table of Contents

• Facets of Ruby
  • Getting Started
    • Installing Ruby
    • Installing Ruby for Windows
    • Running Ruby
    • Creating Ruby Programs
    • Getting More Information about Ruby
    • What’s Next
  • Ruby.new
    • Ruby Is an Object-Oriented Language
    • Some Basic Ruby
    • Arrays and Hashes
    • Symbols
    • Control Structures
    • Regular Expressions
    • Blocks
    • Reading and ‘Riting
    • Command-Line Arguments
    • Commenting Ruby
    • What’s Next
  • Classes, Objects, and Variables
    • Defining Classes
    • Objects and Attributes
    • Classes Working with Other Classes
    • Specifying Access Control
    • Variables
    • Reopening Classes
    • What’s Next
  • Collections, Blocks, and Iterators
    • Arrays
    • Hashes
    • Digging
    • Word Frequency: Using Hashes and Arrays
    • Blocks and Enumeration
    • What’s Next
  • More about Methods
    • Defining a Method
    • Calling a Method
    • What’s Next
  • Sharing Functionality: Inheritance, Modules, and :q
    Mixins
    • Inheritance and Messages
    • Modules
    • Inheritance, Mixins, and Design
    • What’s Next
  • Basic Types: Numbers, Strings, and Ranges
    • Numbers
    • Strings
    • Ranges
    • What’s Next
  • Regular Expressions
    • What Regular Expressions Let You Do
    • Creating and Using Regular Expressions
    • Regular Expression Patterns
    • Regular Expression Syntax
    • What’s Next
  • Expressions
    • Operator Expressions
    • Command Expressions
    • Assignment
    • Conditional Execution
    • Loops and Iterators
    • Pattern Matching
    • What’s Next
  • Exceptions
    • The Exception Class
    • Handling Exceptions
    • Raising Exceptions
    • Using Catch and Throw
    • What’s Next
  • Basic Input and Output
    • What Is an I/O Object?
    • Opening and Closing Files
    • Reading and Writing Files
    • Talking to Networks
    • What’s Next
  • Threads, Fibers, and Ractors
    • Multithreading with Threads
    • Running Multiple External Processes
    • Creating Fibers
    • Async and Concurrent Ruby
    • Understanding Ractors
    • What’s Next
  • Testing Ruby Code
    • Why Unit Test?
    • Testing with Minitest
    • Structuring Tests
    • Creating Mock Objects in Minitest
    • Organizing and Running Tests
    • Testing with RSpec
    • What’s Next
• Ruby in Its Setting
  • Ruby from the Command Line
    • Calling the Ruby Command
    • Ruby Command-Line Options
    • Making Your Code an Executable Program
    • Processing Command-Line Arguments to Your Code
    • Accessing Environment Variables
    • Where Ruby Finds Its Libraries
    • Using the Rake Build Tool
    • The Build Environment
    • What’s Next
  • Ruby Gems
    • Installing and Managing Gems
    • Using Bundler to Manage Groups of Gems
    • Writing and Packaging Your Own Code into Gems
    • Organizing Your Source Code
    • Distributing and Installing Your Code
    • What’s Next
  • Interactive Ruby
    • Using irb
    • Navigating irb
    • Configuring irb
    • What’s Next
  • Debugging Ruby
    • Printing Things
    • The Ruby Debugger
    • Pry
    • Debugging Performance Issues with Benchmark
    • What’s Next
  • Typed Ruby
    • What’s a Type?
    • Official Ruby Typing with RBS
    • Ruby Typing with Sorbet
    • Literal Ruby
    • What’s Next
  • Documenting Ruby
    • Documenting with RDoc
    • Adding RDoc to Ruby Code
    • Running RDoc
    • Documenting with YARD
    • What’s Next
• Ruby Crystallized
  • Ruby and the Web
    • CGI Encoding
    • Templating with ERB
    • Serving Ruby Code to the Web
    • Ruby in the Browser with Web Assembly
    • What’s Next
  • Ruby Style
    • Written Ruby Style
    • Using RuboCop
    • Using Standard
    • Ruby Style in the Large
    • Duck Typing
    • What’s Next
  • The Ruby Object Model and Metaprogramming
    • Understanding Objects and Classes
    • Defining Singleton Methods
    • Inheritance and Visibility
    • Modules and Mixins
    • Putting Code in a Ruby Box
    • Metaprogramming Class-Level Macros
    • Using instance_eval and class_eval
    • Using Hook Methods
    • A Metaprogramming Example
    • Top-Level Execution Environment
    • What’s Next
  • Reflection and Object Space
    • 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
    • What’s Next
• Ruby Language Reference
  • Language Reference: Literal Types and Expressions
    • Source Layout
    • Ruby Literals
    • Regular Expressions
    • Names
    • Values, Variables, and Constants
    • Expressions, Conditionals, and Loops
  • Language Reference: Objects and Classes
    • Method Definition
    • Invoking a Method
    • Aliasing
    • Defining Classes
    • Defining Modules
    • Access Control
    • Blocks, Closures, and Proc Objects
    • Exceptions
    • Catch and Throw
    • Typed Ruby
• Ruby Library Reference
  • Library Reference: Core Data Types
    • Dates and Times
    • Math
    • Numbers
    • Random and SecureRandom
    • Regexp
    • Strings
    • Symbols
  • Library Reference: Ruby’s Object Model
    • BasicObject
    • Class
    • Comparable
    • Kernel
    • Method
    • Module
    • Object
  • Library Reference: Enumerators and Containers
    • Array
    • Enumerable
    • Enumerator
    • Hash
    • Set
  • Library Reference: Input, Output, Files, and Formats
    • CSV
    • Dir
    • File
    • FileUtils
    • IO
    • JSON
    • Pathname
    • StringIO
    • Tempfile
    • URI
    • YAML
  • Library Reference: Ruby on Ruby
    • Benchmark
    • Data
    • Delegator and SimpleDelegator
    • Logger
    • ObjectSpace
    • Observable
    • OpenStruct
    • PP
    • Prism
    • Ripper
    • Singleton
    • Struct
    • Unbound Method
• Appendixes
  • Troubleshooting Ruby
    • Common Issues
    • Debugging Tips
  • I Can’t Look It Up!
  • Command-Line Basics
    • The Command Prompt
    • Folders, Directories, and Navigation
  • Ruby Runtimes
    • Just-in-Time Compilers
    • TruffleRuby
    • JRuby
    • mRuby
    • Other Runtimes

Author