The Well-Grounded Rubyist, 2nd Ed, video edition

Video description

"Once again, the definitive book on Ruby from David Black. A must-have!"
William Wheeler, TekSystems

The Well-Grounded Rubyist, Second Edition addresses both newcomers to Ruby as well as Ruby programmers who want to deepen their understanding of the language. This beautifully written tutorial begins with your first Ruby program and goes on to explore sophisticated topics like callable objects, reflection, and threading. It concentrates on the language, preparing you to use Ruby in any way you choose. This edition includes coverage of Ruby features such as keyword arguments, lazy enumerators, and Module#prepend.

This is a good time for Ruby! It's powerful like Java or C++, and has dynamic features that let your code react gracefully to changes at runtime. And it's elegant, so creating applications, development tools, and administrative scripts is easier and more straightforward. With an active development community and countless libraries and productivity tools, Ruby has come into its own.
Inside:

  • Clear explanations of Ruby concepts
  • Numerous simple examples
  • Updated for Ruby 2.1
  • Prepares you to use Ruby anywhere for any purpose

David A. Black is an internationally known Ruby developer, author, trainer, speaker, event organizer, and founder of Ruby Central, as well as a Lead Consultant at Cyrus Innovation.

All wheat, no chaff—takes you from Ruby programmer to full-fledged Rubyist.
Doug Sparling, Andrews McMeel Universal

Provides powerful insights and digs into Ruby’s quirks. Revelatory.
Ted Roche, Ted Roche & Associates, LLC

The best way to learn Ruby fundamentals.
Derek Sivers, sivers.org

NARRATED BY MARK THOMAS

Table of contents

  1. PART 1 RUBY FOUNDATIONS
    1. Chapter 1. Bootstrapping your Ruby literacy
    2. Chapter 1. The variety of Ruby identifiers
    3. Chapter 1. Method calls, messages, and Ruby objects
    4. Chapter 1. Writing and saving a simple program
    5. Chapter 1. Anatomy of the Ruby installation
    6. Chapter 1. Ruby extensions and programming libraries
    7. Chapter 1. Out-of-the-box Ruby tools and applications
    8. Chapter 1. A closer look at interactive Ruby interpretation with irb
    9. Chapter 1. The rake task-management utility
    10. Chapter 2. Objects, methods, and local variables
    11. Chapter 2. Creating a generic object
    12. Chapter 2. Crafting an object: The behavior of a ticket
    13. Chapter 2. The innate behaviors of an object
    14. Chapter 2. A close look at method arguments
    15. Chapter 2. Order of parameters and arguments
    16. Chapter 2. Local variables and variable assignment
    17. Chapter 2. References in variable assignment and reassignment
    18. Chapter 2. Local variables and the things that look like them
    19. Chapter 3. Organizing objects with classes
    20. Chapter 3. Overriding methods
    21. Chapter 3. Instance variables and object state
    22. Chapter 3. Setter methods
    23. Chapter 3. Attributes and the attr_* method family
    24. Chapter 3. Inheritance and the Ruby class hierarchy
    25. Chapter 3. Classes as objects and message receivers
    26. Chapter 3. A singleton method by any other name...
    27. Chapter 3. Constants up close
    28. Chapter 3. Nature vs. nurture in Ruby objects
    29. Chapter 4. Modules and program organization
    30. Chapter 4. A module encapsulating “stacklikeness”
    31. Chapter 4. Mixing a module into a class
    32. Chapter 4. Modules, classes, and method lookup
    33. Chapter 4. Defining the same method more than once
    34. Chapter 4. The rules of method lookup summarized
    35. Chapter 4. The method_missing method
    36. Chapter 4. Class/module design and naming
    37. Chapter 5. The default object (self), scope, and visibility
    38. Chapter 5. Self inside class, module, and method definitions
    39. Chapter 5. Self as the default receiver of messages
    40. Chapter 5. Determining scope
    41. Chapter 5. Local scope
    42. Chapter 5. Scope and resolution of constants
    43. Chapter 5. Class variable syntax, scope, and visibility
    44. Chapter 5. Class variables and the class hierarchy
    45. Chapter 5. Deploying method-access rules
    46. Chapter 5. Writing and using top-level methods
    47. Chapter 6. Control-flow techniques
    48. Chapter 6. Assignment syntax in condition bodies and tests
    49. Chapter 6. case statements
    50. Chapter 6. Repeating actions with loops
    51. Chapter 6. Iterators and code blocks
    52. Chapter 6. Curly braces vs. do/end in code block syntax
    53. Chapter 6. The importance of being each
    54. Chapter 6. Block parameters and variable scope
    55. Chapter 6. Error handling and exceptions
    56. Chapter 6. Capturing an exception in a rescue clause
  2. PART 2 BUILT-IN CLASSES AND MODULES
    1. Chapter 7. Built-in essentials
    2. Chapter 7. Recurrent syntactic sugar
    3. Chapter 7. Bang (!) methods and “danger”
    4. Chapter 7. Built-in and custom to_* (conversion) methods
    5. Chapter 7. Numerical conversion with to_i and to_f
    6. Chapter 7. Boolean states, Boolean objects, and nil
    7. Chapter 7. Comparing two objects
    8. Chapter 7. Inspecting object capabilities
    9. Chapter 8. Strings, symbols, and other scalar objects
    10. Chapter 8. Basic string manipulation
    11. Chapter 8. Querying strings
    12. Chapter 8. String transformation
    13. Chapter 8. String encoding: A brief introduction
    14. Chapter 8. Symbols and their uses
    15. Chapter 8. Symbols in practice
    16. Chapter 8. Numerical objects
    17. Chapter 8. Times and dates
    18. Chapter 8. Date/time formatting methods
    19. Chapter 9. Collection and container objects
    20. Chapter 9. Collection handling with arrays
    21. Chapter 9. Inserting, retrieving, and removing array elements
    22. Chapter 9. Combining arrays with other arrays
    23. Chapter 9. Hashes
    24. Chapter 9. Specifying default hash values and behavior
    25. Chapter 9. Hash querying
    26. Chapter 9. Ranges
    27. Chapter 9. Sets
    28. Chapter 10. Collections central: Enumerable and Enumerator
    29. Chapter 10. Enumerable Boolean queries
    30. Chapter 10. Enumerable searching and selecting
    31. Chapter 10. Selecting on threequal matches with grep
    32. Chapter 10. Element-wise enumerable operations
    33. Chapter 10. Relatives of each
    34. Chapter 10. The map method
    35. Chapter 10. Strings as quasi-enumerables
    36. Chapter 10. Where the Comparable module fits into enumerable sorting (or doesn’t)
    37. Chapter 10. Enumerators and the next dimension of enumerability
    38. Chapter 10. Attaching enumerators to other objects
    39. Chapter 10. Enumerator semantics and uses
    40. Chapter 10. Fine-grained iteration with enumerators
    41. Chapter 10. Enumerator method chaining
    42. Chapter 10. Exclusive-or operations on strings with enumerators
    43. Chapter 10. Lazy enumerators
    44. Chapter 11. Regular expressions and regexp-based string operations
    45. Chapter 11. Building a pattern in a regular expression
    46. Chapter 11. Matching, substring captures, and MatchData
    47. Chapter 11. Two ways of getting the captures
    48. Chapter 11. Fine-tuning regular expressions with quantifiers, anchors, and modifiers
    49. Chapter 11. Greedy (and non-greedy) quantifiers
    50. Chapter 11. Regular expression anchors and assertions
    51. Chapter 11. Converting strings and regular expressions to each other
    52. Chapter 11. Common methods that use regular expressions
    53. Chapter 11. Case equality and grep
    54. Chapter 12. File and I/O operations
    55. Chapter 12. STDIN, STDOUT, STDERR
    56. Chapter 12. Basic file operations
    57. Chapter 12. Reading files with File class methods
    58. Chapter 12. Querying IO and File objects
    59. Chapter 12. Directory manipulation with the Dir class
    60. Chapter 12. File tools from the standard library
    61. Chapter 12. The StringIO class
  3. PART 3 RUBY DINAMICS
    1. Chapter 13. Object individuation
    2. Chapter 13. Examining and modifying a singleton class directly
    3. Chapter 13. Singleton classes on the method-lookup path
    4. Chapter 13. The singleton_class method
    5. Chapter 13. Modifying Ruby’s core classes and modules
    6. Chapter 13. The risks of changing core functionality
    7. Chapter 13. Additive changes
    8. Chapter 13. Per-object changes with extend
    9. Chapter 13. BasicObject as ancestor and class
    10. Chapter 14. Callable and runnable objects
    11. Chapter 14. Procs and blocks and how they differ
    12. Chapter 14. Using Symbol#to_proc for conciseness
    13. Chapter 14. Creating functions with lambda and ->
    14. Chapter 14. The eval family of methods
    15. Chapter 14. The instance_eval method
    16. Chapter 14. Parallel execution with threads
    17. Chapter 14. Writing a chat server using sockets and threads
    18. Chapter 14. Manipulating thread keys
    19. Chapter 14. Issuing system commands from inside Ruby programs
    20. Chapter 14. Summary
    21. Chapter 15. Callbacks, hooks, and runtime introspection
    22. Chapter 15. Intercepting unrecognized messages with method_missing
    23. Chapter 15. Trapping include and prepend operations
    24. Chapter 15. The Module#const_missing method
    25. Chapter 15. Interpreting object capability queries
    26. Chapter 15. Getting class and module instance methods
    27. Chapter 15. Introspection of variables and constants
    28. Chapter 15. Tracing execution
    29. Chapter 15. Callbacks and method inspection in practice
    30. Chapter 15. Specifying and implementing MicroTest

Product information

  • Title: The Well-Grounded Rubyist, 2nd Ed, video edition
  • Author(s): David A. Black
  • Release date: June 2014
  • Publisher(s): Manning Publications
  • ISBN: None