| Start...End time | TrackA | TrackB |
|---|---|---|
|
01:00 - 01:55 UTC |
Lang: ja
Track: TrackA
TypeProf for IDE: Enrich Dev-Experience without AnnotationsRuby 3.0 comes bundled with TypeProf, a code analysis tool that doesn't require so many type annotations. Its primary goal is to create type signatures for existing Ruby programs and help users to apply some external type checkers like Steep. Since the release, we have made an effort to adapt TypeProf to an integrated development environment (IDE), which allows users to enjoy many features supported in an IDE, such as browsing method type signatures inferred on the fly, find definition, find references, error checking, etc. We demonstrate TypeProf for IDE, and present its roadmap. |
|
|
02:00 - 02:25 UTC |
Lang: en & ja
Track: TrackA
Why Ruby's JIT was slowIn Ruby 2.6, we started to use a JIT compiler architecture called "MJIT", which uses a C compiler to generate native code. While it achieved Ruby 3x3 in one benchmark, we had struggled to optimize web application workloads like Rails with MJIT. The good news is we recently figured out why. In this talk, you will hear how JIT architectures impact various benchmarks differently, and why it matters for *you*. You may or may not benefit from Ruby's JIT, depending on what JIT architecture we'll choose beyond the current MJIT. Let's discuss which direction we'd like to go. |
|
|
04:00 - 04:25 UTC |
Lang: en
Track: TrackA
Optimizing Partial Backtraces in Ruby 3Backtraces are very useful tools when debugging problems in Ruby programs. Unfortunately, backtrace generation is expensive for deep callstacks. In older versions of Ruby, this is true even if you only want a partial backtrace, such as a single backtrace frame. Thankfully, Ruby 3 has been optimized so that it no longer processes unnecessary backtrace frames, which can greatly speed up the generation of partial backtraces. Join me for an interesting look a Ruby backtraces, how they are generated, how we optimized partial backtraces in Ruby 3, and how we fixed bugs in the optimization in 3.0.1. |
Lang: ja
Track: TrackB
RuboCop in 2021: Stable and BeyondRuboCop 1.0 stable version was released last year. Well, RuboCop v1 provided a background to stable upgrade. On the other hand, RuboCop supports various coding styles and the development is a struggle against false positives and false negatives. So, the improvement must go on. This presentation shows behind the scenes of development to make RuboCop and environment surrounding it better. Finally, I will show several ideas for future RuboCop. Through this talk, you will know about benefits and considerations for upgrading RuboCop. |
|
04:30 - 04:55 UTC |
Lang: en
Track: TrackA
Ruby Archaeology### In 2009 _why tweeted: "programming is rather thankless. you see your works become replaced by superior works in a year. unable to run at all in a few more." __I take this as a call to action to run old code.__ In this talk we dig, together, through historical Ruby. We will have fun excavating interesting gems from the past. Further, I will answer the following questions: * What code greater than 12 years old still runs in Ruby 3.0? * What idioms have changed? * _And for the brave_: how can you set up an environment to run Ruby 1.8 code from ~2008 on a modern machine? |
Lang: ja
Track: TrackB
The Art of Execution Control for Ruby's DebuggerWe introduce `debug.gem` ([ruby/debug: Debugging functionality for Ruby](https://github.com/ruby/debug)), the fastest debugger for Ruby and how to make it. Existing debuggers have performance penalty to control execution. `debug.gem` uses recently introduced `TracePoint` features to mange execution and there is (almost) no penalties. `debug.gem` has more interesting features: * Remote debugging * IDE (VSCode) Integration * Thread/Ractor support * and more In this presentation, we introduce newly created `debug.gem` and show the tricks to make the *fastest* debugger. |
|
05:00 - 05:25 UTC |
Lang: en
Track: TrackA
Variable Width Allocation: Optimizing Ruby's Memory LayoutRuby’s current memory model assumes all objects live in fixed size slots. This means that object data is often stored outside of the Ruby heap, which has implications: an object's data can be scattered across many locations, increasing complexity and causing poor locality resulting in reduced efficiency of CPU caches. Join us as we explore how our Variable Width Allocation project will move system heap memory into Ruby heap memory, reducing system heap allocations and giving us finer control of the memory layout to optimize for performance. |
Lang: ja
Track: TrackB
Toycol: Define your own application protocolTCP/IP is the protocol stack where each layer is independent. So what is a protocol? - It is a set of rules for communication between network nodes. What if you could change these rules at will? For example, why not change our familiar HTTP/1.x to a different communication style? I’ve created a minimal framework that translates the custom toy application protocol for the Web into HTTP/1.x, with which you can define the protocol that clients and servers understand. In this talk, I'd like to show the flexibility of this framework with some examples of both nodes that speak in given protocols. |
|
05:30 - 05:55 UTC |
Lang: en
Track: TrackA
Parallel testing with Ractors: putting CPUs to workParallelizing tests is an opportune way of reducing the total runtime for a test suite. Rails achieves this by forking multiple separate workers that fetch tests from a queue. In Ruby 3, Ractors introduced new mechanisms for executing code in parallel. Can they be leveraged by a test framework? And how would that compare to current parallelization solutions? Let’s find the answers to these questions by building a test framework built on Ractors, from scratch. We’ll compare the current solutions for parallelization and what advantages or limitations Ractors bring when used in this context. |
Lang: ja
Track: TrackB
dRuby in the real-world embedded systems.We will report an example of using dRuby and CRuby (not mruby) in embedded software for small medical devices. In this talk, we will discuss the architecture of our products. |
|
06:00 - 06:25 UTC |
Lang: en
Track: TrackA
Regular Expressions: Amazing and DangerousMany Ruby programmers use regular expressions frequently. They are an amazingly powerful tool for many different kinds of text processing. However, if not used carefully, they can also be dangerous: They may not exactly match what their writer thinks they match, and they may execute very slowly on certain inputs. This talk will help you understand regular expressions better, so that you can make good use of their amazing power while avoiding their dangerous sides. It will also discuss recent changes to Ruby in the area of regular expressions. |
Lang: en
Track: TrackB
Story of Rucy - How to "compile" a BPF binary from RubyBPF is a technology used in Linux for packet filtering, tracing or access auditing. BPF has its own VM and set of opcodes. If you want to write a program that loads and uses BPF binary, you can write it in any language including Ruby. However, to prepare a "BPF binary" itself, you generally need to write a bit weird C, and pass it to clang compiler using `bpf` target. Wouldn't it be great if we could make these BPF binaries entirely in Ruby? Rucy is intended to allow programmers to write their whole BPF programs in Ruby. I'll discuss how to "compile" BPF binaries from Ruby in this talk. |
|
06:30 - 06:55 UTC |
Lang: en
Track: TrackA
Demystifying DSLs for better analysis and understandingThe ability to create DSLs is one of the biggest strengths of Ruby. They allow us to write easy to use interfaces and reduce the need for boilerplate code. On the flip side, DSLs encapsulate complex logic which makes it hard for developers to understand what's happening under the covers. Surfacing DSLs as static artifacts makes working with them much easier. Generating RBI/RBS files that declare the methods which are dynamically created at runtime, allows static analyzers like Sorbet or Steep to work with DSLs. This also allows for better developers tooling and as some kind of "DSL linter". |
Lang: ja
Track: TrackB
Falling down from FreeBSDIntroduction of mruby on YABM Why I started mruby on YABM(Yet Another Bare Metal). I describe inside of mruby and how to use it. Also I talked about IoT use case. |
01:00 - 01:55
Ruby 3.0 comes bundled with TypeProf, a code analysis tool that doesn't require so many type annotations. Its primary goal is to create type signatures for existing Ruby programs and help users to apply some external type checkers like Steep. Since the release, we have made an effort to adapt TypeProf to an integrated development environment (IDE), which allows users to enjoy many features supported in an IDE, such as browsing method type signatures inferred on the fly, find definition, find references, error checking, etc. We demonstrate TypeProf for IDE, and present its roadmap.
02:00 - 02:25
In Ruby 2.6, we started to use a JIT compiler architecture called "MJIT", which uses a C compiler to generate native code. While it achieved Ruby 3x3 in one benchmark, we had struggled to optimize web application workloads like Rails with MJIT. The good news is we recently figured out why. In this talk, you will hear how JIT architectures impact various benchmarks differently, and why it matters for *you*. You may or may not benefit from Ruby's JIT, depending on what JIT architecture we'll choose beyond the current MJIT. Let's discuss which direction we'd like to go.
04:00 - 04:25
Backtraces are very useful tools when debugging problems in Ruby programs. Unfortunately, backtrace generation is expensive for deep callstacks. In older versions of Ruby, this is true even if you only want a partial backtrace, such as a single backtrace frame. Thankfully, Ruby 3 has been optimized so that it no longer processes unnecessary backtrace frames, which can greatly speed up the generation of partial backtraces. Join me for an interesting look a Ruby backtraces, how they are generated, how we optimized partial backtraces in Ruby 3, and how we fixed bugs in the optimization in 3.0.1.
RuboCop 1.0 stable version was released last year. Well, RuboCop v1 provided a background to stable upgrade. On the other hand, RuboCop supports various coding styles and the development is a struggle against false positives and false negatives. So, the improvement must go on. This presentation shows behind the scenes of development to make RuboCop and environment surrounding it better. Finally, I will show several ideas for future RuboCop. Through this talk, you will know about benefits and considerations for upgrading RuboCop.
04:30 - 04:55
### In 2009 _why tweeted: "programming is rather thankless. you see your works become replaced by superior works in a year. unable to run at all in a few more." __I take this as a call to action to run old code.__ In this talk we dig, together, through historical Ruby. We will have fun excavating interesting gems from the past. Further, I will answer the following questions: * What code greater than 12 years old still runs in Ruby 3.0? * What idioms have changed? * _And for the brave_: how can you set up an environment to run Ruby 1.8 code from ~2008 on a modern machine?
We introduce `debug.gem` ([ruby/debug: Debugging functionality for Ruby](https://github.com/ruby/debug)), the fastest debugger for Ruby and how to make it. Existing debuggers have performance penalty to control execution. `debug.gem` uses recently introduced `TracePoint` features to mange execution and there is (almost) no penalties. `debug.gem` has more interesting features: * Remote debugging * IDE (VSCode) Integration * Thread/Ractor support * and more In this presentation, we introduce newly created `debug.gem` and show the tricks to make the *fastest* debugger.
05:00 - 05:25
Ruby’s current memory model assumes all objects live in fixed size slots. This means that object data is often stored outside of the Ruby heap, which has implications: an object's data can be scattered across many locations, increasing complexity and causing poor locality resulting in reduced efficiency of CPU caches. Join us as we explore how our Variable Width Allocation project will move system heap memory into Ruby heap memory, reducing system heap allocations and giving us finer control of the memory layout to optimize for performance.
TCP/IP is the protocol stack where each layer is independent. So what is a protocol? - It is a set of rules for communication between network nodes. What if you could change these rules at will? For example, why not change our familiar HTTP/1.x to a different communication style? I’ve created a minimal framework that translates the custom toy application protocol for the Web into HTTP/1.x, with which you can define the protocol that clients and servers understand. In this talk, I'd like to show the flexibility of this framework with some examples of both nodes that speak in given protocols.
05:30 - 05:55
Parallelizing tests is an opportune way of reducing the total runtime for a test suite. Rails achieves this by forking multiple separate workers that fetch tests from a queue. In Ruby 3, Ractors introduced new mechanisms for executing code in parallel. Can they be leveraged by a test framework? And how would that compare to current parallelization solutions? Let’s find the answers to these questions by building a test framework built on Ractors, from scratch. We’ll compare the current solutions for parallelization and what advantages or limitations Ractors bring when used in this context.
We will report an example of using dRuby and CRuby (not mruby) in embedded software for small medical devices. In this talk, we will discuss the architecture of our products.
06:00 - 06:25
Many Ruby programmers use regular expressions frequently. They are an amazingly powerful tool for many different kinds of text processing. However, if not used carefully, they can also be dangerous: They may not exactly match what their writer thinks they match, and they may execute very slowly on certain inputs. This talk will help you understand regular expressions better, so that you can make good use of their amazing power while avoiding their dangerous sides. It will also discuss recent changes to Ruby in the area of regular expressions.
BPF is a technology used in Linux for packet filtering, tracing or access auditing. BPF has its own VM and set of opcodes. If you want to write a program that loads and uses BPF binary, you can write it in any language including Ruby. However, to prepare a "BPF binary" itself, you generally need to write a bit weird C, and pass it to clang compiler using `bpf` target. Wouldn't it be great if we could make these BPF binaries entirely in Ruby? Rucy is intended to allow programmers to write their whole BPF programs in Ruby. I'll discuss how to "compile" BPF binaries from Ruby in this talk.
06:30 - 06:55
The ability to create DSLs is one of the biggest strengths of Ruby. They allow us to write easy to use interfaces and reduce the need for boilerplate code. On the flip side, DSLs encapsulate complex logic which makes it hard for developers to understand what's happening under the covers. Surfacing DSLs as static artifacts makes working with them much easier. Generating RBI/RBS files that declare the methods which are dynamically created at runtime, allows static analyzers like Sorbet or Steep to work with DSLs. This also allows for better developers tooling and as some kind of "DSL linter".
Introduction of mruby on YABM Why I started mruby on YABM(Yet Another Bare Metal). I describe inside of mruby and how to use it. Also I talked about IoT use case.
| Start...End time | TrackA | TrackB |
|---|---|---|
|
01:00 - 01:55 UTC |
Lang: en
Track: TrackA
The Future Shape of Ruby ObjectsTruffleRuby uses an optimisation called object shapes to optimise Ruby. It automatically learns and understands the layout and types, or the shape, of your objects as your code is running and optimises code to work better with those shapes. As the community tries to make MRI faster, it could be time to adopt object shapes there as well. We’ll talk about what TruffleRuby does, how it does it, and the benefits it achieves in practice. |
|
|
02:00 - 02:25 UTC |
Lang: en
Track: TrackA
Just-in-Time Compiling Ruby Regexps on TruffleRubyTruffleRuby together with Truffle Regex can now execute Ruby Regexps up to 40 times faster than CRuby! This is possible by just-in-time compiling Ruby Regexps to machine code by using Truffle Regex, a Truffle language for regular expressions. Truffle Regex uses finite-state machines, a [much faster](https://swtch.com/~rsc/regexp/regexp1.html) alternative to backtracking regexp engines. Because of the unique capability of GraalVM to inline across languages, the Ruby code and the Regexp are optimized and compiled together for ultimate performance. |
Lang: ja
Track: TrackB
PRK Firmware: Keyboard is Essentially RubyPRK Firmware is the world's first keyboard firmware framework in Ruby. You can write not only your own "keymap" in Ruby but also additional behavior by features of Ruby like open class system and Proc object. Plus, your keyboard itself interprets a Ruby script on the fly. Essentially, your keyboard can become Ruby. The ultimate goal is certainly not a small one --- let's make Ruby comparable to projects such as MicroPython, CircuitPython or Lua in terms of viability as a scripting language for microcontrollers. |
|
02:30 - 02:55 UTC |
Lang: en
Track: TrackA
YJIT - Building a new JIT Compiler inside CRubyYJIT, an open source project led by a small team of developers at Shopify to incrementally build a new JIT compiler inside CRuby. Key advantages are that our compiler delivers very fast warm up, and we have complete, fine-grained control over the entire code generation pipeline. In this talk, I present the approach we are taking to implement YJIT and discuss early performance results. The talk will conclude with a discussion of what steps can be taken to unlock higher levels of performance for all JIT compilers built inside CRuby, be it YJIT, MJIT or any future JIT compiler efforts. |
Lang: ja
Track: TrackB
The newsletter of RBS updatesI talk about the RBS updates between Ruby 3.0 and 3.1 in this talk. RBS for Ruby 3.1 will be released with many changes. I'll pick up and describe some features for this talk. |
|
04:00 - 04:25 UTC |
Lang: en
Track: TrackA
Parsing RubySince Ruby's inception, there have been many different projects that parse Ruby code. This includes everything from development tools to Ruby implementations themselves. This talk dives into the technical details and tradeoffs of how each of these tools parses and subsequently understands your applications. After, we'll discuss how you can do the same with your own projects using the `Ripper` standard library. You'll see just how far we can take this library toward building useful development tools. |
Lang: ja
Track: TrackB
include/prepend in refinements should be prohibitedinclude/prepend in refinements are often used to define the same set of methods in multiple refinements. However it should be prohibited because it has implementation difficulties such as https://bugs.ruby-lang.org/issues/17007 and https://bugs.ruby-lang.org/issues/17379, and tends to be misleading like https://bugs.ruby-lang.org/issues/17374. In this talk, I propose a new feature instead of include/prepend in refinements. |
|
04:30 - 04:55 UTC |
Lang: en
Track: TrackA
Ractor's speed is not light-speedRactor is the new feature, introduced in Ruby 3.0, to run Ruby code on multiple CPU cores. But unfortunately, Ruby 3.0 is not fully ready for actual workloads. This session will show how we can improve web-app performance by Ractor, and what we have to do to run our web apps on Ractor. |
Lang: en
Track: TrackB
Graphical Terminal User Interface of Ruby 3.1The IRB shipped with Ruby 3.1 provides a dialog window feature on the terminal to achieve autocomplete. This is implemented as a new feature in Reline, which displays a dialog in an interactive user input interface at any time you want. In this article, I will show you how to utilize this dialog display feature of Reline, with IRB and the Ruby debugger which is a new feature in Ruby 3.1. |
|
05:00 - 05:55 UTC |
|
01:00 - 01:55
TruffleRuby uses an optimisation called object shapes to optimise Ruby. It automatically learns and understands the layout and types, or the shape, of your objects as your code is running and optimises code to work better with those shapes. As the community tries to make MRI faster, it could be time to adopt object shapes there as well. We’ll talk about what TruffleRuby does, how it does it, and the benefits it achieves in practice.
02:00 - 02:25
TruffleRuby together with Truffle Regex can now execute Ruby Regexps up to 40 times faster than CRuby! This is possible by just-in-time compiling Ruby Regexps to machine code by using Truffle Regex, a Truffle language for regular expressions. Truffle Regex uses finite-state machines, a [much faster](https://swtch.com/~rsc/regexp/regexp1.html) alternative to backtracking regexp engines. Because of the unique capability of GraalVM to inline across languages, the Ruby code and the Regexp are optimized and compiled together for ultimate performance.
PRK Firmware is the world's first keyboard firmware framework in Ruby. You can write not only your own "keymap" in Ruby but also additional behavior by features of Ruby like open class system and Proc object. Plus, your keyboard itself interprets a Ruby script on the fly. Essentially, your keyboard can become Ruby. The ultimate goal is certainly not a small one --- let's make Ruby comparable to projects such as MicroPython, CircuitPython or Lua in terms of viability as a scripting language for microcontrollers.
02:30 - 02:55
YJIT, an open source project led by a small team of developers at Shopify to incrementally build a new JIT compiler inside CRuby. Key advantages are that our compiler delivers very fast warm up, and we have complete, fine-grained control over the entire code generation pipeline. In this talk, I present the approach we are taking to implement YJIT and discuss early performance results. The talk will conclude with a discussion of what steps can be taken to unlock higher levels of performance for all JIT compilers built inside CRuby, be it YJIT, MJIT or any future JIT compiler efforts.
I talk about the RBS updates between Ruby 3.0 and 3.1 in this talk. RBS for Ruby 3.1 will be released with many changes. I'll pick up and describe some features for this talk.
04:00 - 04:25
Since Ruby's inception, there have been many different projects that parse Ruby code. This includes everything from development tools to Ruby implementations themselves. This talk dives into the technical details and tradeoffs of how each of these tools parses and subsequently understands your applications. After, we'll discuss how you can do the same with your own projects using the `Ripper` standard library. You'll see just how far we can take this library toward building useful development tools.
include/prepend in refinements are often used to define the same set of methods in multiple refinements. However it should be prohibited because it has implementation difficulties such as https://bugs.ruby-lang.org/issues/17007 and https://bugs.ruby-lang.org/issues/17379, and tends to be misleading like https://bugs.ruby-lang.org/issues/17374. In this talk, I propose a new feature instead of include/prepend in refinements.
04:30 - 04:55
Ractor is the new feature, introduced in Ruby 3.0, to run Ruby code on multiple CPU cores. But unfortunately, Ruby 3.0 is not fully ready for actual workloads. This session will show how we can improve web-app performance by Ractor, and what we have to do to run our web apps on Ractor.
The IRB shipped with Ruby 3.1 provides a dialog window feature on the terminal to achieve autocomplete. This is implemented as a new feature in Reline, which displays a dialog in an interactive user input interface at any time you want. In this article, I will show you how to utilize this dialog display feature of Reline, with IRB and the Ruby debugger which is a new feature in Ruby 3.1.
05:00 - 05:55
| Start...End time | TrackA | TrackB |
|---|---|---|
|
01:00 - 01:25 UTC |
Lang: en
Track: TrackA
Do regex dream of Turing Completeness?We're used to using Regular Expressions every day for pattern matching and text replacement, but... What can Regexes actually do? How far can we push them? Can we implement actual logic with them? What if I told you... You can actually implement Conway's Game of Life with just a Regex? What if I told you... You can actually implement ANYTHING with just a Regex? Join me on a wild ride exploring amazing Game of Life patterns, unusual Regex techniques, Turing Completeness, programatically generating complex Regexes with Ruby, and what all this means for our understanding of what a Regex can do. |
Lang: ja
Track: TrackB
Use Macro all the time ~ マクロを使いまくろ ~Ruby can get AST with `RubyVM::AbstractSyntaxTree`. I have implemented to convert AST into Ruby code. This will allow you to modify and execute Ruby code at AST level. - Ruby code -> Convert to AST -> Convert to another AST -> Convert AST to Ruby code -> Run Ruby code In this session, I will discuss "Implementations for converting AST to Ruby code" and "Implementations for converting AST to another AST". This feature of "converting to another AST" is similar to what is called a "Macro" in other languages. Let's think together about what happens when we implement "Macro" in Ruby. |
|
01:30 - 01:55 UTC |
Lang: en
Track: TrackA
Crafting exploits, tools and havoc with RubyCan I use ruby to ...? Create Websites? Yes Create Applications? Yes Wreak havoc, write exploits, and hack stuff? Of course! During this session we will analyze different exploits and tools written in Ruby by the author: from scanners and bruteforcers to C2 servers and complex exploits. Each exploit will be explained in a simple and friendly way for newcomers, and different samples and libraries will be shared so that anyone interested can start building its ruby-powered hacking toolbox. There will also be a short lab demo of these tools. Take a seat, grab an exploit, hack stuff. |
Lang: ja
Track: TrackB
Charty: Statistical data visualization in RubyHave you ever thought it would be better to make stylish charts by Ruby for daily data visualization tasks that sometimes occur? I will make that wish come true! Using Charty, you can do it by Ruby. Charty makes statistical data visualization easier. If you want to put error bars in a bar plot, you must calculate the mean and the 95% confidence interval before plotting. Charty performs these calculations instead of you. Moreover, Charty can recognize many data types as table data and supports files, Jupyter Notebook, JupyerLab, VSCode, and a terminal emulator as the output destination. |
|
02:00 - 02:25 UTC |
Lang: en
Track: TrackA
Building Native Extensions. This Could Take A While..."Native gems" contain pre-compiled libraries for a specific machine architecture, removing the need to compile the C extension or to install other system dependencies. This leads to a much faster and more reliable installation experience for programmers. This talk will provide a deep look at the techniques and toolchain used to ship native versions of Nokogiri (a commonly-used rubygem), and will discuss why human trust is an important requirement. Gem maintainers will learn how to build native versions of their own gems, and developers will learn how to use and deploy pre-compiled packages. |
Lang: ja
Track: TrackB
Dive into EncodingEach Ruby `String` object has an encoding internally. Therefore, it can use a different encoding in the same application. It's very convenient. So, how does Ruby encode a String? What does it mean to have an encoding for each String? As they say, practice makes perfect, so I figured I could understand it by adding self-made encoding. This talk would like to try to add self-made encoding in Ruby and see how Ruby handles encodings. |
|
02:30 - 02:55 UTC |
Lang: en
Track: TrackA
Beware the Dead End!!Nothing stops a program from executing quite as fast as a syntax error. After years of “unexpected end” in my dev life, I decided to “do” something about it. In this talk we'll cover lexing, parsing, and indentation informed syntax tree search that power that `dead_end` Ruby library. |
Lang: ja
Track: TrackB
How to develop the Standard Libraries of Ruby?I maintain the RubyGems, Bundler and the standard libraries of the Ruby language. So, I've been extract many of the standard libraries to default gems and GitHub at Ruby 3.0. But the some of libraries still remains in only Ruby repository. I will describe these situation. So, Rubyists can submit a pull-request for the default gems like net-http, irb or etc after Ruby 3.0. We need to learn about the mechanism of the default gems. and also learn the bundled gems. I will describe a technic for developing the standard libraries with GitHub.. |
|
04:00 - 04:25 UTC |
Lang: en
Track: TrackA
It is time to build your mruby VM on the microcontroller?In 2020, I find a mini-arcade maker product that uses ESP8622 and MicroPython. Since I know the mruby/c can run on the ESP32 but it doesn't support running on the ESP8622. Is it possible to implement our own mruby VM and execute Ruby on any microcontroller we want to use it? This talk will show my progress to run a simple mruby script on the ESP8622 by implementing my own small mruby VM. |
Lang: ja
Track: TrackB
Ruby, Ractor, QUICFrom Ruby 3, a parallel processing mechanism called Ractor has been introduced. This has made it easy to implement safe parallel processing in Ruby. In addition, QUIC, which was announced by Google in 2013, standardized in May 2021, and will be used more and more in the future. In this presentation, I will explain what QUIC is, whether it is possible to implement a QUIC server and client with Ractor introduced in Ruby 3, and if so, why it is difficult or impossible. |
|
04:30 - 04:55 UTC |
Lang: en
Track: TrackA
10 years of Ruby-powered citizen scienceIn the wake of the 2011 Tohoku earthquake and tsunami, people were worried for their safety. Safecast answered that call and went on to the largest open radiation database in the world. 10 years later our science project continues, with Ruby at its heart. Our radiation measurements span the globe and are freely available for anyone to use. And now with projects like Airnote we’re using that expertise to tackle new environmental challenges such as the California wildfires. |
Lang: ja
Track: TrackB
Red Arrow - Ruby and Apache ArrowTo use Ruby for data processing widely, [Apache Arrow](https://arrow.apache.org/) support is important. We can do the followings with Apache Arrow: * Super fast large data interchange and processing * Reading/writing data in several famous formats such as CSV and Apache Parquet * Reading/writing partitioned large data on cloud storage such as Amazon S3 This talk describes the followings: * What is Apache Arrow * How to use Apache Arrow with Ruby * How to integrate with Ruby 3.0 features such as MemoryView and Ractor |
|
05:00 - 06:00 UTC |
|
01:00 - 01:25
We're used to using Regular Expressions every day for pattern matching and text replacement, but... What can Regexes actually do? How far can we push them? Can we implement actual logic with them? What if I told you... You can actually implement Conway's Game of Life with just a Regex? What if I told you... You can actually implement ANYTHING with just a Regex? Join me on a wild ride exploring amazing Game of Life patterns, unusual Regex techniques, Turing Completeness, programatically generating complex Regexes with Ruby, and what all this means for our understanding of what a Regex can do.
Ruby can get AST with `RubyVM::AbstractSyntaxTree`. I have implemented to convert AST into Ruby code. This will allow you to modify and execute Ruby code at AST level. - Ruby code -> Convert to AST -> Convert to another AST -> Convert AST to Ruby code -> Run Ruby code In this session, I will discuss "Implementations for converting AST to Ruby code" and "Implementations for converting AST to another AST". This feature of "converting to another AST" is similar to what is called a "Macro" in other languages. Let's think together about what happens when we implement "Macro" in Ruby.
01:30 - 01:55
Can I use ruby to ...? Create Websites? Yes Create Applications? Yes Wreak havoc, write exploits, and hack stuff? Of course! During this session we will analyze different exploits and tools written in Ruby by the author: from scanners and bruteforcers to C2 servers and complex exploits. Each exploit will be explained in a simple and friendly way for newcomers, and different samples and libraries will be shared so that anyone interested can start building its ruby-powered hacking toolbox. There will also be a short lab demo of these tools. Take a seat, grab an exploit, hack stuff.
Have you ever thought it would be better to make stylish charts by Ruby for daily data visualization tasks that sometimes occur? I will make that wish come true! Using Charty, you can do it by Ruby. Charty makes statistical data visualization easier. If you want to put error bars in a bar plot, you must calculate the mean and the 95% confidence interval before plotting. Charty performs these calculations instead of you. Moreover, Charty can recognize many data types as table data and supports files, Jupyter Notebook, JupyerLab, VSCode, and a terminal emulator as the output destination.
02:00 - 02:25
"Native gems" contain pre-compiled libraries for a specific machine architecture, removing the need to compile the C extension or to install other system dependencies. This leads to a much faster and more reliable installation experience for programmers. This talk will provide a deep look at the techniques and toolchain used to ship native versions of Nokogiri (a commonly-used rubygem), and will discuss why human trust is an important requirement. Gem maintainers will learn how to build native versions of their own gems, and developers will learn how to use and deploy pre-compiled packages.
Each Ruby `String` object has an encoding internally. Therefore, it can use a different encoding in the same application. It's very convenient. So, how does Ruby encode a String? What does it mean to have an encoding for each String? As they say, practice makes perfect, so I figured I could understand it by adding self-made encoding. This talk would like to try to add self-made encoding in Ruby and see how Ruby handles encodings.
02:30 - 02:55
Nothing stops a program from executing quite as fast as a syntax error. After years of “unexpected end” in my dev life, I decided to “do” something about it. In this talk we'll cover lexing, parsing, and indentation informed syntax tree search that power that `dead_end` Ruby library.
I maintain the RubyGems, Bundler and the standard libraries of the Ruby language. So, I've been extract many of the standard libraries to default gems and GitHub at Ruby 3.0. But the some of libraries still remains in only Ruby repository. I will describe these situation. So, Rubyists can submit a pull-request for the default gems like net-http, irb or etc after Ruby 3.0. We need to learn about the mechanism of the default gems. and also learn the bundled gems. I will describe a technic for developing the standard libraries with GitHub..
04:00 - 04:25
In 2020, I find a mini-arcade maker product that uses ESP8622 and MicroPython. Since I know the mruby/c can run on the ESP32 but it doesn't support running on the ESP8622. Is it possible to implement our own mruby VM and execute Ruby on any microcontroller we want to use it? This talk will show my progress to run a simple mruby script on the ESP8622 by implementing my own small mruby VM.
From Ruby 3, a parallel processing mechanism called Ractor has been introduced. This has made it easy to implement safe parallel processing in Ruby. In addition, QUIC, which was announced by Google in 2013, standardized in May 2021, and will be used more and more in the future. In this presentation, I will explain what QUIC is, whether it is possible to implement a QUIC server and client with Ractor introduced in Ruby 3, and if so, why it is difficult or impossible.
04:30 - 04:55
In the wake of the 2011 Tohoku earthquake and tsunami, people were worried for their safety. Safecast answered that call and went on to the largest open radiation database in the world. 10 years later our science project continues, with Ruby at its heart. Our radiation measurements span the globe and are freely available for anyone to use. And now with projects like Airnote we’re using that expertise to tackle new environmental challenges such as the California wildfires.
To use Ruby for data processing widely, [Apache Arrow](https://arrow.apache.org/) support is important. We can do the followings with Apache Arrow: * Super fast large data interchange and processing * Reading/writing data in several famous formats such as CSV and Apache Parquet * Reading/writing partitioned large data on cloud storage such as Amazon S3 This talk describes the followings: * What is Apache Arrow * How to use Apache Arrow with Ruby * How to integrate with Ruby 3.0 features such as MemoryView and Ractor
05:00 - 06:00