Ruby under a microscope An illustrated guide to ruby internals
Ruby Under a Microscope gives developers an inside, hands-on look at Ruby's core, using simple diagrams coupled with clear explanations.
| Autor principal: | |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
San Francisco :
No Starch Press
[2013]
|
| Edición: | 1st edition |
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009629501306719 |
Tabla de Contenidos:
- Intro
- Ruby Under a Microscope: An Illustrated Guide to Ruby Internals
- Dedication
- Advance Praise for Ruby under a Microscope
- About the Author
- Foreword
- Acknowledgments
- Introduction
- Who This Book Is For
- Using Ruby to Test Itself
- Which Implementation of Ruby?
- Overview
- 1. Tokenization and Parsing
- Tokens: The Words That Make Up the Ruby Language
- Experiment 1-1: Using Ripper to Tokenize Different Ruby Scripts
- Parsing: How Ruby Understands Your Code
- Understanding the LALR Parse Algorithm
- Some Actual Ruby Grammar Rules
- Experiment 1-2: Using Ripper to Parse Different Ruby Scripts
- Summary
- 2. Compilation
- No Compiler for Ruby 1.8
- Ruby 1.9 and 2.0 Introduce a Compiler
- How Ruby Compiles a Simple Script
- Compiling a Call to a Block
- Experiment 2-1: Displaying YARV Instructions
- The Local Table
- Compiling Optional Arguments
- Compiling Keyword Arguments
- Experiment 2-2: Displaying the Local Table
- Summary
- 3. How Ruby Executes Your Code
- YARV's Internal Stack and Your Ruby Stack
- Stepping Through How Ruby Executes a Simple Script
- Executing a Call to a Block
- Experiment 3-1: Benchmarking Ruby 2.0 and Ruby 1.9 vs. Ruby 1.8
- Local and Dynamic Access of Ruby Variables
- Local Variable Access
- Method Arguments Are Treated Like Local Variables
- Dynamic Variable Access
- Experiment 3-2: Exploring Special Variables
- Summary
- 4. Control Structures and Method Dispatch
- How Ruby Executes an if Statement
- Jumping from One Scope to Another
- Catch Tables
- Other Uses for Catch Tables
- Experiment 4-1: Testing How Ruby Implements for Loops Internally
- The send Instruction: Ruby's Most Complex Control Structure
- Method Lookup and Method Dispatch
- Eleven Types of Ruby Methods
- Calling Normal Ruby Methods
- Preparing Arguments for Normal Ruby Methods.
- Calling Built-In Ruby Methods
- Calling attr_reader and attr_writer
- Method Dispatch Optimizes attr_reader and attr_writer
- Experiment 4-2: Exploring How Ruby Implements Keyword Arguments
- Summary
- 5. Objects and Classes
- Inside a Ruby Object
- Inspecting klass and ivptr
- Visualizing Two Instances of One Class
- Generic Objects
- Simple Ruby Values Don't Require a Structure at All
- Do Generic Objects Have Instance Variables?
- Where Does Ruby Save Instance Variables for Generic Objects?
- Experiment 5-1: How Long Does It Take to Save a New Instance Variable?
- What's Inside the RClass Structure?
- Inheritance
- Class Instance Variables vs. Class Variables
- Getting and Setting Class Variables
- Constants
- The Actual RClass Structure
- Experiment 5-2: Where Does Ruby Save Class Methods?
- Summary
- 6. Method Lookup and Constant Lookup
- How Ruby Implements Modules
- Modules Are Classes
- Including a Module into a Class
- Ruby's Method Lookup Algorithm
- A Method Lookup Example
- The Method Lookup Algorithm in Action
- Multiple Inheritance in Ruby
- The Global Method Cache
- The Inline Method Cache
- Clearing Ruby's Method Caches
- Including Two Modules into One Class
- Including One Module into Another
- A Module#prepend Example
- How Ruby Implements Module#prepend
- Experiment 6-1: Modifying a Module After Including It
- Classes See Methods Added to a Module Later
- Classes Don't See Submodules Included Later
- Included Classes Share the Method Table with the Original Module
- Constant Lookup
- Finding a Constant in a Superclass
- How Does Ruby Find a Constant in the Parent Namespace?
- Lexical Scope in Ruby
- Creating a Constant for a New Class or Module
- Finding a Constant in the Parent Namespace Using Lexical Scope
- Ruby's Constant Lookup Algorithm.
- Experiment 6-2: Which Constant Will Ruby Find First?
- Ruby's Actual Constant Lookup Algorithm
- Summary
- 7. The Hash Table: The Workhorse of Ruby Internals
- Hash Tables in Ruby
- Saving a Value in a Hash Table
- Retrieving a Value from a Hash Table
- Experiment 7-1: Retrieving a Value from Hashes of Varying Sizes
- How Hash Tables Expand to Accommodate More Values
- Hash Collisions
- Rehashing Entries
- Experiment 7-2: Inserting One New Element into Hashes of Varying Sizes
- How Ruby Implements Hash Functions
- Experiment 7-3: Using Objects as Keys in a Hash
- Hash Optimization in Ruby 2.0
- Summary
- 8. How Ruby Borrowed a Decades-Old Idea from Lisp
- Blocks: Closures in Ruby
- Stepping Through How Ruby Calls a Block
- Borrowing an Idea from 1975
- Experiment 8-1: Which Is Faster: A while Loop or Passing a Block to each?
- Lambdas and Procs: Treating a Function as a First-Class Citizen
- Stack vs. Heap Memory
- A Closer Look at How Ruby Saves a String Value
- How Ruby Creates a Lambda
- How Ruby Calls a Lambda
- The Proc Object
- Experiment 8-2: Changing Local Variables After Calling lambda
- Calling lambda More Than Once in the Same Scope
- Summary
- 9. Metaprogramming
- Alternative Ways to Define Methods
- Ruby's Normal Method Definition Process
- Defining Class Methods Using an Object Prefix
- Defining Class Methods Using a New Lexical Scope
- Defining Methods Using Singleton Classes
- Defining Methods Using Singleton Classes in a Lexical Scope
- Creating Refinements
- Using Refinements
- Experiment 9-1: Who Am I? How self Changes with Lexical Scope
- self in the Top Scope
- self in a Class Scope
- self in a Metaclass Scope
- self Inside a Class Method
- Metaprogramming and Closures: eval, instance_eval, and binding
- Code That Writes Code
- Calling eval with binding
- An instance_eval Example.
- Another Important Part of Ruby Closures
- instance_eval Changes self to the Receiver
- instance_eval Creates a Singleton Class for a New Lexical Scope
- Experiment 9-2: Using a Closure to Define a Method
- Using define_method
- Methods Acting as Closures
- Summary
- 10. JRuby: Ruby on the JVM
- Running Programs with MRI and JRuby
- How JRuby Parses and Compiles Your Code
- How JRuby Executes Your Code
- Implementing Ruby Classes with Java Classes
- Experiment 10-1: Monitoring JRuby's Just-in-Time Compiler
- Experiment Code
- Using the -J-XX:+PrintCompilation Option
- Does JIT Speed Up Your JRuby Program?
- Strings in JRuby and MRI
- How JRuby and MRI Save String Data
- Copy-on-Write
- Experiment 10-2: Measuring Copy-on-Write Performance
- Creating a Unique, Nonshared String
- Experiment Code
- Visualizing Copy-on-Write
- Modifying a Shared String Is Slower
- Summary
- 11. Rubinius: Ruby Implemented with Ruby
- The Rubinius Kernel and Virtual Machine
- Tokenization and Parsing
- Using Ruby to Compile Ruby
- Rubinius Bytecode Instructions
- Ruby and C++ Working Together
- Implementing Ruby Objects with C++ Objects
- Experiment 11-1: Comparing Backtraces in MRI and Rubinius
- Backtraces in Rubinius
- Arrays in Rubinius and MRI
- Arrays Inside of MRI
- Arrays Inside of Rubinius
- Experiment 11-2: Exploring the Rubinius Implementation of Array#shift
- Reading Array#shift
- Modifying Array#shift
- Summary
- 12. Garbage Collection in MRI, JRuby, and Rubinius
- Garbage Collectors Solve Three Problems
- Garbage Collection in MRI: Mark and Sweep
- The Free List
- Marking
- How Does MRI Mark Live Objects?
- Sweeping
- Lazy Sweeping
- Disadvantages of Mark and Sweep
- Experiment 12-1: Seeing MRI Garbage Collection in Action
- Seeing MRI Perform a Lazy Sweep
- Seeing MRI Perform a Full Collection.
- Interpreting a GC Profile Report
- Garbage Collection in JRuby and Rubinius
- Copying Garbage Collection
- Bump Allocation
- The Semi-Space Algorithm
- The Eden Heap
- Generational Garbage Collection
- The Weak Generational Hypothesis
- Using the Semi-Space Algorithm for Young Objects
- Promoting Objects
- Garbage Collection for Mature Objects
- Concurrent Garbage Collection
- Marking While the Object Graph Changes
- Tricolor Marking
- Three Garbage Collectors in the JVM
- Experiment 12-2: Using Verbose GC Mode in JRuby
- Triggering Major Collections
- Further Reading
- Summary
- Index
- Copyright.
