Thread by @gregnavis

🆕 Ruby 3.2 is out, so let's start 2023 by exploring what's new.

Many of the changes warrant separate deep-dives, but we can describe them briefly to raise awareness.

Let's roll!

1/16 New hook method! 🎉

Whenever a new constant is added to a module, .const_added is called with that constant's name as a symbol.

Example use case: automatic registration of classes inside a module with some third-party API

2/16 New core class: Data

Data is like Struct for immutable value objects. Changing its attributes is only possible by creating a new instance with the updated values.

I think immutability is a promising direction to explore in Ruby.

3/16 Rest and keyword rest arguments can be forwarded anonymously.

In other words: if a method only references rest arguments to forward them to another method then these rest arguments can be unnamed.

Result: positional, keyword, and block arguments can be anonymous!

4/16 Ruby pattern matching is constantly evolving, and 3.2 is another step in its evolution.

The find pattern is no longer considered experimental.

Find pattern = one or more adjacent array items, with some items before or after them.

5/16 Regexp performance improvements / DoS protection

Many regexps can now be matched in linear time, providing DoS protection.

A match timeout can be set, providing a fallback protection.

6/16 Error reporting improvements

Syntax errors are more informative, and try to point to causes.

Type and argument errors are mapped to more specific locations in program text.

Such quality of life improvements DO accumulate, and help produce great developer experience.

7/16 WASI-based WebAssembly

The Ruby interpreter can now be run in WebAssembly environments (e.g. the browser), and interact with the operating system via WASI.

WASI = set of APIs WebAssembly code can use to manage files, open sockets, etc. outside of browsers.

8/16 YJIT is production-ready 🎉

YJIT is a just-in-time compiler developed by Shopify and GitHub. It's 40% faster in synthetic benchmarks than not using JIT.

Additionally, it supports arm64 now, e.g. Apple M1.

Enable via `ruby --yjit`

9/16 Procs taking one positional parameter + keyword parameters behave in a less surprising way

It's a bit of an edge case, but I'm sure you can totally imagine wasting time debugging it.

Fortunately, Ruby 3.2 is much less surprising here!

10/16 Left-to-right constant assignment on explicit objects

This was another potentially surprising behavior, which was made predictable in 3.2.

11/16 Bundler (but not RubyGems!) has switched its dependency resolution algorithm from Molinillo to PubGrub.

PubGrub is more efficient and offers more helpful error messages in case of conflicting package dependencies.

Another DX improvement!

12/16 Refinements and meta-programming

Ruby 3.2 offers more methods for reflection related to refinements. It's not something you'd use often, but it's there in case you're doing meta-programming.

13/16 MatchData can return a byte range, in addition to character range, for a capturing group.

Very helpful when working with regular expressions at a byte level, as it saves you from determining offsets manually.

14/16 String got three byte-level methods:

• byteindex - byte-level offset of a substring
• byterindex - same as above, but for the last occurence
• bytesplice - replace a range of bytes within the string

15/16 Other improvements:

• MJIT was reimplemented from C to Ruby
• Set is built-in
• Hash: shift returns nil even if there's a default
• Proc: dup and parameters improvements
• Some new parser options
• Struct can be initialized with keyword arguments by default

16/16 Last but not least, some removals:

• Fixnum, Bignum, and a few other consts
• taint- and trust- related methods
• No libyyaml and libffi

That's 99% of changes brought by Ruby 3.2.

I'll explore some of them in deep-dive threads and articles, so follow me @gregnavis not to miss them.

You can help other Rubyists catch up on the latest changed by liking and retweeting the thread.