Ismael Celis

November 2025 talk on durable messaging and Ruby

Wed, 03 Dec 2025 09:10:00 +0000

This is a presentation about durable messaging, Event Sourcing and Ruby that I gave at the London Ruby User Group this past November.

Unfinished business

Tue, 04 Nov 2025 10:10:00 +0000

The conventional distinction between “foreground” request handling and “background” operations in web development is broken, misleading, and incomplete.

There, I said it.

Conventional browser, controller, background job flow

Baltic Ruby 2025 talk: an Event-Sourced programming model for Ruby

Tue, 02 Sep 2025 10:10:00 +0000

Video of a presentation on Ruby and Event Sourcing I gave at Baltic Ruby 2025 back in June.

Watch the talk on YouTube

Said elsewhere (August 2025)

Fri, 29 Aug 2025 22:59:00 +0000

Things I’ve said on Bluesky in August 2025. On Event Sourcing, Domain-Driven Design, Ruby, and software architecture.

Identity and behaviour

Thu, 10 Jul 2025 22:59:00 +0000

In Object Oriented programming, identity and behaviour are often conflated. But it can be useful to think of them as different concepts.

Give it time

Mon, 21 Apr 2025 22:59:00 +0000

Our experience of reality is based on the passage of time. Things begin and end, events happen one after the other. The world changes. And yet we model software as static object graphs frozen in time.

Dead Code Podcast Notes

Tue, 14 Jan 2025 11:55:54 +0000

I was recently invited to chat at the Dead Code podcast (thank you for the invite!), about Event Sourcing and Ruby. Here are some notes (and corrections!) from the conversation.

What do commands do in Event Sourcing

Sun, 22 Dec 2024 11:00:00 +0000

I’ve been playing with and exploring Event Sourcing for a while now, but only recently realised that part of my thinking might have been muddled by unexamined assumptions about what commands are and what they do in the context of Event Sourcing.

The Decide, Evolve, React pattern in Ruby

Mon, 16 Sep 2024 11:00:00 +0000

The Decide, Evolve, React pattern provides a unified mechanism for expressing, handling and reacting to state changes in a system. It optionally provides a lossless audit trail of changes, and the seeds of a pub/sub sub-system, by tying together events to the state changes they cause. It’s a generalisation of the Event Sourcing pattern, but it doesn’t require a log of events or a replay mechanism, and can be readily leveraged by traditional CRUD systems.

Railway-Oriented Pipelines in Ruby pt. 5: Testing pipelines

Wed, 20 Mar 2024 14:00:00 +0000

In this series: Part 1: Practical Railway-Oriented Pipelines in Ruby Part 2: User input, errors and metadata Part 3: Extending pipelines Part 4: Middleware Part 5: Testing pipelines Testing pipelines. Testing any complex workflow can be challenging. Composable pipelines can make it easier to use a “divide and conquer” approach to testing. 1. Unit test each step in isolation. Steps may or may not be complex, but their simple #call(Result) Result interface makes them easy to test.

Railway-Oriented Pipelines in Ruby pt. 4: Middleware

Wed, 20 Mar 2024 13:00:00 +0000

In this series: Part 1: Practical Railway-Oriented Pipelines in Ruby Part 2: User input, errors and metadata Part 3: Extending pipelines Part 4: Middleware Part 5: Testing pipelines In the previous article in this series I showed how to extend the basic pipeline with domain-specific steps and helpers. Here I’ll show how to add middleware to the pipeline, to add tracing, logging, caching, and other cross-cutting concerns. Middleware Middleware is a bit of code that wraps around each step in the pipeline, adding functionality to it.

Railway-Oriented Pipelines in Ruby pt. 3: Extending pipelines

Wed, 20 Mar 2024 12:00:00 +0000

In this series: Part 1: Practical Railway-Oriented Pipelines in Ruby Part 2: User input, errors and metadata Part 3: Extending pipelines Part 4: Middleware Part 5: Testing pipelines In the previous article in this series I showed how to pass extra metadata from one step to the next, including user input, errors and context data. This article expands on the previous ones by showing how to extend the pipeline with domain-specific steps and helpers.

Railway-Oriented Pipelines in Ruby pt.2: User input, errors and metadata

Wed, 20 Mar 2024 11:00:00 +0000

In this series: Part 1: Practical Railway-Oriented Pipelines in Ruby Part 2: User input, errors and metadata Part 3: Extending pipelines Part 4: Middleware Part 5: Testing pipelines In the previous article I described a bare-bones implementation of Railway-oriented pipelines in Ruby. I showed how to build pipelines of steps that can be executed sequentially, with each step receiving the result of the previous one. # An illustrative data processing pipeline DataImporter = Pipeline.

Practical Railway-Oriented Pipelines in Ruby

Sun, 17 Mar 2024 12:19:16 +0000

In this series: Part 1: Practical Railway-Oriented Pipelines in Ruby Part 2: User input, errors and metadata Part 3: Extending pipelines Part 4: Middleware Part 5: Testing pipelines Some years ago I explored patterns for building composable processing pipelines in Ruby, using a Railway-oriented paradigm. In this series, I’ll describe a simplified implementation for practical use. # An illustrative data processing pipeline DataImporter = Pipeline.new do |pl| pl.step ValidateUserInput pl.step ReadCSV pl.

Event Sourcing with Ruby examples. The Command layer.

Mon, 04 Jul 2022 10:00:00 +0100

This is part of a series on Event Sourcing concepts, with Ruby examples. Read the previous part: Event Sourcing with Ruby examples. The Event Store interface. The Command Layer is conceptually the place where business logic happens, user input is handled and decisions are made. It’s not by any means unique to event-sourced apps, but present in all kinds of software in one way or the other. In event-sourced apps it can take many forms, but the general flow is this:

Event Sourcing with Ruby examples. The Event Store interface.

Tue, 28 Jun 2022 10:00:00 +0100

This is part of a series on Event Sourcing concepts, with Ruby examples. Read the first part: Event Sourcing from the ground up, with Ruby examples, part 1. The Event Store interface is the canonical data store in event sourcing, and it’s in charge of persisting and retrieving events produced by your system. #append_to_stream(stream_id String, events List<Event>) boolean #read_from_stream(stream_id String) List<Event> The stream_id is the identity of an entity in your domain.

Event Sourcing from the ground up, with Ruby examples, part 1

Mon, 27 Jun 2022 17:00:00 +0100

In this series I’ll go over the basic concepts in Event Sourcing. The code examples are in Ruby, but the general principles should apply in any language. What’s Event Sourcing The essential idea is that the state of objects in an app is tracked by a sequence of events describing discrete changes to those objects. For every state change, an event is produced and appended to a log in storage. Conversely, the current state of objects in the app is obtained by “replaying” all relevant events from the log and aggregating the described changes onto the object.

Exploring Railway-Oriented programming in Ruby

Thu, 14 Oct 2021 11:32:35 +0100

An exploration of patterns for building composable data pipelines in Ruby, from the basics to the possibly YAGNI. Function composition Ruby’s function composition allows you to neatly chain Procs together using the #>> operator. DISCOUNT = 200 substract_discount = ->(amount) { amount - DISCOUNT } TAX_RATE = 0.19 add_tax = ->(amount) { amount * (1 + TAX_RATE) } calculate_total = substract_discount >> add_tax calculate_total.call(1000) # 952.0 #>> (and its inverse, #<<) are implemented in procs and method objects, so it’s possible to write class-based steps.