Visualized multi-threaded simulators in Ruby

In this talk, Jakub Godawa introduces creative techniques for building multi-threaded simulations in Ruby, highlighting their use in modeling real-world scenarios like petrol stations. The presentation begins with Godawa sharing a personal anecdote about his transition from a software engineer role to his current position at a petrol station, which sparked his interest in creating simulations to optimize operations in a controlled environment.

Key Points:
- Simulation Concept: Godawa emphasizes the importance of simulations as programmable environments to model real-life systems, focusing on controlling time and synchronizing multiple threads representing various entities like cars and pumps.
- Thread Management: The talk delves into handling shared resources through Ruby's threading capabilities, discussing how to use threads, queues, and mutexes to effectively manage the flow of cars at the petrol station. He outlines handling consumer-producer scenarios, emphasizing that every car does not need to run on its own thread, instead encouraging efficient management through a car spawner pushing to a queue.
- Visualization Techniques: Visualizing the simulation is crucial for understanding its dynamics. Godawa showcases his work using D3.js and ASCII art, demonstrating how simulation outcomes can be represented visually to draw insights.
- Configurable Simulations: The talk details how to configure simulations via YAML files, allowing various scenarios to be tested simultaneously. Godawa explains how to define parameters like the number of pumps, fueling speed, and car arrival rates to gather meaningful data.
- Performance & Optimization: The speaker stresses optimizing simulation performance by limiting thread usage. He illustrates how lazy enumerators can help manage resource consumption by controlling the number of active threads while allowing multiple simulations to run concurrently without heavy CPU load.
- Real-World Insights: Godawa shares insights from his simulations which show varied results based on different pump configurations, revenue tracking, and user interface updates that reflect real-time data.

In conclusion, Godawa encourages developers to play with simulation designs as they can inspire creativity in programming and lead to improved production code. His examples combine practical Ruby programming skills with animations to present complex system interactions in an engaging manner. The talk serves as a valuable introduction to building interactive, multi-threaded simulations in Ruby, pushing developers to explore coding in unconventional ways.

Main Takeaways:
- Simulations provide a powerful tool to visualize and optimize processes.
- Effective thread management and the use of shared resources are essential for performance.
- Configurable scenarios increase the utility of simulations, allowing for comparative analysis.
- Visualization aids in understanding and communicating simulation outcomes.

Visualized multi-threaded simulators in Ruby
Jakub Godawa • Sarajevo, Bosnia and Herzegovina • Talk

Date: September 13, 2024
Published: January 13, 2025
Announced: unknown

We all do simulations in our heads, so why not make one in Ruby? Something that we can observe, fast forward, or let it linger. Let's see how custom shared timers, threads, queues, and mutexes work together, and how they can form a petrol station with optimal cost and throughput.

The cars are coming to a station. They want to get some fuel. They come at different times and they need to be served. Just like web requests but this time we'll not do web development. This we do at work. So for fun we want to build something that feels more alive. A small closed system that we could fully control and derive further ideas from. This is how we start thinking about simulators.

The main idea of a simulation is that it happens in some programmable environment. First, we need to think about how to control time. If every piece of the simulation, like a car or a station, runs in its own thread, then how do we synchronize them? How to handle access into shared resources? What data structures should we use?

Also, how do we create a protocol for gathering results to help us make decisions? How do we write a config file for a simulator engine that can spawn multiple scenarios in parallel? And last but not least, how do we visualize a simulation?

This presentation is a pure Ruby feast. We will operate on MRI and visualize the simulation in two ways: with d3.js, and through ASCII art. See you there! 🚕

EuRuKo 2024