O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

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