[ruby-core:101697] Re: Ruby 3.0.0 Released

Added 3.0.0 to docs: https://docs.ruby-lang.org/en/3.0.0/
For next time, you can create a PR referring
https://github.com/ruby/docs.ruby-lang.org/commit/360bff5327c527270a9ef228cea25f1bf68ed541

2020年12月25日(金) 18:58 Victor Shepelev <[e-mail]>:
>
> Congratulations!
> Awesome release.
>
> When would the new version appear at https://docs.ruby-lang.org/en/?
>
> V.
>
> пт, 25 груд. 2020, 09:09 користувач NARUSE, Yui <[e-mail]> пише:
>>
>> We are pleased to announce the release of Ruby 3.0.0. From 2015 we
>> developed hard toward Ruby 3, whose goal is performance, concurrency,
>> and Typing. Especially about performance, Matz stated "Ruby3 will be 3
>> times faster than Ruby2" a.k.a. [Ruby
>> 3x3](https://blog.heroku.com/ruby-3-by-3).
>>
>>
>> <img src='https://cache.ruby-lang.org/pub/media/ruby3x3.png'
>> alt='Optcarrot 3000 frames' width='100%' />
>>
>> With [Optcarrot benchmark](https://github.com/mame/optcarrot), which
>> measures single thread performance based on NES's game emulation
>> workload, it achieved 3x faster performance than Ruby 2.0!
>> <details>These were measured at the environment written in
>> https://benchmark-driver.github.io/hardware.html.
>> [8c510e4095](http://github.com/ruby/ruby/commit/8c510e4095) was used
>> as Ruby 3.0. It may not be 3x faster depending on your environment or
>> benchmark.</details>
>>
>> Ruby 3.0.0 covers those goals by
>> * Performance
>>   * MJIT
>> * Concurrency
>>   * Ractor
>>   * Fiber Scheduler
>> * Typing (Static Analysis)
>>   * RBS
>>   * TypeProf
>>
>> With above performance improvement Ruby 3.0 introduces a number of new
>> features described below.
>>
>> ## Performance
>>
>> > When I first declared "Ruby3x3" in the conference keynote, many including members of the core team felt "Matz is a boaster". In fact, I felt so too. But we did. I am honored to see the core team actually accomplished to make Ruby3.0 three times faster than Ruby2.0 (in some benchmarks). -- Matz
>>
>> ### MJIT
>>
>> Many improvements were implemented in MJIT. See NEWS for details.
>>
>> As of Ruby 3.0, JIT is supposed to give performance improvements in
>> limited workloads, such as games
>> ([Optcarrot](https://benchmark-driver.github.io/benchmarks/optcarrot/commits.html#chart-1)),
>> AI ([Rubykon](https://benchmark-driver.github.io/benchmarks/rubykon/commits.html)),
>> or whatever application that spends majority of time in calling a few
>> methods many times.
>>
>> Although Ruby 3.0 [significantly decreased a size of JIT-ed
>> code](https://twitter.com/k0kubun/status/1256142302608650244), it is
>> still not ready for optimizing workloads like Rails, which often spend
>> time on so many methods and therefore suffer from i-cache misses
>> exacerbated by JIT. Stay tuned for Ruby 3.1 for further improvements
>> on this issue.
>>
>> ## Concurrency / Parallel
>>
>> > It's multi-core age today. Concurrency is very important. With Ractor, along with Async Fiber, Ruby will be a real concurrent language. --- Matz
>>
>> ### Ractor (experimental)
>> Ractor is an Actor-model like concurrent abstraction designed to
>> provide a parallel execution feature without thread-safety concerns.
>>
>> You can make multiple ractors and you can run them in parallel. Ractor
>> enables you to make thread-safe parallel programs because ractors can
>> not share normal objects. Communication between ractors are supported
>> by exchaning messages.
>>
>> To limit sharing of objects, Ractor introduces several restrictions to
>> the Ruby's syntax (without multiple Ractors, there is no restriction).
>>
>> The specification and implementation are not matured and may be
>> changed in the future, so this feature is marked as experimental and
>> show the "experimental feature" warning when the first `Ractor.new`.
>>
>> The following small program measures the execution time of famous
>> benchmark tak function ([Tak (function) -
>> Wikipedia](https://en.wikipedia.org/wiki/Tak_(function))), by
>> executing it 4 times sequentially or 4 times in parallel with ractors.
>>
>> ``` ruby
>> def tarai(x, y, z) =
>>   x <= y ? y : tarai(tarai(x-1, y, z),
>>                      tarai(y-1, z, x),
>>                      tarai(z-1, x, y))
>> require 'benchmark'
>> Benchmark.bm do |x|
>>   # sequential version
>>   x.report('seq'){ 4.times{ tarai(14, 7, 0) } }
>>
>>   # parallel version
>>   x.report('par'){
>>     4.times.map do
>>       Ractor.new { tarai(14, 7, 0) }
>>     end.each(&:take)
>>   }
>> end
>> ```
>>
>> ```
>> Benchmark result:
>>           user     system      total        real
>> seq  64.560736   0.001101  64.561837 ( 64.562194)
>> par  66.422010   0.015999  66.438009 ( 16.685797)
>> ```
>>
>> The result was　measured on Ubuntu 20.04, Intel(R) Core(TM) i7-6700 (4
>> cores, 8 hardware threads). It shows that the parallel version is 3.87
>> times faster than the sequential version.
>>
>>
>> See [doc/ractor.md](https://github.com/ruby/ruby/blob/master/doc/ractor.md)
>> for more details.
>>
>> ### Fiber Scheduler
>>
>> `Fiber#scheduler` is introduced for intercepting blocking operations.
>> This allows for light-weight concurrency without changing existing
>> code. Watch ["Don't Wait For Me, Scalable Concurrency for Ruby
>> 3"](https://www.youtube.com/watch?v=Y29SSOS4UOc) for an overview of
>> how it works.
>>
>> Currently supported classes/methods:
>>
>> - `Mutex#lock`, `Mutex#unlock`, `Mutex#sleep`
>> - `ConditionVariable#wait`
>> - `Queue#pop`, `SizedQueue#push`
>> - `Thread#join`
>> - `Kernel#sleep`
>> - `Process.wait`
>> - `IO#wait`, `IO#read`, `IO#write` and related methods (e.g.
>> `#wait_readable`, `#gets`, `#puts` and so on).
>> - `IO#select` is *not supported*.
>>
>> This example program will perform several HTTP requests concurrently:
>>
>> ``` ruby
>> require 'async'
>> require 'net/http'
>> require 'uri'
>>
>> Async do
>>   ["ruby", "rails", "async"].each do |topic|
>>     Async do
>>       Net::HTTP.get(URI "https://www.google.com/search?q=#{topic}")
>>     end
>>   end
>> end
>> ```
>>
>> It uses [async](https://github.com/socketry/async) which provides the
>> event loop. This event loop uses the `Fiber#scheduler` hooks to make
>> `Net::HTTP` non-blocking. Other gems can use this interface to provide
>> non-blocking execution for Ruby, and those gems can be compatible with
>> other implementations of Ruby (e.g. JRuby, TruffleRuby) which can
>> support the same non-blocking hooks.
>>
>> ## Static Analysis
>>
>> > 2010s were an age of statically type programming languages. Ruby seeks the future with static type checking, without type declaration, using abstract interpretation. RBS & TypeProf are the first step to the future. More steps to come. --- Matz
>>
>> ### RBS
>>
>> RBS is a language to describe the types of Ruby programs.
>>
>> Type checkers including TypeProf and other tools supporting RBS will
>> understand Ruby programs much better with RBS definitions.
>>
>> You can write down the definition of classes and modules: methods
>> defined in the class, instance variables and their types, and
>> inheritance/mix-in relations.
>>
>> The goal of RBS is to support commonly seen patterns in Ruby programs
>> and it allows writing advanced types including union types, method
>> overloading, and generics. It also supports duck typing with
>> _interface types_.
>>
>> Ruby 3.0 ships with `rbs` gem, which allows parsing and processing
>> type definitions written in RBS.
>> The following is a small example of RBS with class, module, and
>> constant definitions.
>>
>> ``` rbs
>> module ChatApp
>>   VERSION: String
>>   class Channel
>>     attr_reader name: String
>>     attr_reader messages: Array[Message]
>>     attr_reader users: Array[User | Bot]              # `|` means
>> union types, `User` or `Bot`.
>>     def initialize: (String) -> void
>>     def post: (String, from: User | Bot) -> Message   # Method
>> overloading is supported.
>>             | (File, from: User | Bot) -> Message
>>   end
>> end
>> ```
>>
>> See [README of rbs gem](https://github.com/ruby/rbs) for more detail.
>>
>> ### TypeProf
>>
>> TypeProf is a type analysis tool bundled in the Ruby package.
>>
>> Currently, TypeProf serves as a kind of type inference.
>>
>> It reads plain (non-type-annotated) Ruby code, analyzes what methods
>> are defined and how they are used, and generates a prototype of type
>> signature in RBS format.
>>
>> Here is a simple demo of TypeProf.
>>
>> An example input:
>>
>> ``` ruby
>> # test.rb
>> class User
>>   def initialize(name:, age:)
>>     @name, @age = name, age
>>   end
>>   attr_reader :name, :age
>> end
>> User.new(name: "John", age: 20)
>> ```
>>
>> An example output:
>>
>> ```
>> $ typeprof test.rb
>> # Classes
>> class User
>>   attr_reader name : String
>>   attr_reader age : Integer
>>   def initialize : (name: String, age: Integer) -> [String, Integer]
>> end
>> ```
>>
>> You can run TypeProf by saving the input as "test.rb" and invoke a
>> command called "typeprof test.rb".
>>
>> You can also [try TypeProf
>> online](https://mame.github.io/typeprof-playground/#rb=%23+test.rb%0Aclass+User%0A++def+initialize%28name%3A%2C+age%3A%29%0A++++%40name%2C+%40age+%3D+name%2C+age%0A++end%0A++%0A++attr_reader+%3Aname%2C+%3Aage%0Aend%0A%0AUser.new%28name%3A+%22John%22%2C+age%3A+20%29&rbs=).
>> (It runs TypeProf on the server side, so sorry if it is out!)
>>
>> See [the documentation](https://github.com/ruby/typeprof/blob/master/doc/doc.md)
>> and [demos](https://github.com/ruby/typeprof/blob/master/doc/demo.md)
>> for details.
>>
>> TypeProf is experimental and not so mature yet; only a subset of the
>> Ruby language is supported, and the detection of type errors is
>> limited. But it is still growing rapidly to improve the coverage of
>> language features, the analysis performance, and usability. Any
>> feedback is very welcome.
>>
>> ## Other Notable New Features
>>
>> * One-line pattern matching is redesigned.  (experimental)
>>
>>     * `=>` is added. It can be used as like rightward assignment.
>>
>>       ```ruby
>>       0 => a
>>       p a #=> 0
>>
>>       {b: 0, c: 1} => {b:}
>>       p b #=> 0
>>       ```
>>     * `in` is changed to return `true` or `false`.
>>
>>       ```ruby
>>       # version 3.0
>>       0 in 1 #=> false
>>
>>       # version 2.7
>>       0 in 1 #=> raise NoMatchingPatternError
>>       ```
>>
>> * Find pattern is added. (experimental)
>>
>>   ``` ruby
>>   case ["a", 1, "b", "c", 2, "d", "e", "f", 3]
>>   in [*pre, String => x, String => y, *post]
>>     p pre  #=> ["a", 1]
>>     p x    #=> "b"
>>     p y    #=> "c"
>>     p post #=> [2, "d", "e", "f", 3]
>>   end
>>   ```
>>
>> * Endless method definition is added.
>>
>>   ``` ruby
>>   def square(x) = x * x
>>   ```
>>
>> * `Hash#except` is now built-in.
>>
>>   ``` ruby
>>   h = { a: 1, b: 2, c: 3 }
>>   p h.except(:a) #=> {:b=>2, :c=>3}
>>   ```
>>
>> * Memory view is added as an experimental feature
>>
>>     * This is a new C-API set to exchange a raw memory area, such as a
>> numeric array and a bitmap image, between extension libraries.  The
>> extension libraries can share also the metadata of the memory area
>> that consists of the shape, the element format, and so on.  Using
>> these kinds of metadata, the extension libraries can share even a
>> multidimensional array appropriately.  This feature is designed by
>> referring to Python's buffer protocol.
>>
>> ## Performance improvements
>>
>> * Pasting long code to IRB is 53 times faster than bundled with Ruby
>> 2.7.0. For example, the time required to paste [this sample
>> code](https://gist.github.com/aycabta/30ab96334275bced5796f118c9220b0b)
>> goes from 11.7 seconds to 0.22 seconds.
>>
>>
>> <video autoplay="autoplay" controls="controls" muted="muted"
>> width="764" height="510"
>> poster="https://cache.ruby-lang.org/pub/media/ruby-3.0-irb-highspeed.png">
>>   <source src="https://cache.ruby-lang.org/pub/media/ruby-3.0-irb-highspeed.mp4"
>> type="video/mp4">
>> </video>
>>
>>
>> * The `measure` command has been added to IRB. It allows simple
>> execution time measurement.
>>
>>   ```
>>   irb(main):001:0> 3
>>   => 3
>>   irb(main):002:0> measure
>>   TIME is added.
>>   => nil
>>   irb(main):003:0> 3
>>   processing time: 0.000058s
>>   => 3
>>   irb(main):004:0> measure :off
>>   => nil
>>   irb(main):005:0> 3
>>   => 3
>>   ```
>>
>> ## Other notable changes since 2.7
>>
>> * Keyword arguments are separated from other arguments.
>>   * In principle, code that prints a warning on Ruby 2.7 won't work.
>> See the [document](https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0/)
>> in detail.
>>   * By the way, arguments forwarding now supports leading arguments.
>>
>>     ``` ruby
>>     def method_missing(meth, ...)
>>       send(:"do_#{ meth }", ...)
>>     end
>>     ```
>>
>> * Pattern matching (`case/in`) is no longer experimental.
>> * The `$SAFE` feature was completely removed; now it is a normal
>> global variable.
>> * The order of backtrace had been reversed at Ruby 2.5, and is
>> reverted.  Now it behaves like Ruby 2.4; an error message and the line
>> number where the exception occurs are printed first, and its callers
>> are printed later.
>> * Some standard libraries are updated.
>>   * RubyGems 3.2.3
>>   * Bundler 2.2.3
>>   * IRB 1.2.6
>>   * Reline 0.1.5
>>   * Pysch 3.3.0
>>   * JSON 2.5.0
>>   * BigDecimal 3.0.0
>>   * CSV 3.1.9
>>   * Date 3.1.1
>>   * Digest 3.0.0
>>   * Fiddle 1.0.5
>>   * StringIO 3.0.0
>>   * StringScanner 3.0.0
>>   * etc.
>> * The following libraries are no longer bundled gems or standard libraries.
>>   Install the corresponding gems to use these features.
>>   * sdbm
>>   * webrick
>>   * net-telnet
>>   * xmlrpc
>> * The following default gems are now bundled gems.
>>   * rexml
>>   * rss
>> * The following stdlib files are now default gems and are published on
>> rubygems.org.
>>   * English
>>   * abbrev
>>   * base64
>>   * drb
>>   * debug
>>   * erb
>>   * find
>>   * net-ftp
>>   * net-http
>>   * net-imap
>>   * net-protocol
>>   * open-uri
>>   * optparse
>>   * pp
>>   * prettyprint
>>   * resolv-replace
>>   * resolv
>>   * rinda
>>   * set
>>   * securerandom
>>   * shellwords
>>   * tempfile
>>   * tmpdir
>>   * time
>>   * tsort
>>   * un
>>   * weakref
>>   * digest
>>   * io-nonblock
>>   * io-wait
>>   * nkf
>>   * pathname
>>   * syslog
>>   * win32ole
>>
>> See [NEWS](https://github.com/ruby/ruby/blob/v3_0_0/NEWS.md)
>> or [commit logs](https://github.com/ruby/ruby/compare/v2_7_0...v3_0_0)
>> for more details.
>>
>> With those changes, [4028 files changed, 200058 insertions(+), 154063
>> deletions(-)](https://github.com/ruby/ruby/compare/v2_7_0...v3_0_0#file_bucket)
>> since Ruby 2.7.0!
>>
>> > Ruby3.0 is a milestone. The language is evolved, keeping compatibility. But it's not the end. Ruby will keep progressing, and become even greater. Stay tuned! --- Matz
>>
>> Merry Christmas, Happy Holidays, and enjoy programming with Ruby 3.0!
>>
>> ## Download
>>
>> * <https://cache.ruby-lang.org/pub/ruby/3.0/ruby-3.0.0.tar.gz>
>>
>>       SIZE: 19539509
>>       SHA1: 233873708c1ce9fdc295e0ef1c25e64f9b98b062
>>       SHA256: a13ed141a1c18eb967aac1e33f4d6ad5f21be1ac543c344e0d6feeee54af8e28
>>       SHA512: e62f4f63dc12cff424e8a09adc06477e1fa1ee2a9b2b6e28ca22fd52a211e8b8891c0045d47935014a83f2df2d6fc7c8a4fd87f01e63c585afc5ef753e1dd1c1
>>
>> * <https://cache.ruby-lang.org/pub/ruby/3.0/ruby-3.0.0.tar.xz>
>>
>>       SIZE: 14374176
>>       SHA1: c142899d70a1326c5a71311b17168f98c15e5d89
>>       SHA256: 68bfaeef027b6ccd0032504a68ae69721a70e97d921ff328c0c8836c798f6cb1
>>       SHA512: 2a23c2894e62e24bb20cec6b2a016b66d7df05083668726b6f70af8338211cfec417aa3624290d1f5ccd130f65ee7b52b5db7d428abc4a9460459c9a5dd1a450
>>
>> * <https://cache.ruby-lang.org/pub/ruby/3.0/ruby-3.0.0.zip>
>>
>>       SIZE: 23862057
>>       SHA1: 2a9629102d71c7fe7f31a8c91f64e570a40d093c
>>       SHA256: a5e4fa7dc5434a7259e9a29527eeea2c99eeb5e82708f66bb07731233bc860f4
>>       SHA512: e5bf742309d79f05ec1bd1861106f4b103e4819ca2b92a826423ff451465b49573a917cb893d43a98852435966323e2820a4b9f9377f36cf771b8c658f80fa5b
>>
>> ## What is Ruby
>>
>> Ruby was first developed by Matz (Yukihiro Matsumoto) in 1993,
>> and is now developed as Open Source. It runs on multiple platforms
>> and is used all over the world especially for web development.
>>
>> Unsubscribe: <mailto:[e-mail]?subject=unsubscribe>
>> <http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>
>
>
> Unsubscribe: <mailto:[e-mail]?subject=unsubscribe>
> <http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>

Unsubscribe: <mailto:[e-mail]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>