Hi, I'm Tomasz

Why Observer is so cool?

Managing complexity in large code base is all about decoupling. Observer is a perfect tool to do that. The Observed object has no idea about its observers, no dependency injection is required at all, as a result a loose coupling is achieved between two classes of objects where the only common part is the interface they agree upon.

First iteration

It’s a classic design pattern and I’m sure majority (if not all) of engineers know the details behind it, most of us implement it in a slightly different way, depending on the requirements and the code base we are working with though. Here’s my flavour of this design pattern.

Why signals are important

Signals are the simplest form of IPC in Unix-like systems. They are notifiers to the process that an external event has happened. As this is a system specific mechanism, there’s no portable C++ STL library providing support for signal handling. But it’s fairly easy to write one. First though a short introduction is required.

Signal disposition

Each thread in a process has a signal mask which can be modified either via setprocmask (for single threaded processes) or pthread_sigmask (for multithreaded processes). Every raised signal is checked against the mask. If it’s blocked, it’s residing in a PENDING state and it will be immediately handled once unblocked. If it’s not blocked, its corresponding signal handler will be called or the default action executed in case there is none. Of course there are signals which can’t be blocked or its disposition can’t be altered (like SIGKILL or SIGSTOP). In other words, pending signal is handled as soon as thread’s signal mask unblocks it. It’s also worth to remember that signals are not queued (aside from realtime signals - these are queued). Multiple subsequently raised pending signals will be handled as if a single one was raised.

Callbacks are a perfect way for clients to interface with an API abstracting an events source. How to design an API for such abstraction to make it unambiguous and easy to use? The simplest choice is functor injection, similarly as it is done in many places in STL (or even C stdlib by means of function pointers). Can we do better though? What are the alternatives available? In this post, I’ll try to provide a step by step overview of a design process for an imaginary HttpServer class.