| Start...End time | Track name |
|---|---|
|
00:30 - 01:00 UTC |
Lang: ja
Track: TrackGrand Auditorium
error_highlight: user-friendly error diagnosticsRuby 3.1 has introduced a gem called "error_highlight", which shows a code snippet with an underline to spot where `NameError` or `NoMethodError` was raised. ``` $ ruby test.rb test.rb:1:in `<main>': undefined method `[]' for nil:NilClass (NoMethodError) json[:foo][:bar] ^^^^^^ ``` We will talk about the design and implementation of error_highlight: how it works, why and how we designed it, how we resolved the difficulties we faced during implementation, and the feedback we received. This feature goes further in Ruby 3.2: more error support other than `NameError`/`NoMethodError` and more fine-grained error spotting. We also redesigned its backend by introducing a new API, `Exception#detailed_message`, which allows us to enhance error messages with fewer incompatibilities. In fact, it allowed simple integration with other error message extensions such as did_you_mean and dead_end. We will also talk about what we would like users to help us with to make error_highlight better. Memo |
|
01:10 - 01:40 UTC |
Lang: en
Track: TrackGrand Auditorium
Syntax TreeSyntax Tree is a new toolkit for interacting with the Ruby parse tree. It can be used to analyze, inspect, debug, and format your Ruby code. In this talk we'll walk through how it works, how to use it in your own applications, and the exciting future possibilities enabled by Syntax Tree. Memo |
|
01:50 - 02:20 UTC |
Lang: en
Track: TrackGrand Auditorium
Real World Applications with the Ruby Fiber SchedulerRuby 3 introduced the fiber scheduler which provides transparent context switching between fibers when they perform blocking operations. With minimal changes, web applications can take advantage of the fiber scheduler to improve performance and unlock new techniques for application design and interactivity. We discuss the current state of the fiber scheduler design, its usage in several real world applications, and how you can take advantage of it in your own projects. Memo |
|
02:30 - 03:00 UTC |
Lang: en
Track: TrackGrand Auditorium
A Faster CRuby interpreter with dynamically specialized IRA new CRuby internal representation (IR) dynamically specialized during execution will be presented. The major specialization includes generation of * Hybrid stack-RTL instructions * Type specialized instructions using basic block versioning technique * Speculatively specialized instructions based on profile-based information Deoptimization technique of speculatively specialized instructions when the original assumptions become wrong will be also discussed. Using specialized IR can significantly speed up the interpretation and can permit generation of effective JIT code with static compilers like MIR or GCC. The new IR can be also used to implement Ruby specific optimizations, e.g. inlining. Performance comparison of CRuby interpreter with the specialized IR, the current CRuby interpreter, YJIT, and MJIT will be given for some benchmarks. Memo |
|
04:30 - 05:00 UTC |
Lang: ja
Track: TrackMiddle Auditorium
The Better RuboCop World to enjoy RubyTools like RuboCop are very useful. I am very grateful for contributors. I think it's really helpful to keep our code clean and consistent. However, sometimes I feel there is a gap between 'Cop' culture and Ruby culture. In general, 'Cop' restricts our rights though Ruby gives freedom to us. I understand we have right not to use RuboCop or disable some Cops. But it is not very easy in reality, especially for Ruby beginners in their teams. To make them happier, experts would be able to set up config perfectly. But again, it is not very easy in reality. As a result, even though there is no evil, in some case people wrongfully make detour and give up their creativeness to keep CI green. It's a pity, isn't it? In this talk, I introduce my thoughts on RubyCop and programming and some idea of a bit better RuboCop world, with lower risk to damage productivity and to misguide beginners. Memo |
|
05:10 - 05:40 UTC |
Lang: en
Track: TrackMiddle Auditorium
Ethereum for RubyThis talk will cover the use of Ruby libraries that interact with the Ethereum blockchain and their implementation. You will get an overview of the Ethereum ecosystem, how blockchain transactions work, how signatures work, and learn how to use eth.rb. How it is implemented in Ruby code will also be explained. Lets create a web application that connects to the blockchain together. Memo |
|
05:50 - 06:20 UTC |
Lang: en
Track: TrackGrand Auditorium
Fixing Assignment Evaluation OrderFor a long time, Ruby's assignment evaluation order was inconsistent. Normal assignment would evaluate the left hand side before the right hand side, but multiple assignment and constant assignment would evaluate the right hand side first. This issue was known since before the release of Ruby 1.9.3, but it was considered difficult to fix. Come learn how we fixed evaluation order for multiple assignment in Ruby 3.1, and evaluation order for constant assignment in Ruby 3.2. Memo |
|
06:50 - 07:20 UTC |
Lang: en
Track: TrackGrand Auditorium
Ruby programming with types in actionI have been developing Steep, a static type checker for Ruby, for more than five years. Let's see how it transforms an editor into an IDE and how the Ruby programming experience changes with it. This session includes a live coding using Steep. It will start with writing the RBS type definitions, then demonstrate Ruby coding with IDE assistance, and finally refactor the code. This is how I write new Ruby code and will show the benefits of using Steep. Memo |
|
07:30 - 08:40 UTC |
Lang: en
Track: TrackGrand Auditorium
Stories from developing YJITYJIT is CRuby's second just-in-time compiler first released with Ruby 3.1.0. Much sweat and tears were shed during YJIT's development. What are the performance goals of YJIT and how are we going for them? How do CPUs react to YJIT's output? What is it like to retrofit a JIT compiler into a runtime system with a long history? Why is Rust involved now? Memo |
00:30 - 01:00
Ruby 3.1 has introduced a gem called "error_highlight", which shows a code snippet with an underline to spot where `NameError` or `NoMethodError` was raised. ``` $ ruby test.rb test.rb:1:in `<main>': undefined method `[]' for nil:NilClass (NoMethodError) json[:foo][:bar] ^^^^^^ ``` We will talk about the design and implementation of error_highlight: how it works, why and how we designed it, how we resolved the difficulties we faced during implementation, and the feedback we received. This feature goes further in Ruby 3.2: more error support other than `NameError`/`NoMethodError` and more fine-grained error spotting. We also redesigned its backend by introducing a new API, `Exception#detailed_message`, which allows us to enhance error messages with fewer incompatibilities. In fact, it allowed simple integration with other error message extensions such as did_you_mean and dead_end. We will also talk about what we would like users to help us with to make error_highlight better.
01:10 - 01:40
Syntax Tree is a new toolkit for interacting with the Ruby parse tree. It can be used to analyze, inspect, debug, and format your Ruby code. In this talk we'll walk through how it works, how to use it in your own applications, and the exciting future possibilities enabled by Syntax Tree.
01:50 - 02:20
Ruby 3 introduced the fiber scheduler which provides transparent context switching between fibers when they perform blocking operations. With minimal changes, web applications can take advantage of the fiber scheduler to improve performance and unlock new techniques for application design and interactivity. We discuss the current state of the fiber scheduler design, its usage in several real world applications, and how you can take advantage of it in your own projects.
02:30 - 03:00
A new CRuby internal representation (IR) dynamically specialized during execution will be presented. The major specialization includes generation of * Hybrid stack-RTL instructions * Type specialized instructions using basic block versioning technique * Speculatively specialized instructions based on profile-based information Deoptimization technique of speculatively specialized instructions when the original assumptions become wrong will be also discussed. Using specialized IR can significantly speed up the interpretation and can permit generation of effective JIT code with static compilers like MIR or GCC. The new IR can be also used to implement Ruby specific optimizations, e.g. inlining. Performance comparison of CRuby interpreter with the specialized IR, the current CRuby interpreter, YJIT, and MJIT will be given for some benchmarks.
04:30 - 05:00
Tools like RuboCop are very useful. I am very grateful for contributors. I think it's really helpful to keep our code clean and consistent. However, sometimes I feel there is a gap between 'Cop' culture and Ruby culture. In general, 'Cop' restricts our rights though Ruby gives freedom to us. I understand we have right not to use RuboCop or disable some Cops. But it is not very easy in reality, especially for Ruby beginners in their teams. To make them happier, experts would be able to set up config perfectly. But again, it is not very easy in reality. As a result, even though there is no evil, in some case people wrongfully make detour and give up their creativeness to keep CI green. It's a pity, isn't it? In this talk, I introduce my thoughts on RubyCop and programming and some idea of a bit better RuboCop world, with lower risk to damage productivity and to misguide beginners.
05:10 - 05:40
This talk will cover the use of Ruby libraries that interact with the Ethereum blockchain and their implementation. You will get an overview of the Ethereum ecosystem, how blockchain transactions work, how signatures work, and learn how to use eth.rb. How it is implemented in Ruby code will also be explained. Lets create a web application that connects to the blockchain together.
05:50 - 06:20
For a long time, Ruby's assignment evaluation order was inconsistent. Normal assignment would evaluate the left hand side before the right hand side, but multiple assignment and constant assignment would evaluate the right hand side first. This issue was known since before the release of Ruby 1.9.3, but it was considered difficult to fix. Come learn how we fixed evaluation order for multiple assignment in Ruby 3.1, and evaluation order for constant assignment in Ruby 3.2.
06:50 - 07:20
I have been developing Steep, a static type checker for Ruby, for more than five years. Let's see how it transforms an editor into an IDE and how the Ruby programming experience changes with it. This session includes a live coding using Steep. It will start with writing the RBS type definitions, then demonstrate Ruby coding with IDE assistance, and finally refactor the code. This is how I write new Ruby code and will show the benefits of using Steep.
07:30 - 08:40
YJIT is CRuby's second just-in-time compiler first released with Ruby 3.1.0. Much sweat and tears were shed during YJIT's development. What are the performance goals of YJIT and how are we going for them? How do CPUs react to YJIT's output? What is it like to retrofit a JIT compiler into a runtime system with a long history? Why is Rust involved now?
| Start...End time | Track name |
|---|---|
|
01:50 - 03:00 UTC |
Lang: ja
Track: TrackGrand Auditorium
Ruby meets WebAssemblyWebAssembly (Wasm) is a binary format for programs written in any language, designed to eventually run everywhere without changes, mainly inside Web browsers. Wasm is now used beyond the Web, from edge computing to smart contracts in blockchain. Now CRuby can be compiled to WebAssembly, which can be run in web browsers and many non-web environments with WASI. This talk will give you how we got there, techniques, and its use cases. Memo |
|
04:30 - 05:00 UTC |
Lang: ja
Track: TrackGrand Auditorium
Making *MaNy* threads on RubyWe will introduce *MaNy* project: supports massive number of threads on Ruby. Concurrent mchanism (threads, processes, etc.) is an important language feature especially for multiple network connections. Ruby supports Ractor/Thread/Fiber for concurrency. However making many Threads (and Ractors) introduce huge overhead. Fiber scheduler was introduced for this purpose but it has some limitations. On the other languages, for example, Go language supports goroutine. They can make many goroutines and they can run concurrently or in parallel. Other languages (Erlang, Rust, ...) also support similar features. They use a well-known technique called M:N threading. In short, M:N threading supports many M threads on N (enough small number) system threads. *MaNy* project introduces M:N threading into Ruby. In this talk, we will show the background and progress of *MaNy* project. Because we are replacing the threading mechanism of current Ruby, we can share some details about it. Memo |
|
05:10 - 05:40 UTC |
Lang: ja
Track: TrackMiddle Auditorium
Types teaches success, what will we do?Are there “Types" of Ruby in the project you are involved with? Starting with Ruby 3.0, RBS and Steep are bundled, and Ruby now has static Types. Unfortunately, many projects have not yet introduced Types, I think. One reason for this is the lack of gem Types used in many projects. In this talk, I propose a contribution to `gem_rbs_collection` as one of the things we can do to promote the Type Ecosystem in Ruby. I'll walk you step by step through the process of contributing to `gem_rbs_collection` so that you can commit without hesitation when the opportunity arises. If more Rubyists become interested in gem_rbs_collection as a result of this talk, it is expected to accelerate the spread of the Type ecosystem. Memo |
|
05:50 - 06:20 UTC |
Lang: ja
Track: TrackGrand Auditorium
Tools for Providing rich user experience in debuggerruby/debug is one of the very active projects, and many users use it. Also, there are some hidden valuable features to enhance your development experience. This talk dives into Chrome integration and History Viewer within them. Chrome integration: Debugging with Chrome DevTools is the one of popular ways, especially in JavaScript. The advantages of Chrome DevTools are easy setup and a rich user experience. You don't have to install any tools except for Chrome. History Viewer: What do you do when you want to step back to the specified line? History Viewer can help you in the situation. History Viewer, which extends stepping back, is the feature in VSCode extension for ruby/debug. You can go back to the location without thinking about how many times "step back" commands are needed. In this talk, I will introduce how to use them and how they work, such as how to communicate between ruby/debug and Chrome DevTools. Memo |
|
06:50 - 07:20 UTC |
Lang: en
Track: TrackGrand Auditorium
Towards Ruby 4 JITFrom Ruby 3.1, we started to see CRuby's JIT compilers optimize real-world applications like Rails. However, you might be still wondering whether you should run it on production or not, given the fact that we're only seeing the beginning of the improvement. How far can we go in the foreseeable future? What would the impact on your production application look like? Let's talk about that together. Memo |
|
07:30 - 08:40 UTC |
Lang: ja
Track: TrackGrand Auditorium
TRICK 2022 (Returns)After four years, the programming contest comes back. Memo |
01:50 - 03:00
WebAssembly (Wasm) is a binary format for programs written in any language, designed to eventually run everywhere without changes, mainly inside Web browsers. Wasm is now used beyond the Web, from edge computing to smart contracts in blockchain. Now CRuby can be compiled to WebAssembly, which can be run in web browsers and many non-web environments with WASI. This talk will give you how we got there, techniques, and its use cases.
04:30 - 05:00
We will introduce *MaNy* project: supports massive number of threads on Ruby. Concurrent mchanism (threads, processes, etc.) is an important language feature especially for multiple network connections. Ruby supports Ractor/Thread/Fiber for concurrency. However making many Threads (and Ractors) introduce huge overhead. Fiber scheduler was introduced for this purpose but it has some limitations. On the other languages, for example, Go language supports goroutine. They can make many goroutines and they can run concurrently or in parallel. Other languages (Erlang, Rust, ...) also support similar features. They use a well-known technique called M:N threading. In short, M:N threading supports many M threads on N (enough small number) system threads. *MaNy* project introduces M:N threading into Ruby. In this talk, we will show the background and progress of *MaNy* project. Because we are replacing the threading mechanism of current Ruby, we can share some details about it.
05:10 - 05:40
Are there “Types" of Ruby in the project you are involved with? Starting with Ruby 3.0, RBS and Steep are bundled, and Ruby now has static Types. Unfortunately, many projects have not yet introduced Types, I think. One reason for this is the lack of gem Types used in many projects. In this talk, I propose a contribution to `gem_rbs_collection` as one of the things we can do to promote the Type Ecosystem in Ruby. I'll walk you step by step through the process of contributing to `gem_rbs_collection` so that you can commit without hesitation when the opportunity arises. If more Rubyists become interested in gem_rbs_collection as a result of this talk, it is expected to accelerate the spread of the Type ecosystem.
05:50 - 06:20
ruby/debug is one of the very active projects, and many users use it. Also, there are some hidden valuable features to enhance your development experience. This talk dives into Chrome integration and History Viewer within them. Chrome integration: Debugging with Chrome DevTools is the one of popular ways, especially in JavaScript. The advantages of Chrome DevTools are easy setup and a rich user experience. You don't have to install any tools except for Chrome. History Viewer: What do you do when you want to step back to the specified line? History Viewer can help you in the situation. History Viewer, which extends stepping back, is the feature in VSCode extension for ruby/debug. You can go back to the location without thinking about how many times "step back" commands are needed. In this talk, I will introduce how to use them and how they work, such as how to communicate between ruby/debug and Chrome DevTools.
06:50 - 07:20
From Ruby 3.1, we started to see CRuby's JIT compilers optimize real-world applications like Rails. However, you might be still wondering whether you should run it on production or not, given the fact that we're only seeing the beginning of the improvement. How far can we go in the foreseeable future? What would the impact on your production application look like? Let's talk about that together.
07:30 - 08:40
After four years, the programming contest comes back.
| Start...End time | Track name |
|---|---|
|
00:30 - 01:40 UTC |
|
|
01:50 - 02:20 UTC |
Lang: en
Track: TrackGrand Auditorium
Ruby debugger - The best investment for your productivityIn this talk, I want to show you how adopting the Ruby debugger (`ruby/debug`) can be the single best thing to improve your productivity. It will include: - The difference between puts debugging, REPL (`Pry`/`IRB`) debugging and debugger debugging - Comparison with byebug - How you can use debugger to achieve even better puts and REPL debugging result: - Replace REPL debugging with breakpoint commands - Replace puts debugging with tracing and context commands - Automate debugging steps with `do:` and `pre:` options - Remote debugging capability - The debugging tooling spectrum and when you should **not** use the debugger Memo |
|
02:30 - 03:00 UTC |
Lang: ja
Track: TrackMiddle Auditorium
Make RuboCop super fastRuboCop introduces the new server options for super fast mode. RuboCop 2.0 has the catchphrase RuboCop 2x2, like Ruby 3x3. the server mode is a big move towards that. This is perfect for the current era where quick feedback to developer is required, especially when interacting with text editors and IDEs. Through the design and implementation of server options, you will get the essence of how fast RuboCop works. Memo |
|
04:30 - 05:00 UTC |
Lang: ja
Track: TrackGrand Auditorium
Method-based JIT compilation by transpiling to JuliaI will demonstrate a new approach to the method-based Just-In-Time compilation for Ruby. This is used Julia language as an infrastructure of the JIT compilation. I will describe the characteristics of this approach and show you some example results. Memo |
|
05:10 - 05:40 UTC |
Lang: ja
Track: TrackMiddle Auditorium
How fast really is Ruby 3.x?Ruby 3 brings novel improvements such as YJIT and Ractor, but the extent to which these techniques can speed up real applications is unknown. Performance claims should not be accepted solely based on abstract theories or micro benchmarks, but by the supporting evidence from actual applications. We recently ported a large-scale, open-source Ruby application (Fluentd) to Ruby 3, and conducted a survey to obtain an estimate of the speed improvements over Ruby 2.x. This talk will explain and discuss the results. Memo |
|
05:50 - 06:20 UTC |
Lang: ja
Track: TrackMiddle Auditorium
Packet analysis with mruby on Wireshark - dRuby as exampleWireshark is a very popular network traffic analyzer that supports not only many popular network protocols, but also custom protocols by adding an extension plugin called "dissector".' Currently, Wireshark provides APIs to develop dissectors in Lua and C only. It’s a little disappointing for us Rubyists, we cannot write Ruby for developing Wireshark dissectors. So I have created an extension for Wireshark that makes it possible to easily add dissector by writing a configuration file via Ruby DSL, allowing you to analyze any protocols. It is accomplished by embedding mruby into Wireshark and wrapping Wireshark’s C API with Ruby. This presentation will show its usage and implementation, and as an example, how to analyze dRuby (familiar to all Rubyists!) packets. Memo |
|
06:50 - 07:20 UTC |
Lang: ja
Track: TrackMiddle Auditorium
Create my own search engine.What do you do after reading the search engine textbook? In this talk, I will explain about the creation of my own search engine. I needed a search engine for Pokemon TCG decks. I will explain the implementation of this search engine and the technique of operation on Heroku. Memo |
|
07:30 - 08:40 UTC |
Lang: ja
Track: TrackGrand Auditorium
Ruby Committers vs The WorldRuby core committers on stage! Memo |
00:30 - 01:40
01:50 - 02:20
In this talk, I want to show you how adopting the Ruby debugger (`ruby/debug`) can be the single best thing to improve your productivity. It will include: - The difference between puts debugging, REPL (`Pry`/`IRB`) debugging and debugger debugging - Comparison with byebug - How you can use debugger to achieve even better puts and REPL debugging result: - Replace REPL debugging with breakpoint commands - Replace puts debugging with tracing and context commands - Automate debugging steps with `do:` and `pre:` options - Remote debugging capability - The debugging tooling spectrum and when you should **not** use the debugger
02:30 - 03:00
RuboCop introduces the new server options for super fast mode. RuboCop 2.0 has the catchphrase RuboCop 2x2, like Ruby 3x3. the server mode is a big move towards that. This is perfect for the current era where quick feedback to developer is required, especially when interacting with text editors and IDEs. Through the design and implementation of server options, you will get the essence of how fast RuboCop works.
04:30 - 05:00
I will demonstrate a new approach to the method-based Just-In-Time compilation for Ruby. This is used Julia language as an infrastructure of the JIT compilation. I will describe the characteristics of this approach and show you some example results.
05:10 - 05:40
Ruby 3 brings novel improvements such as YJIT and Ractor, but the extent to which these techniques can speed up real applications is unknown. Performance claims should not be accepted solely based on abstract theories or micro benchmarks, but by the supporting evidence from actual applications. We recently ported a large-scale, open-source Ruby application (Fluentd) to Ruby 3, and conducted a survey to obtain an estimate of the speed improvements over Ruby 2.x. This talk will explain and discuss the results.
05:50 - 06:20
Wireshark is a very popular network traffic analyzer that supports not only many popular network protocols, but also custom protocols by adding an extension plugin called "dissector".' Currently, Wireshark provides APIs to develop dissectors in Lua and C only. It’s a little disappointing for us Rubyists, we cannot write Ruby for developing Wireshark dissectors. So I have created an extension for Wireshark that makes it possible to easily add dissector by writing a configuration file via Ruby DSL, allowing you to analyze any protocols. It is accomplished by embedding mruby into Wireshark and wrapping Wireshark’s C API with Ruby. This presentation will show its usage and implementation, and as an example, how to analyze dRuby (familiar to all Rubyists!) packets.
06:50 - 07:20
What do you do after reading the search engine textbook? In this talk, I will explain about the creation of my own search engine. I needed a search engine for Pokemon TCG decks. I will explain the implementation of this search engine and the technique of operation on Heroku.
07:30 - 08:40
Ruby core committers on stage!