I'm pleasantly surprised to see this improvement:

  Tempfile.create(anonymous: true) removes the created temporary file
  immediately. So applications don’t need to remove the file.
  [Feature #20497]

I use a similar pattern a lot:

  file = Tempfile.new.tap(&:unlink)
  file << "... some really large data to pipe"
  system("md5sum", in: file.tap(&:rewind))

It's a neat trick to leverage the filesystem for large amounts of data (e.g. "psql \copy" generation), without littering tempfiles everywhere. Once the last fd disappears, the filesystem releases the data; so you don't have to "trap" signals and add cleanup routines. (Hint: you can also use these unlinked-tempfiles for command output, e.g. huge grep output, etc.)

On Linux systems, `open(..., O_TMPFILE)` is typically used, which provides additional safety. The created file is initially unnamed (no race condition between `open` and `unlink`).

When I needed safety, my non-portable solution was to use Ruby's syscall feature. (Btw, I love that you can do this.)

  require "fcntl"

  SYS_OPEN   = 2
  O_TMPFILE  = 0x00410000
  O_RDWR     = Fcntl::O_RDWR

  def tmpfile
    mode = O_RDWR | O_TMPFILE
    fd = syscall(SYS_OPEN, "/dev/shm", mode, 0644)
    IO.for_fd(fd)
  end

But... Another pleasant surprise from the PR (https://bugs.ruby-lang.org/issues/20497).

  Linux 3.11 has O_TMPFILE to create an unnamed file.
  The current implementation uses it.

Excellent to see :) Makes the PR even better!

The default block parameter name seems small, but I feel like I'm gonna use it all the time, especially when I'm in the Rails console just trying to debug data

  [it, (1..it).map { it * it }]

  [x, (1..x).map { x * it }]

  items.map { foo(_1) }
  items.map { foo(it) }

I know Shopify has a great site on comparing Ruby vs YJIT perf.

https://speed.yjit.org

But does anyone have current numbers on how Ruby/YJIT compares to something like Python/PHP/LuaJIT?

> In Ruby 3.4, it has been added as a default name for the first parameter passed to a block. Rather than specifying a name in trivial cases like the one above, you can now write:

> [

> "beige chinos",

> "blue jorts",

> "rainbow jorts",

> ].filter { it =~ /jorts/ }

> # => ["blue jorts", "rainbow jorts"]

This reminds me of Perl's $_ (which in Ruby is last line read from STDIN).

    ary.grep /(j|sh)orts/

    terms = %w(foo? bar q**x)
    Regexp.new "\\b(#{terms.map { Regexp.escape it }.join ?|})\\b"

    #=> /\b(foo\?|bar|q\*\*x)\b/

The author also forgot to mention that the new error output doesn't mix ` and ' anymore.

Ruby 3.3

> 'asd' + 1 (sitar-report):1:in `+': no implicit conversion ...

Ruby 3.4

> 'asd' + 1 (sitar-report):1:in 'String#+': no implicit conversion...

I happen to be reading the latest edition of the pickaxe book, as I'll soon be using Ruby at work (first experience) and this 'it' update sounds so much better than the _1 described in the book.

I remember thinking it clashed a bit with the idea of trying to make the code read like natural language.

  pp open("|ls -lh /usr/bin/ls"){_1.read}
  "-rwxr-xr-x 1 root root 135K Aug 30 04:57 /usr/bin/ls\n"

  open("|column -t -s \\t", "w"){_1 << tsv_data}

I have a love-hate relationship with Ruby. On one hand, it's a very expressive language that's excellent for building structured, lightweight applications. On the other hand, it requires significant discipline and a strong memory of your codebase and all the different types in play. When you combine this highly dynamic nature with Rails, especially its concerns and hooks, it can become extremely challenging to understand what's actually happening in the system.

I don't understand the change of the default block parameter name. It's already _1, _2, etc. Why create yet another, backward-incompatible way?

And still, they doom march forward with the fragmentation of rbs and sorbet/tapioca, rather than adopting in-band gradual typing like Python did.

I think the greater problem is Ruby appears to be developed by a nearly-closed small clique of people who refuse to listen to others or to reason.

Is ruby used outside of web dev (i.e., Ruby on Rails)? it seems like a nice cute language but I almost never hear about it.

Happy to see chilled strings; eventually getting rid of the frozen strings pragma will be enjoyable.

See also: https://nithinbekal.com/posts/ruby-3-4/

I think it's quite sad that Ruby is so associated with Rails. Ruby is one of my favorite languages and last time that I touched a Rails code was in 2017. Even in web dev Rails is not the only thing in Ruby, there's also Sinatra which is an elegant micro-framework for building HTTP APIs, similar to Flask.

Some projects that I remember that uses Ruby that are not related to web dev: Homebrew, Metasploit, Vagrant and Jekyll.

I also find Ruby very useful for shell scripts. I wrote a blog post about that some months ago, you can read it and the discussion about it here: https://news.ycombinator.com/item?id=40763640

Ruby is my go to language for short "fun" programs, as there are many places where it optimized for development experience (such as the new "it" feature). One of the committers, Yusuke Endoh, clearly understood the joy of coding in itself as opposed to being means to an end, and has authored a book on esoteric programming:

https://www.amazon.co.jp/dp/4774176435

Before Ruby, my preferred fun language was Perl. Ruby is like Perl but without having to type $ all the time. I have never used Rails.

Oh yes, Ruby is my go to language to use when I need to glue things together or when I want to automate tasks on my computer. It's such a pleasant language to use!

I think the reason it's not talked about a lot is mainly because Rails overshadowing it and because there aren't so much hype or controversies around it.

At my day job we use Ruby with Sorbet to stitch together a large number of data engineering pipelines. It's a good choice since we also often stand up small Rails apps to expose the results from those pipelines, so we can keep everything in one language. The fluent functional approach it enables is pretty nice for that business logic (but I would not want to do it without the gradual typing on top). We do find ourselves glancing over at the Python ecosystem with envy from time to time but overall it has worked pretty well. As I've gotten better with it I find myself reaching for irb for more and more one-off tasks in the shell too.

Yup, I wrote smartcard reader programs in it. Some of them talk to a http server using async-http. It can be used for anything that Perl or Python is good at, well maybe except data science because Python really shines there. And irb is massively useful for everyday tasks.

Yes! In practice it's a scripting language similar in vein to Python, and it's used for similar things.

It's actually the language of choice for a lot of OpenSUSE projects as well, like the Open Build Service.

The reason you don't here much about it is because of its maturity.

It's used for chef/cinc. I rather like that "recipes" use ruby with an edsl rather than yaml like ansible or salt.

Vagrant, chef, puppet and lots of other stuff is written in Ruby. It's also great as a scripting language replacing Bash, Python or Perl for any number of things. I write all my small, one off programs in Ruby.

I use Ruby extensively in ops scripting and text mangling, where it supplanted Perl for me around about the same time that Perl stagnated ca.2010-2015.

However, Ruby doesn't make sense to me as a general applications language (Swift & Kotlin have won me over from C++ & Java), or as a systems programming language (I'm still rusted on to C, pun intended), and I remain super ambivalent about Rails despite using it extensively to stick web interfaces onto things. That doubt is in large part because Rails frequently undermines the Smalltalk-ish heart of Ruby.

Sure. I use it for almost everything, because it's so pleasant to use.

Yeah, I use it for everything between 5-lines-of-bash and a needs-a-compiled-language. You almost never hear about it, because it's mature. No big controversies, no huge fuckups or new versions that break everything, just a steady trickle of improvements.

We use it for microservices that only deal with Json and avro. Of course, we do that on Rails for some reason I'll never understand.

Definitely, although Rails is its most common use

You might have heard about Metasploit.