Programming Ruby 3.3: The Pragmatic Programmers Guide - Noel Rappin

"Programming Ruby 3.3: The Pragmatic Programmers Guide - Noel Rappin” is an encyclopedia of Ruby, which is, arguably, one of the most important web development tools. Ruby is at the helm of the Rails framework on which the foundations of many crucial Web destinations rely. More specifically, this two-part revised edition – fondly called the “Pickaxe Book” after the cover’s glyph – provides an up-to-date system reference on the language itself, which includes an introduction to the language with an emphasis on the features of pattern matching and Ractors; an overview of the language through Ruby 3. 3. 

Like Python, Ruby is a pure object-oriented language, but it is also a scripting language that makes it very useful and a favorite among programmers who want to complete their targets efficiently and effectively. This book comprises extensive documentation of the common Ruby programming language, including detailed descriptions of standard library modules in Ruby, built-in classes in Ruby, and modules. Programming Ruby 3.3: The Pragmatic Programmers Guide - Noel Rappin also deals with all the new and changed syntax and semantics that have been released with Ruby 3. Thus, let us focus on three strands of it, namely, pattern matching and Ractors. 

The book "Programming Ruby 3.3: The Pragmatic Programmers Guide - Noel Rappin” presupposes the reader’s familiarity with object-oriented paradigms. Ruby programmers particularly run their code on the command line and use text editors rather than falling into the category of an Integrated Development Environment. The major platforms where Ruby is used are Windows, Linux, and MacOS. 

Programming Ruby 3.3: The Pragmatic Programmers Guide - Noel Rappin Table of Contents:

1. Getting Started:
2. Installing Ruby
3. Installing Ruby for Windows
4. Running Ruby
5. Creating Ruby Programs
6. Getting More Information about Ruby
7. Ruby.new excerpt:
8. Ruby Is an Object-Oriented Language
9. Some Basic Ruby
10. Arrays and Hashes
11. Symbols
12. Control Structures
13. Regular Expressions
14. Blocks
15. Reading and 'Riting
16. Command-Line Arguments
17. Commenting Ruby
18. Classes, Objects, and Variables:
19. Defining Classes
20. Objects and Attributes
21. Classes Working with Other Classes
22. Specifying Access Control
23. Variables
24. Reopening Classes
25. Collections, Blocks, and Iterators:
26. Arrays
27. Hashes
28. Digging
29. Word Frequency: Using Hashes and Arrays
30. Blocks and Enumeration
31. More about Methods:
32. Defining a Method
33. Calling a Method
34. Sharing Functionality: Inheritance, Modules, and Mixins excerpt:
35. Inheritance and Messages
36. Modules
37. Inheritance, Mixins, and Design
38. Basic Types: Numbers, Strings, and Ranges:
39. Numbers
40. Strings
41. Ranges
42. Regular Expressions:
43. What Regular Expressions Let You Do
44. Creating and Using Regular Expressions
45. Regular Expression Patterns
46. Regular Expression Syntax
47. Expressions:
48. Operator Expressions
49. Command Expressions
50. Assignment
51. Conditional Execution
52. Loops and Iterators
53. Pattern Matching
54. Exceptions:
55. The Exception Class
56. Handling Exceptions
57. Raising Exceptions
58. Using Catch and Throw
59. Basic Input and Output:
60. What Is an I/O Object?
61. Opening and Closing Files
62. Reading and Writing Files
63. Talking to Networks
64. Threads, Fibers, and Ractors:
65. Multithreading with Threads
66. Running Multiple External Processes
67. Creating Fibers
68. Understanding Ractors
69. Testing Ruby Code:
70. Why Unit Test?
71. Testing with Minitest
72. Structuring Tests
73. Creating Mock Objects in Minitest
74. Organizing and Running Tests
75. Testing with RSpec
76. Ruby in Its Setting:
77. Ruby from the Command Line excerpt
78. Ruby Gems
79. Interactive Ruby
80. Debugging Ruby
81. Typed Ruby excerpt
82. Documenting Ruby
83. Ruby Crystallized
84. Ruby Style
85. The Ruby Object Model and Metaprogramming:
86. Understanding Objects and Classes
87. Defining Singleton Methods
88. Inheritance and Visibility
89. Modules and Mixins
90. Metaprogramming Class-Level Macros
91. Using instance_eval and class_eval
92. Using Hook Methods
93. A Metaprogramming Example
94. Top-Level Execution Environment
95. Reflection and Object Space:
96. Looking at Objects
97. Looking at Classes
98. Calling Methods Dynamically
99. System Hooks
100. Tracing Your Program’s Execution
101. Behind the Curtain: The Ruby VM
102. Marshaling and Distributed Ruby
103. Ruby Language Reference:
104. Language Reference: Literal Types and Expressions
105. Source Layout
106. Ruby Literals
107. Regular Expressions
108. Names
109. Values, Variables, and Constants
110. Expressions, Conditionals, and Loops
111. Language Reference: Objects and Classes
112. Method Definition
113. Invoking a Method
114. Aliasing
115. Defining Classes
116. Defining Modules
117. Access Control
118. Blocks, Closures, and Proc Objects
119. Exceptions
120. Catch and Throw
121. Typed Ruby
122. Ruby Library Reference:
123. Library Reference: Core Data Types
124. Dates and Times
125. Math
126. Numbers
127. Random and SecureRandom
128. Regexp
129. Strings
130. Symbols
131. Library Reference: Ruby’s Object Model
132. BasicObject
133. Class
134. Comparable
135. Kernel
136. Method
137. Module
138. Object
139. Library Reference: Enumerators and Containers
140. Array
141. Enumerable
142. Enumerator
143. Hash
144. Set
145. Library Reference: Input, Output, Files, and Formats
146. CSV
147. Dir
148. File
149. FileUtils
150. IO
151. JSON
152. Pathname
153. StringIO
154. Tempfile
155. URI
156. YAML
157. Library Reference: Ruby on Ruby
158. Benchmark
159. Data
160. Delegator and SimpleDelegator
161. Logger
162. ObjectSpace
163. Observable
164. OpenStruct
165. PP
166. Prism
167. Ripper
168. Singleton
169. Struct
170. Unbound Method
171. Appendixes:
172. Troubleshooting Ruby
173. Ruby Changes
174. Ruby Runtimes

Who is this course for?

1. The people targeted by this knowledge transfer include programmers aspiring to work with Ruby in web applications. 
2. Rails developers who wish to extend their knowledge about Ruby language, which underlies the development of Rails applications. 
3. Developers prefer to skip several stages in the development process and move quickly from the concept to the working code. 
4. Senior developers and other stakeholders are getting angry when dealing with demanding languages that appear to hinder the ontogenesis process, which is much independent of their intended assistance. 
5. Those who spend more time satisfying the compiler than the clients or consumers. 
6. Developers who like to run the programs in the terminal and who use simple text editors instead of graphical Integrated Development Environments (IDEs). 
7. Anyone who wants to learn Ruby, which is a fully object-oriented Scripting language. 
8. Everyone is seeking a one-stop manual on Ruby that will appeal to Ruby newcomers as well as intermediate and advanced programmers and prepare them for the new and changed syntax and semantics added to Ruby 3. 3, including pattern matching and Reactors. 

Click on the links below to Download Programming Ruby 3.3: The Pragmatic Programmers Guide - Noel Rappin!