Deep Vision Ruby… by Justin 'J' Lynn [Leanpub PDF/iPad/Kindle]
Deep Vision Ruby: Kinematics
Deep Vision Ruby: Kinematics
Deep Vision Ruby: Kinematics

This book is 2% complete

Last updated on 2014-01-12

About the Book

Deep Vision Ruby: Kinematics is for those who wish to understand Ruby front to back, inside and out, syntax to implementation. Deep Vision Ruby: Kinematics explores the symbiosis between language and runtime - the impact that design decisions made in one have on the other and vice versa. This is the book the author wishes they had when they were first introduced to Ruby and its community. Implementation details relate to the Canonical MRI (Matz's Ruby Interpreter) version 2.1.0p0.

Once purchased, access to github source code (for the manuscript as well as the code samples) will be granted if desired. Additionally, contributions and corrections may be accepted by pull request with credit given via the contributors listing.

Structure

  • Introduction
  • Prerequisites
  • A Bird's Eye View
  • A Short History of The Ruby Language and its Runtimes
  • The Ruby Runtime
    • The Canvas
      • The C Programming Language
      • The File System Source Layout
    • The Build Pipeline
      • Autotools
      • Make
      • GCC (The GNU Compiler Collection)
      • Miniruby
    • The Runtime Proper
      • Startup
        • Booting Up
        • Implementing Types
        • Initialising The Interpreter Machinery
          • Dual Stack Machine
        • Keeping Things Tidy
      • Execution
        • Understanding Ruby Source Code
          • Parsing
            • Lexical Analysis
              • Tokenisation
              • Parsing
              • Error Handling
            • Syntactic Analysis
              • Error Handling
            • Parse Tree Compilation
          • Compilation
            • Input Data Structures
            • Transformation
              • YARV Byte Code
                • Optimisation
            • Error Handling
        • Normal Operation
          • Bytecode Execution
          • Interrupts
            • Signals
          • Garbage Collection
            • Generational GC
          • Input and Output
          • Extensions
            • The Global Interpreter Lock
          • Security and Safety
          • Multitasking
            • Pre-emption
        • Underlying Operating System Interactions
          • Interrupts and Signals
          • Input and Output Operations
            • Storage and Network IO
            • Memory Services
        • Exceptions to Normal Flow Control
      • Shutdown
        • Signals
        • Clean up
          • Hooks and Callbacks
    • Colloquialisms and Conventions
  • Expanding the Runtime with Ruby Syntax and Functionality
    • Declarations
      • Truthyness
      • Operators
        • Functional Operators
          • Arithmetic
          • Comparison
          • Bitwise
          • Logical
            • Aliases
          • Ternary
          • Range
        • Assignments
          • Operators
        • Stateful Operators
          • Definition Presence Inquiry
        • Precedence and disambiguation
      • Reserved Words (Keywords)
      • Variables
        • Sigils
      • Composition of Operators into a Declaration
      • Colloquialisms and Conventions
    • Functions
      • Definitions
      • Execution Context
        • Name scope resolution
        • Reflection
        • The Call Stack
      • Input and Output
        • Side Effects
      • Applications
        • Recursion and Optimisation
      • Colloquialisms and Conventions
    • Objects and Encapsulated State
      • Closures
        • Name scope resolution
        • References and Values
      • Classes
        • Organisation
        • Instantiation
        • Modules
          • Namespaces
      • Mutation, Dependency and Inheritance
        • Hierarchy
          • Name scope resolution
        • Overriding Functionality
          • Operators
          • Dynamic Modification
          • Mix-ins (extends, prepend and include)
          • Refinements
      • Defining an API
        • By Enforcement
          • Public, Protected, and Private
        • By Convention
          • Documentation
          • Nested Classes and Modules
      • Colloquialisms and Conventions
    • Security and Safety
      • Preventing Unwanted Data Modification
      • Protecting Against Malicious Input
      • Sandboxing
    • Behaviours You Might Find Surprising That Matz Does Not
  • The Machine: A Language and Runtime Combination
    • Ruby Project Organisation
      • Namespaces
        • In Relationship to the File System
      • Library API Structure
      • Binaries and Executable Commands
      • Tooling
        • Packaging
        • Dependency Management
        • Testing and Specification
      • Colloquialisms and Conventions
    • Utilities and Documentation
      • Rake
      • RDoc/YARD
      • Ruby-Toolbox
    • Execution Trace - A Practical Annotated Example From 'execve' to 'exit(0)'
  • Epilogue
  • Colophon

Structure Under Active Construction

  • Introduction
  • A Bird's Eye View
  • Ruby Syntax and Functionality
    • Declarations
  • The Ruby Runtime
    • The Canvas
    • The Runtime Proper
  • Colophon

Completed Structures

This space intentionally left blank

  • Share this book

About the Author

Justin 'J' Lynn
Justin 'J' Lynn

Justin Lynn, known to his friends and colleagues as 'J', is a Co-founder and the Princpal Engineer at Infrastructory with several years of professional experience and a lifetime of interest in the art of designing, building, implementing, and running large software systems. His current environment of choice is GNU/Linux, for both server and desktop use. His programming language and community of choice for the last eight years has been Ruby and its ecosystem. As for system configuration tools he prefers Opscode Chef. On any given day you can find him fixing broken electronics, doing IT work, planning for the next expansion of his client's systems, working on his or other people's various open source projects, or indulging in a good book.

The Leanpub Unconditional, No Risk, 100% Happiness Guarantee

Within 45 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.
See full terms

Write and Publish on Leanpub

Authors and publishers use Leanpub to publish amazing in-progress and completed ebooks, just like this one. You can use Leanpub to write, publish and sell your book as well! Leanpub is a powerful platform for serious authors, combining a simple, elegant writing and publishing workflow with a store focused on selling in-progress ebooks. Leanpub is a magical typewriter for authors: just write in plain text, and to publish your ebook, just click a button. It really is that easy.

Learn more about writing on Leanpub