Ruby Language Versions: What’s New in Each Release – wiki基地

Ruby Language Versions: A Journey Through Evolution and Innovation

Ruby, the beloved language of developers seeking elegance and productivity, has consistently evolved since its inception. Each major release introduces a plethora of new features, performance enhancements, and developer experience improvements, reflecting its commitment to modern programming paradigms and the ever-growing demands of software development. This article delves into the significant advancements across recent Ruby versions, highlighting the key innovations that have shaped its trajectory.

Ruby 2.7: Paving the Way for Ruby 3

Ruby 2.7 served as a crucial bridge to the ambitious Ruby 3.0, introducing experimental features and laying groundwork for future changes.

Pattern Matching (Experimental): This powerful new feature allowed for structural value checking and local variable binding, offering a more concise and readable way to handle conditional logic.
Compaction GC: An enhancement to the garbage collector, Compaction GC helped defragment memory, leading to improved performance and reduced memory usage in certain multi-threaded applications.
REPL Improvements: The interactive Ruby environment (IRB) received significant upgrades, including multi-line editing, rdoc integration, and colorized output, making it more user-friendly and powerful.
Separation of Positional and Keyword Arguments: A significant change for argument handling, Ruby 2.7 deprecated automatic conversion between keyword and positional arguments, preparing for their complete separation in Ruby 3.0.
Numbered Parameters (Experimental): An experimental feature enabling shorthand block parameters like _1, _2, simplifying block syntax.
Beginless Ranges (Experimental): Introduced the experimental syntax for ranges that omit the starting value, such as ..0.
Enumerable#tally: A handy new method to count the occurrences of each element within an enumerable collection.
Enumerable#filter_map: Combined the functionality of select and map into a single, efficient operation.

Ruby 3.0: The “3×3” Era of Performance and Concurrency

Ruby 3.0 marked a monumental release, famously aiming for the “3×3” goal – making Ruby three times faster than Ruby 2.0. It delivered significant strides in performance, concurrency, and static analysis.

Ractors (Experimental): Introduced as an experimental feature for true parallelism, Ractors provide an actor-like concurrency primitive with isolated memory, enabling Ruby to leverage multiple CPU cores more effectively.
RBS and TypeProf (Static Analysis): Ruby 3.0 introduced RBS, a language for describing the types of Ruby programs, and TypeProf, a static type analyzer. These tools greatly enhanced static analysis capabilities, improving code reliability and maintainability.
Performance Improvements: While the “3×3” goal was ambitious, Ruby 3.0 achieved substantial performance gains, particularly with improvements to the MJIT compiler for CPU-bound programs.
Endless Method Definition: A new, concise syntax for single-expression methods, allowing definitions like def square(x) = x * x.
Hash#except: This widely used method, previously often provided by ActiveSupport, was integrated into Ruby’s core Hash class.
Pattern Matching (Production-Ready): Elevated from experimental status, pattern matching became a fully-fledged feature with new syntax for one-line patterns and find patterns.
Fiber Scheduler: Introduced to improve concurrency management and simplify the writing of multi-threaded applications.
Automatic Garbage Compaction: Building on Ruby 2.7’s manual compaction, Ruby 3.0 made garbage compaction fully automatic, further optimizing memory usage.

Ruby 3.1: Further Refinements and Tooling

Ruby 3.1 continued to refine the language, focusing on performance with a new JIT compiler and a vastly improved debugging experience.

YJIT (Experimental): A groundbreaking addition, YJIT (Yet Another JIT) was introduced as an experimental in-process JIT compiler developed by Shopify. It promised significant performance boosts, especially for Ruby on Rails applications.
New Debugger (debug gem): Ruby 3.1 shipped with a completely rewritten debugger, offering a modern, feature-rich experience including remote debugging, improved performance, and a colorized interface, aiming to be a comprehensive replacement for existing debugging gems.
Omitted Hash Values and Keyword Arguments: New syntactic sugar allowed developers to omit hash values or keyword arguments when their names matched existing variables or methods, leading to cleaner code.
Module#prepend Behavior Change: The Module#prepend method saw a change in behavior, now taking effect even if the same module was already included, ensuring consistent module inclusion.
Improved Error Messages: Ruby 3.1 continued the trend of enhancing error messages, integrating tools like syntax_suggest and error_highlight for clearer and more actionable feedback on TypeError and ArgumentError.

Ruby 3.2: Production-Ready Performance and Expanded Horizons

Ruby 3.2 solidified many experimental features and expanded Ruby’s reach into new environments, all while maintaining a strong focus on security and performance.

YJIT (Production-Ready): A major milestone for YJIT, it transitioned from experimental to production-ready, offering stable and significant performance improvements along with reduced memory overhead.
WebAssembly Support: Ruby 3.2 introduced initial support for running Ruby in WebAssembly (Wasm) environments. This exciting development allows Ruby to operate in browsers, serverless edge environments, and other Wasm-compatible platforms.
Improved Regular Expressions: Enhancements were made to the Regexp matching algorithm to mitigate ReDoS (Regular Expression Denial of Service) attacks, ensuring that many regular expression matches now complete in linear time, with configurable timeouts.
Data Class: A new core class, Data, was introduced to represent simple, immutable value objects, providing a convenient way to define data structures.
Enumerable#compact: This new method allows for easily removing nil values from any enumerable object.
Better Error Messages: Consistent improvements to error messages continued, making debugging an even smoother process.

Ruby 3.3: The Future of Speed and Parsing

Ruby 3.3 further pushed the boundaries of performance and developer tooling, particularly in parsing and JIT compilation.

YJIT Performance Improvements: YJIT received substantial performance enhancements, better memory usage, and improved support for splat and rest arguments. It’s now enabled by default in newly generated Rails applications, signaling its maturity and impact.
Prism Parser: Introduced as a default gem, Prism is a portable, error-tolerant, and maintainable recursive descent parser for Ruby. It replaced the older Sexp parser, promising a more robust and easier-to-maintain parsing infrastructure.
RJIT (Experimental): A new experimental pure-Ruby JIT compiler, RJIT, was introduced to replace MJIT. While experimental and supporting x86-64 architecture on Unix platforms, it represents ongoing innovation in Ruby’s JIT landscape, with YJIT remaining the recommended choice for production.
IRB Enhancements: The interactive Ruby shell (IRB) gained advanced debugging integration, pager support, and type-based autocompletion, making it an even more powerful tool for development and exploration.
M:N Thread Scheduler: Implemented to improve thread and Ractor performance and CPU utilization, enhancing Ruby’s capabilities for concurrent operations.
Lrama Parser Generator: Replaced Bison, simplifying the maintenance of Ruby’s parser.

Looking Ahead: Ruby 3.4 and 4.0

The future of Ruby continues to hold exciting prospects. Ruby 3.4 is anticipated to bring features like an it block parameter reference and further optimizations to the garbage collector. Looking further, Ruby 4.0 is expected to introduce ZJIT, a new generation of the YJIT compiler focused on even greater performance, along with “Ruby Box” for in-process isolation and significant Ractor improvements.

Conclusion

Ruby’s journey through its various versions is a testament to its vibrant community and dedicated core team. Each release builds upon the last, delivering a language that is not only powerful and expressive but also increasingly performant, concurrent, and developer-friendly. From pattern matching to advanced JIT compilers and robust static analysis tools, Ruby continues to evolve, empowering developers to build sophisticated and efficient applications with joy and ease.