Ruby Notes for Professionals Ruby Programmation step by step (Chahdi, Othmane) (Z-Library)

# Ruby Notes for Professionals: Ruby Programming Step by Step ## 【One-Line Pitch】 A practical, recipe-style reference for Ruby developers who want to master the language's core mechanics—from variables and control flow to metaprogramming and functional techniques—through concise, example-driven explanations. Ideal for intermediate programmers who already know basic syntax and want to deepen their understanding of Ruby's idiomatic patterns. ## 【Book Arc】 - **Opening (~0%–10%)**: Foundational data types and operations—numbers (integer vs. float division, rounding, rationals, complex numbers), symbols, strings, and basic I/O. Establishes the "everything is an object" mindset with practical conversion and manipulation recipes. - **Early (~10%–30%)**: Variables, scope, and assignment patterns—global variables, constants, parallel assignment, and the splat operator for array decomposition. Introduces string formatting techniques (justification, centering, percent strings, heredocs) and time/date handling. - **Early–Middle (~30%–45%)**: Control flow and conditional logic—if/elsif/else expressions, ternary operators, the or-equals (||=) operator, and block syntax. Covers hash creation, custom hash/eql? implementations, and using methods as blocks. - **Middle (~45%–55%)**: Functional programming concepts—currying and partial application with lambdas, plus iteration patterns (each, reverse_each) and exception handling with multiple rescue clauses. - **Late (~55%–100%)**: Object-oriented internals—constructors, the new/allocate/initialize lifecycle, message passing through inheritance and modules, keyword arguments, and truthiness semantics. ## 【Key Takeaways】 - **Integer vs. float division is a common pitfall** (Early): Ruby performs integer division when both operands are integers (3/2 = 1), so cast at least one operand to Float or use fdiv for decimal results. This affects everything from basic math to financial calculations. - **Global variables are powerful but dangerous** (Early): Prefixed with $, they're visible everywhere and return nil when undefined rather than raising errors—but their use is strongly discouraged in favor of constants for maintainability. - **The or-equals operator (||=) is a concise conditional assignment** (Middle): It assigns a value only if the variable is nil or false, replacing verbose if-nil checks. However, be careful when false is a valid value—it will be overwritten. - **Currying enables partial application and code reuse** (Middle): Using `->(a,b){a+b}.curry.(1)` creates specialized functions from general formulas, reducing repetitive method definitions and enabling elegant functional composition. - **Custom hash and eql? implementations require care** (Middle): If two objects are equal under eql?, they must return the same hash value—otherwise you'll get duplicate entries. Poor hash functions degrade O(1) lookup to O(n). - **Ruby's new is just a class method, not a keyword** (Late): It calls allocate to create an uninitialized instance, then invokes initialize (whose return value is discarded). Understanding this lifecycle clarifies why initialize doesn't need to return self. - **Rescue block order matters** (Middle): The first matching rescue clause executes, so placing StandardError first will swallow all more specific exceptions. Always order from most specific to most general. ## 【Reading Tips】 - **Skim the early chapters on numbers and strings** if you're comfortable with basic Ruby—they're reference material best consulted when you need a specific conversion or formatting technique. - **Deep-read the sections on control flow and the ||= operator**—these are everyday patterns that appear constantly in real Ruby code, and understanding their nuances prevents subtle bugs. - **Pay special attention to the currying and partial application examples**—they're conceptually dense but unlock powerful functional programming techniques. Work through the math examples step by step. - **The exception handling section is worth careful study**—the order of rescue clauses is a common source of bugs, and the examples clearly demonstrate both correct and incorrect patterns. - **The object lifecycle section (new/allocate/initialize) is essential for understanding Ruby's OOP model**—it explains why initialize works the way it does and demystifies a common source of confusion for developers coming from other languages. ## 【Coverage Limits】 The excerpts primarily cover language fundamentals and core mechanics; they don't include advanced metaprogramming, Rails-specific patterns, testing frameworks, or deployment topics. The guide focuses on the language itself rather than ecosystem tools. ##