Ilya Bylich - Blog

Ruby, Ractors, and Lock-Free Data Structures

Wed, 19 Mar 2025 00:00:00 +0000

Arena-based parsers

Thu, 09 May 2024 00:00:00 +0000

Writing bindings upside down

Tue, 28 Dec 2021 00:00:00 +0000

Bindings #

Quite a long time ago I started writing C/C++/Ruby/Node.js/WASM bindings so I could call my Rust project from those languages. It is a Ruby language parser.

I tried multiple ways and found one that is very (VERY) controversial, but I think it deserves it’s own article.

Traditional way #

Let’s say you have a library in C. Just for simplicity, Rust is not special here.

lib-ruby-parser

Mon, 23 Nov 2020 00:00:00 +0000

Intro #

So, I’m ready to announce that I have finished working on a new Ruby parser. It’s called lib-ruby-parser.

Key features:

It’s fast. It’s written in Rust and it’s slightly faster than Ripper. The difference is about 1-2% on my machine.
It has a beautiful interface. Every single node has its own type that is documented. For example, take a look at CSend node that represents “conditional send” like foo&.bar. Here’s a list of all defined nodes . Both Ripper and RubyVM::AST have no documentation of their AST format. whitequark/parser has a great documentation , but its AST is not “static”.
What’s “static AST”? By saying that I mean that if documentation says that “N is not-nullable” then it’s true no matter what. whitequark/parser does a great job, but the nature of dynamic language does not allow it to provide such guarantees. I’ll show a few examples later.
It’s precise. Unlike whitequark/parser, its lexer (or tokenizer if it sounds better for you) is based on MRI’s parse.y. What does it mean? It means that I was not able to find any difference in tokenizing on 3 million lines of code that I have got by pulling sources of top 300 gems (by total downloads). I’ll mention how I track it soon.
It does not depend on Ruby. In fact, it has absolutely no “required” dependencies (only a few optional ones). So, it’s possible to write bindings for any other language, and I have made them for C/C++/Node.js. Of course, it’s possible to have bindings for Ruby (because there are bindings for C and it’s easy to reuse them)

Implementation #

Current performance (in release mode, with jemalloc) is ~200000 LOC/s. I think it can even be used for syntax highlighting (and in the browser, too, haha).

Evaluating Ruby in Ruby

Sun, 26 Jan 2020 00:00:00 +0000

TL;DR #

This article is about instruction sequences and evaluating them using pure Ruby.

The repository is available here .

Is it a Ruby implementation?

No. It’s just a runner of instructions. It is similar to MRI’s virtual machine, but it lacks many features and it’s 100 times slower.

Can I use it in my applications?

Of course, no. Well, if you want.

My favorite parts of Ruby

Thu, 19 Jul 2018 00:00:00 +0000

Before we start #

Disclaimer #1 first of all I’d like to say that I really like Ruby. I write a ton of Ruby code every single day and I prefer it over other languages. Please, do not take it seriously, Ruby is nice, and this post is mostly a joke.

Disclaimer #2 I’m not going to cover popular things like flip-flops (thanks God they are deprecated in 2.6.0).

Ruby Marshalling from A to Z

Tue, 26 Jan 2016 00:00:00 +0000

What is Marshalling #

Marshalling is a serialization process when you convert an object to a binary string. Ruby has a standard class Marshal that does all the job for serialization and deserialization. To serialize an object, use Marshal.dump, to deserialize - Marshal.load or Marshal.restore.

marshalled = Marshal.dump([1, 2, 'string', Object.new])
# => "\x04\b[\ti\x06i\aI\"\vstring\x06:\x06ETo:\vObject\x00"

Marshal.load(marshalled)
# => [1, 2, "string", #<Object:0x00000002643000>]

This article explains the format of marshalling and shows how to write a pure Ruby marshalling library compatible with the standard Ruby implementation.

HandlerSocket + Ruby

Tue, 10 Nov 2015 00:00:00 +0000

What is HandlerSocket (HS) #

a plugin for MySQL
which allows you to read/write to MySQL
and gives you a separate connection to MySQL
and does not allow you to run SQL queries
but allows to run simple CRUD queries only using indexes

HandlerSocket query language is very simple (I’d even say it’s primitive), but it’s much faster than MySQL’s one. Though, of course, there are some limitations. Interested?

Saving execution context for later debugging

Fri, 21 Aug 2015 00:00:00 +0000

The problem #

Consider the following situation: you have got an exception in production. Of course, all of us are good developers, but you know, sometimes *it just happens. What do you usually do to get some information about the error? You just grab the request parameters to test it locally, right? Then I might have a better solution for you: dump your memory once an error happens and restore the dump later to debug it.

Wrapping JavaScript library with Opal

Thu, 23 Jul 2015 00:00:00 +0000

Introduction #

The task that is solved here is not real, but it’s still a good example of (probably?) real work with Opal. I could choose some complex enough JavaScript library and write a simple wrapper using Opal, but there’s no fun. Instead, let’s write a wrapper for existing rich client-side application (it may show you how to wrap your existing application logic). Well, wrapper for something like a client-side scheduler may sound boring, so I have chosen a JavaScript-based browser game called BrowserQuest written by Mozilla, and I’ll show you how to write a bot for it using Opal.

Capybara and asynchronous stuff

Wed, 01 Jul 2015 00:00:00 +0000

What is Capybara, Poltergeist and PhantomJS? #

In this part I will try to cover the following aspects:

Running asynchronous code in a web driver
Making the call synchronous
Wrapping it into some common solution
Advanced example - working with IndexedDB from Capybara

PhantomJS #

First of all, we need to know what is PhantomJS. I would say it’s a ’tool that acts like a browser but can be controlled from outside using simple command interface’. In more common words, it’s a web driver. It’s a full-featured WebKit (an engine of Chrome/Safari/few last versions of Opera and other browsers), but in console. You can use it for scripting, automating or testing.

Apipie - amazing tool for documenting your Rails API

Mon, 08 Jun 2015 00:00:00 +0000

Apipie #

This article is about Apipie gem which provides a DSL for documenting your API. I will try to cover features that I personally use on my project.

Comparing to other tools for generating API documentation (yardoc, sdoc) I would say that the main thing that you gain with Apipie is that your documentation is a real ruby code, so you can write computations, concerns etc.

What is Ruby DSL

Tue, 26 May 2015 00:00:00 +0000

What is Ruby DSL? #

As you already know, DSL means domain-specific language. It’s like a language in a language. Here are some examples that we use every day:

class User
 attr_reader :name
end

class Profile < ActiveRecord::Base
 has_many :posts
end

class ApiController < ActionController::Base
 before_action :authenticate
end

But all these examples use rails-provided DSL, how about your own? First of all, you should know that all these methods (attr_reader, has_many and before_action) are actually class-methods of Module, ActiveRecord::Base and ActionController::Base. So you can write something like:

Experimental MySQL HTTP API and Ruby

Thu, 14 May 2015 00:00:00 +0000

HTTP API #

Yes, MySQL has an HTTP API which is:

an experimental feature
it ships as a native plugin only for 5.7 version

Basically, it allows you to work with your database in the following ways:

as an SQL endpoint
as a CRUD endpoint
as a JSON document endpoint

SQL endpoint #

It gives an ability to run queries like

ExceptionManager gem

Tue, 14 Apr 2015 00:00:00 +0000

What is this? #

ExceptionManager is a gem for getting extra information from your exception.

Source code: https://github.com/iliabylich/exception_manager

With this gem every time when you get an exception, it’s possible to grab subject of exception (the instance of class where raise happened), locals - local variables, subject_instance_variables and subject_class_variables

Examples:

require 'exception_manager'
ExceptionManager.enable!

class TestClassThatRaisesException
 @@class_variable = :class_value

 def test_error(*args)
 @instance_variable = :instance_value

 raise 'Test error'
 end
end

begin
 TestClassThatRaisesException.new.test_error(1, 2, 3)
rescue => e
 puts "Subject: #{e.subject}"
 puts "Locals: #{e.locals}"
 puts "Instance variables: #{e.subject_instance_variables}"
 puts "Class variables: #{e.subject_class_variables}"
 puts "Summary: #{e.summary.inspect}"
end

This code snippet prints:

Redis Cluster. Quick overview.

Mon, 13 Apr 2015 00:00:00 +0000

Today I have tested version 3.0.0 of Redis server which includes Redis cluster. Here are some first thoughts about this.

Setup #

Here are my servers:

# 212.71.252.54 / 192.168.171.141 / node1
# 176.58.103.254 / 192.168.171.142 / node2
# 178.79.153.89 / 192.168.173.227 / node3

Local hosts (on each server):

# local hosts
192.168.171.141 node1
192.168.171.142 node2
192.168.173.227 node3

And remote (on my PC):