Lessons Matz has learned from the history of Ruby development

Building a feature is not good enough anymore: all your work won't be of use if it's not performant enough. So how to improve performance? After all, performance is not an easy discipline to master: all slow applications are slow in their own way, meaning that there is no silver bullet for these kinds of problems.

In this presentation, we will guide you across patterns, strategies, and little tricks to improve performance. We will do that by sharing real stories of our daily experience facing and solving real performance issues in an application that daily serves billions of requests per day.

As part of implementing Hybrid Public Key Encryption (HPKE; RFC 9180) in Ruby, I had a chance to send a patch into Ruby's OpenSSL gem. Missing functionalities? Major version upgrade of the OpenSSL backend? There is a deep dungeon behind one of Ruby's default gem, and I will talk about one adventure through this dungeon.

With mruby, we can write Ruby for many environments including old video game consoles. I am working on a cross-platform library for mruby so software written for mruby on Dreamcast can be run on Wii with little change to the source. I have ported the block puzzle I showed at RubyConfTW 2019 to Wii, and am now working on the presentation tool.

I will tell you about what is involved in making a cross-platform mruby library for Dreamcast and Wii, as well as challenges and lessons learned.

This presentation will (hopefully) be delivered on either of those consoles and will include some live demos.

A massive XML called BioProject has been published. However, when I parsed the XML as it was, rexml got freeze somewhere, and nokogiri ended up consuming a large amount of memory and being slow. Looking at the sample implementation in Python, it uses iterparse() to parse each element in the first layer. Therefore, we created a similar mechanism in Ruby and also used ractor to speed it up.

With the release of Ruby 3.1 in 2021, an enhancement arrived as Process#_fork, allowing us to override the fork method. This addition simplifies creating callbacks when forking. While there was no official method to track fork events prior to Ruby 3.1, this limitation didn't deter the community from exploring various approaches to achieve the same goal.

In the past, Rails encouraged the use of before_fork and after_fork for connection management, redis-rb ensured fork safety by storing the Process#pid in a variable, and some even used threads to track fork events.

During this session, I will delve into the backstory of _fork and explore the diverse methods the community employed for creating callbacks during forking prior to Ruby 3.1.

Natsukantou and epub-translator gems offer XML translation by allowing users to mix & match filters and translation services (DeepL/ChatGPT). The gem's architecture will be presented, showcasing its middleware pattern, the use cases and wizard configuration inference.

Since Ruby's bundled and default gems change every year with each release, some versions may suddenly happen LoadError at require when running bundle exec or bin/rails, for example matrix or net-smtp.

In this presentation, I will introduce the details of the functionality that extends Ruby's require to provide guidance to users on what they can do to load them. And I will also show how $LOAD_PATH is build behind Ruby and Rails by Bundler.

Can you recall a world without having to remember passwords? If Passkeys becomes widely available, that world is a few steps away in our future. Instead of remembering passwords, we will use our biometrics, already available in our phones, laptops, and desktops, and public key encryption! To a future with no passwords!

介紹如何從 Figma 設計稿，就開始規劃、製作與預覽元件（View Component + Lookbook）。 說明目前偏好的元件組成方式，協助製作元件的工具和注意事項，以及安置元件到頁面中的方式（partial + helper）。 展示利用 settings 搭配 builder 活用元件的嘗試。

Let’s start to plan, create, and preview view components from the design stage with Figma, ViewComponent and Lookbook. I will introduce my preferred way to compose view components, the tools and tips which can help build, and how to use partial and helper to render it. I will also show you a pattern to rendering view components with settings and builder.

At RubyKaigi 2023, yui-knk introduced Lrama, for which I submitted a PR to implement the 'Named References' feature, a functionality found in GNU Bison. In this presentation, I will delve into the internal workings of Lrama gained through this implementation. Alongside, I will touch upon the foundational knowledge of parsers and parser generators, as well as the current state of parsers surrounding Ruby.

In this presentation, we will embark on a journey of live coding to bring microcontrollers to life. All you need is (at least) two "Raspberry Pi Pico W" boards, the same number of USB cables, and a laptop. Witness the realization of PicoRuby, a production-ready Ruby implementation for microcontrollers, as we delve into the world of innovation.

The View layer is the messiest part of a Ruby on Rails application. Developers are confused about where to put logic. Should it be in the model, presenter, decorator, helper, or partial?

ViewComponents, developed by GitHub simplifies the View layer and makes it much easier to manage.

在生成式 AI 風起雲湧的今天，軟體開發的格局正迅速變革。從 GitHub Copilot 到 ChatGPT 的 Code Interpreter，生成式 AI的影響力滲透至開發工作的每一個角落。在這一波浪潮中，網頁應用開發者如何定位自己，保持創造力和專業熱情？

本次座談會將邀請幾位在 LLM（Large Language Models）有相關經驗的資深工程師，共同探討在 Generative AI 的浪潮下，工程師如何保持專業的熱情與創造力。我們將圍繞一個核心問題：AI 是否將成為軟體工程師的威脅，或是進步的助力？

在 Ruby 社群中，「開發者快樂」一直是其哲學的核心。那麼在AI的影響下，我們如何探索運用 Generative AI 的力量來提升開發者的幸福感？

我們將在本次座談會中，尋找那些將會導引我們走向光明未來的答案。

In today’s era of Generative AI, the landscape of software development is rapidly evolving. From GitHub Copilot to ChatGPT’s Code Interpreter, the influence of Generative AI permeates every corner of the development work. In the midst of this wave, how can web application developers position themselves and maintain creativity and professional enthusiasm?

This panel discussion will invite several senior engineers with experience in Large Language Models (LLM) to explore how engineers can maintain their professional enthusiasm and creativity amidst the Generative AI wave. We will focus on a core question: Is AI a threat to software engineers or an advancement?

In the Ruby community, “developer happiness” has always been a core philosophy. So, how can we explore the use of Generative AI to enhance developer happiness in the wake of AI’s influence?

We will seek answers that will guide us towards a brighter future in this panel discussion.

Rails 讓開發 Web Application 變得相當容易，然而因為簡化了許多問題，當我們面臨更複雜的系統時感到極大的挑戰。複雜的 Rails 專案之所以難以維護是 Rails 在架構上的設計造成的限制，讓我們重新思考 Rails 來尋找更容易維護的架構。

The Large-Language Models have taken application development by storm. Ruby has libraries that help build LLM applications, e.g.: Langchain.rb. We need to understand what kind of LLM applications can be built, how to build them, and what are common pitfalls when building them. We're going to look at building vector (semantic) search, chat bots and business process automation solutions. We're going to learn AI/LLM-related concepts, terms and ideas, learn what AI agents are, and look at some of the latest cutting edge AI research.

Chances are you’ve run bundle install or gem install at some point, seeing as we’re at RubyConf. Turns out, you’re not alone. At peak times, RubyGems.org has received as many as 225 thousand requests per second. How does a small, mostly-volunteer team handle serving all that traffic with their rails app? Let’s dive into how using CDNs, scaling with static files, and wrangling expensive endpoints has kept your favorite gem index up and running over the past decade.

Rails 7 introduced a new feature called Active Record Encryption. I will go over what it is, how it works, and how Viewabo used it to help us achieve GDPR compliance. I will include example usage and an overview of the preparatory work that went into implementing Active Record Encryption.

在過去一年裏我們經歷了 LLM 的巨大衝擊，但是對於使用 LLM 實作應用依然困難重重。如何利用 Ruby 的 meta-programming 更好地對 LLM 進行處理和約束從而實作下一世代的 AI 應用是本 Topic 試圖討論的關鍵問題。

Error handling is an essential part of software development. No matter how well-written your code is, there will always be errors. The key is to handle them in a way that minimizes their impact.

In this talk, we will build a foundation of error handling concepts, categorizing errors and exceptions in Ruby. We'll look at practical code examples that demonstrate common issues when propagating errors through layers of code. Explore how Monadic Handling abstract away error handling details by combine Monads Result and Service Object in Ruby programming.

This talk will empower you understand how to use Monadic Handling Ruby code. You'll leave with a deeper appreciation of monads and concrete strategies for encapsulating errors elegantly in your Ruby applications. Join me to discover how monads enable you to minimize disruption and maximize control over error handling in Ruby.

你曾經在不用外部 Gems 的情況下使用 Ruby 嗎？

Ruby 其實內建了很多非常實用的 Gems。不需要做任何的額外安裝就可以直接使用。 這些Gems 包括方便的資料結構與演算法，跨平台的檔案處理，實用的簡易伺服器等等。讓我們一起來發掘各種鮮為人知的內建 Gems。

How many times did you run ruby without external Gems?

Ruby includes many Gems by default. We can use them without extra installation steps. These Gems includes convenient data structure and algorithms, cross platform file handling and practical simple server, etc. Let's unearth the less known builtin Gems.

Minitest is a testing library for Ruby that's bundled with CRuby. Unlike RSpec, it takes more straightforward approach. Class, method and assertion are all we need to write tests in Minitest. However, there are still some magical things going on here. What do assertions actually do? How does autorun feature work? In this talk, we'll write code together. More specifically, we'll write simpler clone of Minitest and make it work.

Race condition 是在 Ruby on Rails 應用程式中可能出現的問題之一，尤其涉及多執行緒的情況。這次演講提供了 race condition 的基本概念，以及如何在 Rails 中測試和解決這些問題的方法。測試 race condition 的方法至關重要，可以通過模擬並發情境來確保穩定性。

"Race condition" is a potential issue in Ruby on Rails applications, especially in situations involving multiple threads. This presentation provides a basic understanding of race conditions and how to test and resolve them in Rails. Testing for race conditions is crucial and can be achieved by simulating concurrent scenarios to ensure stability.

Is Rails still a good choice in 2023? For a new project at work? For a side hustle? How about for someone just looking to get into web development? How does it stack up against "modern" frameworks?

In this presentation we explore the ancient history of web development, discuss the perils of "the modern web application", highlight a brewing generational conflict, and examine how Rails' connection to the past puts it in a unique position to project itself into the future.

在這場分享中，我們將新定義 Generative AI Engineer (生成式 AI 工程師) 這一新興職位。除了 LLM 模型本身之外，要真正開發 AI 應用，我們還需要面對許多的挑戰和工作。隨著開發 AI 應用的門檻逐漸降低，許多原先沒有 AI 背景的應用軟體工程師，現在也能透過呼叫 LLM API 轉型成為 AI 工程師，不再需要從零開始學習訓練機器學習模型，而是專注在 Prompt Engineering (提示工程) 和開發各種 AI 應用，如 Chatbot、Retrieval Augmented Generation(RAG)、Vector Search、Agents 和 OpenAI Function Calling 等。歡迎一起探索這個新時代的 AI 工程師角色。

In this talk, we redefine the emerging role of Generative AI Engineer. Beyond just the LLM itself, developing AI applications presents many challenges and tasks. Now software developers can build AI apps by using LLM APIs and don’t have to start learning machine learning from the beginning. We can focus on Prompt Engineering, Retrieval Augmented Generation(RAG), Vector Search, Agents, and OpenAI Function Calling. Join us in exploring the role of AI engineers in this new era.

In this talk, we explore on how we can take advantage of Ractor to improve parallel processing in some real world scenarios, such as data encryption and transaction processing. We delve into some features of Ractor, with their strength and limitation, and how to migrate thread-based or process-based functionalities using them. This talk hopefully will give the audience more insights on how they can improve their application performance.

Over the past year, the JVM has added native support for fibers (via Project Loom virtual threads), native function calls (via Project Panama), and now has started to add support for native ahead-of-time compilation. JRuby is uniquely positioned to bring these features to Ruby! This talk will show how JRuby is taking advantage of the modern JVM with exciting examples you can try today!

You've heard the whispers, sensed the hype, but you're still not sure what all the fuss is about with SQLite these days. Join me as we explore the use-cases and benefits of running SQLite in a production environment. Along the way, we will learn why SQLite makes sense as your next production database and how to ensure that your setup is optimized for end-user performance and developer happiness. We will setup and deploy a full Rails application—with caching, background jobs, websockets, and full-text search all backed by SQLite—in these 40 minutes. Come along for the ride!

What do curiosity, cooperation and cognisance mean for the budding Rubyist? And can these virtues help us follow the path of programmer happiness?

As we enter a land where both peril and opportunity abound, how can we plot a course towards towards the Ruby of our future? Let’s find out together, as we embark on the adventure of our time!