Public

いけむらさんが観たい RubyKaigi 2022

Note for the schedule

This memo will be placed into OGP image when share on SNS.

たぶんぼっちなので仲良くしてください

Start...End time	Track name
01:50 - 03:00 UTC	Lang: ja Track: TrackGrand Auditorium Ruby meets WebAssembly 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. Memo Edit a note for "Ruby meets WebAssembly" /1024 Close Show detail
04:30 - 05:00 UTC	Lang: ja Track: TrackGrand Auditorium Making MaNy threads on Ruby 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. Memo Edit a note for "Making MaNy threads on Ruby" /1024 Close Show detail
05:10 - 05:40 UTC	Lang: en Track: TrackGrand Auditorium Building a Lightweight IR and Backend for YJIT Last year, the YJIT compiler was upstreamed into CRuby and released as part of Ruby 3.1. Key advantages of YJIT are that it delivers fast warm up time and significant speedup on typical Ruby workloads such as Rails applications. However, up to this point, YJIT has only been available on x86-64 platforms. This year, our goal is to transition from an experimental compiler towards something more broadly usable and future-proof. In order to make YJIT available on more platforms, we are currently working on the implementation of a new Intermediate Representation (IR) and backend for the compiler. This will make it possible for YJIT to run natively on the Apple M1/M2, AWS Graviton processors and the Raspberry Pi. This talk will cover our objectives and constraints, the design of our new IR, the strategy we took to be able to support both x86-64 and ARM CPUs, the challenges we encountered, how we plan to optimize the quality of the generated machine code, and early performance results. Memo Edit a note for "Building a Lightweight IR and Backend for YJIT" /1024 Close Show detail
05:50 - 06:20 UTC	Lang: ja Track: TrackGrand Auditorium Tools for Providing rich user experience in debugger 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. Memo Edit a note for "Tools for Providing rich user experience in debugger" /1024 Close Show detail
06:50 - 07:20 UTC	Lang: en Track: TrackGrand Auditorium Towards Ruby 4 JIT 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. Memo Edit a note for "Towards Ruby 4 JIT" /1024 Close Show detail
07:30 - 08:40 UTC	Lang: ja Track: TrackGrand Auditorium TRICK 2022 (Returns) After four years, the programming contest comes back. Memo Edit a note for "TRICK 2022 (Returns)" /1024 Close Show detail

Start...End time	Track name
00:30 - 01:40 UTC	Lang: ja Track: TrackGrand Auditorium Matz Keynote The Matz keynote! Memo Edit a note for "Matz Keynote" /1024 Close Show detail
01:50 - 02:20 UTC	Lang: ja Track: TrackMiddle Auditorium Do Pure Ruby Dream of Encrypted Binary Protocol? A. There is a harsh reality. To implement QUIC, it is necessary to read and write data bit by bit. Furthermore, the data must be encrypted, so proper encryption and decryption must be performed. Programming languages such as C or Rust are suited for such operations. What are the difficulties in implementing such a protocol in Ruby? Memo Edit a note for "Do Pure Ruby Dream of Encrypted Binary Protocol?" /1024 Close Show detail
02:30 - 03:00 UTC	Lang: ja Track: TrackMiddle Auditorium Make RuboCop super fast 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. Memo Edit a note for "Make RuboCop super fast" /1024 Close Show detail
04:30 - 05:00 UTC	Lang: ja Track: TrackGrand Auditorium Method-based JIT compilation by transpiling to Julia 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. Memo Edit a note for "Method-based JIT compilation by transpiling to Julia" /1024 Close Show detail
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 Edit a note for "How fast really is Ruby 3.x?" /1024 Close Show detail
05:50 - 06:20 UTC	Lang: en Track: TrackGrand Auditorium Hunting Production Memory Leaks with Heap Sampling Existing Ruby tooling is quite helpful when investigating memory leaks if and when we can reproduce them on our development machine or staging environment. But what about those cases when the memory leak only really shows up in Production? Perhaps over a long time period? In this talk, we introduce the `ruby_memprofiler_pprof` heap profiling gem, showing how low-overhead heap sampling can be implemented and used to investigate memory leaks in production. We also discuss early production wins when using this technique at Zendesk. Memo Edit a note for "Hunting Production Memory Leaks with Heap Sampling" /1024 Close Show detail
06:50 - 07:20 UTC	Lang: en Track: TrackGrand Auditorium Caching With MessagePack An object cache is like magic: put an object into the box and it comes back later, exactly as it went in. The magic is seductive because it makes things so easy. It only takes a bit of thought, however, to see the dangers of this trick. Class names can change; a method can return a different result. Objects exist in a universe, and that universe is constantly evolving. Marshal, Ruby's default binary serialization library, does not handle changes like this gracefully. We discovered this recently when a code change collided with a cached class, leading to a fire in production. To avoid incidents like this, we switched the cache serializer in our core Rails monolith from Marshal to MessagePack, an alternative, generic binary serializer. MessagePack has a more compact format than Marshal, with stricter typing and less magic. In this talk, I'll crack open MessagePack to show how it works, how we migrated to it, and why you might want to do the same. Memo Edit a note for "Caching With MessagePack" /1024 Close Show detail
07:30 - 08:40 UTC	Lang: ja Track: TrackGrand Auditorium Ruby Committers vs The World Ruby core committers on stage! Memo Edit a note for "Ruby Committers vs The World" /1024 Close Show detail

Start...End time	Track name
00:30 - 01:00 UTC	Lang: en Track: TrackMiddle Auditorium Megaruby - Running mruby/c programs on Sega Mega Drive Have you heard of Sega Mega Drive? It was a very popular video gaming platform back in the 80s and 90s, and now you can run programs on it written in Ruby! I have been working on porting mruby/c to Mega Drive. It now works well enough to run a simple game and I have developed one. I would like to share with you what has been done so far, what I would like to do next, how you can also develop your Mega Drive game with Ruby, and why we should program on platforms like Mega Drive. This will also include a live demo on a Mega Drive unit (or compatible hardware). Memo Edit a note for "Megaruby - Running mruby/c programs on Sega Mega Drive" /1024 Close Show detail
01:10 - 01:40 UTC	Lang: en Track: TrackGrand Auditorium Syntax Tree 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. Memo Edit a note for "Syntax Tree" /1024 Close Show detail
01:50 - 02:20 UTC	Lang: en Track: TrackGrand Auditorium Real World Applications with the Ruby Fiber Scheduler 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. Memo Edit a note for "Real World Applications with the Ruby Fiber Scheduler" /1024 Close Show detail
02:30 - 03:00 UTC	Lang: en Track: TrackGrand Auditorium A Faster CRuby interpreter with dynamically specialized IR 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. Memo Edit a note for "A Faster CRuby interpreter with dynamically specialized IR" /1024 Close Show detail
04:30 - 05:00 UTC	Lang: en Track: TrackGrand Auditorium Automatically Find Memory Leaks in Native Gems Ruby apps are known to leak memory which causes performance degradation. This eventually results in the system running out of memory and killing the Ruby process. Often, this is caused by a buggy native gem that forgot to clean up unused memory. It's time to fix this problem. Introducing ruby_memcheck, a gem that automatically finds memory leaks in native gems, powered by Valgrind Memcheck. In this talk, we'll discuss memory leaks, the Valgrind Memcheck tool, and how ruby_memcheck works. Memo Edit a note for "Automatically Find Memory Leaks in Native Gems" /1024 Close Show detail
05:10 - 05:40 UTC	Lang: ja Track: TrackGrand Auditorium Fast data processing with Ruby and Apache Arrow I introduced Ruby and Apache Arrow integration including the "super fast large data interchange and processing" Apache Arrow feature at [RubyKaigi Takeout 2021](https://rubykaigi.org/2021-takeout/presentations/ktou.html). This talk introduces how we can use the "super fast large data interchange and processing" Apache Arrow feature in Ruby. Here are some use cases: * Fast data retrieval (fast `pluck`) from DB such as MySQL and PostgreSQL for batch processes in a Ruby on Rails application * Fast data interchange with JavaScript for dynamic visualization in a Ruby on Rails application * Fast OLAP with in-process DB such as DuckDB and Apache Arrow DataFusion in a Ruby on Rails application or irb session Memo Edit a note for "Fast data processing with Ruby and Apache Arrow" /1024 Close Show detail
05:50 - 06:20 UTC	Lang: en Track: TrackGrand Auditorium Fixing Assignment Evaluation Order 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. Memo Edit a note for "Fixing Assignment Evaluation Order" /1024 Close Show detail
06:50 - 07:20 UTC	Lang: ja Track: TrackMiddle Auditorium History of Japanese Ruby reference manual, and future I will talk about history of Japanese reference manual and future plans. Contributing to current Japanese Ruby reference manual (rurema) is harder than other projects. Because current document format (based on RD) is not familiar to recent Ruby users, and there are a few documents for new contributors. So I will explain historical reasons and how to improve systems for new contributors. Memo Edit a note for "History of Japanese Ruby reference manual, and future" /1024 Close Show detail
07:30 - 08:40 UTC	Lang: en Track: TrackGrand Auditorium Stories from developing YJIT 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? Memo Edit a note for "Stories from developing YJIT" /1024 Close Show detail