Ruby Programming Language

  1. Advanced Ruby Concepts
    1. Metaprogramming
      1. The send Method
        1. Dynamic Method Calls
          1. Method Name as String/Symbol
            1. Bypassing Visibility
            2. define_method
              1. Dynamic Method Definition
                1. Block-Based Methods
                  1. Closure Capture
                  2. method_missing
                    1. Missing Method Handler
                      1. Dynamic Method Creation
                        1. Proxy Objects
                        2. eval Family of Methods
                          1. eval
                            1. String Code Execution
                              1. Binding Context
                                1. Security Concerns
                                2. instance_eval
                                  1. Object Context Evaluation
                                    1. Block Execution
                                    2. class_eval
                                      1. Class Context Evaluation
                                        1. Module Modification
                                      2. Introspection and Reflection
                                        1. respond_to?
                                          1. Method Availability
                                            1. Visibility Checking
                                            2. methods
                                              1. Method Listing
                                                1. Inherited Methods
                                                2. instance_variables
                                                  1. Variable Inspection
                                                    1. Object State
                                                    2. ancestors
                                                      1. Inheritance Chain
                                                        1. Module Inclusion Order
                                                      2. Class and Module Hooks
                                                        1. inherited
                                                          1. included
                                                            1. extended
                                                              1. const_missing
                                                              2. Eigenclass Manipulation
                                                                1. Singleton Class Access
                                                                  1. Class Method Definition
                                                                2. Error Handling and Exceptions
                                                                  1. The Exception Class Hierarchy
                                                                    1. Exception
                                                                      1. StandardError
                                                                        1. RuntimeError
                                                                          1. SystemExit
                                                                            1. Interrupt
                                                                            2. begin, rescue, else, ensure
                                                                              1. Exception Handling Structure
                                                                                1. Multiple rescue Clauses
                                                                                  1. else Clause Usage
                                                                                    1. ensure Clause Cleanup
                                                                                    2. Raising Exceptions (raise)
                                                                                      1. raise with Message
                                                                                        1. raise with Exception Class
                                                                                          1. Re-raising Exceptions
                                                                                          2. Rescuing Specific Exceptions
                                                                                            1. Exception Type Matching
                                                                                              1. Multiple Exception Types
                                                                                                1. Exception Variable Capture
                                                                                                2. Creating Custom Exception Classes
                                                                                                  1. Inheriting from StandardError
                                                                                                    1. Custom Exception Attributes
                                                                                                      1. Exception Hierarchies
                                                                                                      2. Retrying Operations
                                                                                                        1. retry Keyword
                                                                                                          1. Retry Limits
                                                                                                            1. Exponential Backoff
                                                                                                            2. Ensuring Cleanup
                                                                                                              1. Resource Management
                                                                                                                1. File Handling
                                                                                                                  1. Connection Cleanup
                                                                                                                2. File I/O
                                                                                                                  1. Reading from Files
                                                                                                                    1. File.open and File.read
                                                                                                                      1. File Modes
                                                                                                                        1. Reading Line by Line
                                                                                                                          1. Reading with Blocks
                                                                                                                          2. Writing to Files
                                                                                                                            1. File.write and File.puts
                                                                                                                              1. File Creation
                                                                                                                                1. Appending to Files
                                                                                                                                  1. Binary Mode
                                                                                                                                  2. File and Directory Manipulation
                                                                                                                                    1. File.exist?
                                                                                                                                      1. File.size and File.mtime
                                                                                                                                        1. File.rename and File.delete
                                                                                                                                          1. Dir Class for Directories
                                                                                                                                            1. Directory Traversal
                                                                                                                                              1. Pathname Class
                                                                                                                                              2. File Permissions and Attributes
                                                                                                                                                1. File.chmod
                                                                                                                                                  1. File.stat
                                                                                                                                                    1. File Ownership
                                                                                                                                                    2. Temporary Files
                                                                                                                                                      1. Tempfile Class
                                                                                                                                                        1. Automatic Cleanup
                                                                                                                                                      2. Regular Expressions (Regex)
                                                                                                                                                        1. Creating Regex Patterns
                                                                                                                                                          1. Literal Syntax
                                                                                                                                                            1. Regex.new
                                                                                                                                                              1. Pattern Compilation
                                                                                                                                                              2. Regex Syntax and Modifiers
                                                                                                                                                                1. Character Classes
                                                                                                                                                                  1. Quantifiers
                                                                                                                                                                    1. Anchors
                                                                                                                                                                      1. Groups and Captures
                                                                                                                                                                        1. Modifiers (i, m, x)
                                                                                                                                                                        2. Matching and Searching Strings
                                                                                                                                                                          1. match Method
                                                                                                                                                                            1. =~ Operator
                                                                                                                                                                              1. scan Method
                                                                                                                                                                              2. The MatchData Object
                                                                                                                                                                                1. Capture Groups
                                                                                                                                                                                  1. Match Position
                                                                                                                                                                                    1. Pre and Post Match
                                                                                                                                                                                    2. Substitution and Scanning
                                                                                                                                                                                      1. gsub and sub
                                                                                                                                                                                        1. Block-Based Replacement
                                                                                                                                                                                          1. Global Matching
                                                                                                                                                                                          2. Named Captures
                                                                                                                                                                                            1. Named Groups
                                                                                                                                                                                              1. Accessing Named Captures
                                                                                                                                                                                            2. Concurrency and Parallelism
                                                                                                                                                                                              1. Threads
                                                                                                                                                                                                1. Creating Threads
                                                                                                                                                                                                  1. Thread.new
                                                                                                                                                                                                    1. Thread Lifecycle
                                                                                                                                                                                                      1. Thread States
                                                                                                                                                                                                        1. Thread Safety
                                                                                                                                                                                                          1. Shared State Issues
                                                                                                                                                                                                          2. Mutexes for Thread Safety
                                                                                                                                                                                                            1. Mutex Class
                                                                                                                                                                                                              1. Synchronization
                                                                                                                                                                                                                1. Critical Sections
                                                                                                                                                                                                                  1. Deadlock Prevention
                                                                                                                                                                                                                  2. Fibers
                                                                                                                                                                                                                    1. Creating and Using Fibers
                                                                                                                                                                                                                      1. Fiber.yield
                                                                                                                                                                                                                        1. Fiber vs. Thread
                                                                                                                                                                                                                          1. Cooperative Multitasking
                                                                                                                                                                                                                          2. The Global Interpreter Lock (GIL)
                                                                                                                                                                                                                            1. Implications for Concurrency
                                                                                                                                                                                                                              1. Thread Switching
                                                                                                                                                                                                                                1. I/O Operations
                                                                                                                                                                                                                                2. Thread Pools
                                                                                                                                                                                                                                  1. Worker Threads
                                                                                                                                                                                                                                    1. Task Queues
                                                                                                                                                                                                                                    2. Atomic Operations
                                                                                                                                                                                                                                      1. Thread-Safe Operations
                                                                                                                                                                                                                                        1. Race Conditions

                                                                                                                                                                                                                                    Previous

                                                                                                                                                                                                                                    6. Object-Oriented Programming (OOP) in Ruby

                                                                                                                                                                                                                                    Go to top

                                                                                                                                                                                                                                    Next

                                                                                                                                                                                                                                    8. The Ruby Ecosystem