The Well-Grounded Rubyist, 2nd Video Edition

The Well-Grounded Rubyist, 2nd Video Edition
The Well-Grounded Rubyist, 2nd Video Edition
English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 17h 34m | 2.49 GB

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.


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

1 Bootstrapping your Ruby literacy
2 The variety of Ruby identifiers
3 Method calls, messages, and Ruby objects
4 Writing and saving a simple program
5 Anatomy of the Ruby installation
6 Ruby extensions and programming libraries
7 Out-of-the-box Ruby tools and applications
8 A closer look at interactive Ruby interpretation with irb
9 The rake task-management utility
10 Objects, methods, and local variables
11 Creating a generic object
12 Crafting an object – The behavior of a ticket
13 The innate behaviors of an object
14 A close look at method arguments
15 Order of parameters and arguments
16 Local variables and variable assignment
17 References in variable assignment and reassignment
18 Local variables and the things that look like them
19 Organizing objects with classes
20 Overriding methods
21 Instance variables and object state
22 Setter methods
23 Attributes and the attr_ method family
24 Inheritance and the Ruby class hierarchy
25 Classes as objects and message receivers
26 A singleton method by any other name…
27 Constants up close
28 Nature vs. nurture in Ruby objects
29 Modules and program organization
30 A module encapsulating “stacklikeness”
31 Mixing a module into a class
32 Modules, classes, and method lookup
33 Defining the same method more than once
34 The rules of method lookup summarized
35 The method_missing method
36 Class_module design and naming
37 The default object (self), scope, and visibility
38 Self inside class, module, and method definitions
39 Self as the default receiver of messages
40 Determining scope
41 Local scope
42 Scope and resolution of constants
43 Class variable syntax, scope, and visibility
44 Class variables and the class hierarchy
45 Deploying method-access rules
46 Writing and using top-level methods
47 Control-flow techniques
48 Assignment syntax in condition bodies and tests
49 case statements
50 Repeating actions with loops
51 Iterators and code blocks
52 Curly braces vs. do_end in code block syntax
53 The importance of being each
54 Block parameters and variable scope
55 Error handling and exceptions
56 Capturing an exception in a rescue clause
57 Built-in essentials
58 Recurrent syntactic sugar
59 Bang (!) methods and “danger”
60 Built-in and custom to_ (conversion) methods
61 Numerical conversion with to_i and to_f
62 Boolean states, Boolean objects, and nil
63 Comparing two objects
64 Inspecting object capabilities
65 Strings, symbols, and other scalar objects
66 Basic string manipulation
67 Querying strings
68 String transformation
69 String encoding – A brief introduction
70 Symbols and their uses
71 Symbols in practice
72 Numerical objects
73 Times and dates
74 Date_time formatting methods
75 Collection and container objects
76 Collection handling with arrays
77 Inserting, retrieving, and removing array elements
78 Combining arrays with other arrays
79 Hashes
80 Specifying default hash values and behavior
81 Hash querying
82 Ranges
83 Sets
84 Collections central – Enumerable and Enumerator
85 Enumerable Boolean queries
86 Enumerable searching and selecting
87 Selecting on threequal matches with grep
88 Element-wise enumerable operations
89 Relatives of each
90 The map method
91 Strings as quasi-enumerables
92 Where the Comparable module fits into enumerable sorting (or doesn’t)
93 Enumerators and the next dimension of enumerability
94 Attaching enumerators to other objects
95 Enumerator semantics and uses
96 Fine-grained iteration with enumerators
97 Enumerator method chaining
98 Exclusive-or operations on strings with enumerators
99 Lazy enumerators
100 Regular expressions and regexp-based string operations
101 Building a pattern in a regular expression
102 Matching, substring captures, and MatchData
103 Two ways of getting the captures
104 Fine-tuning regular expressions with quantifiers, anchors, and modifiers
105 Greedy (and non-greedy) quantifiers
106 Regular expression anchors and assertions
107 Converting strings and regular expressions to each other
108 Common methods that use regular expressions
109 Case equality and grep
110 File and I_O operations
112 Basic file operations
113 Reading files with File class methods
114 Querying IO and File objects
115 Directory manipulation with the Dir class
116 File tools from the standard library
117 The StringIO class
118 Object individuation
119 Examining and modifying a singleton class directly
120 Singleton classes on the method-lookup path
121 The singleton_class method
122 Modifying Ruby’s core classes and modules
123 The risks of changing core functionality
124 Additive changes
125 Per-object changes with extend
126 BasicObject as ancestor and class
127 Callable and runnable objects
128 Procs and blocks and how they differ
129 Using Symbol#to_proc for conciseness
130 Creating functions with lambda and –
131 The eval family of methods
132 The instance_eval method
133 Parallel execution with threads
134 Writing a chat server using sockets and threads
135 Manipulating thread keys
136 Issuing system commands from inside Ruby programs
137 Summary
138 Callbacks, hooks, and runtime introspection
139 Intercepting unrecognized messages with method_missing
140 Trapping include and prepend operations
141 The Module#const_missing method
142 Interpreting object capability queries
143 Getting class and module instance methods
144 Introspection of variables and constants
145 Tracing execution
146 Callbacks and method inspection in practice
147 Specifying and implementing MicroTest