Distributed systems

  • We need insights, not data (19 April 2022)
    Gauges and graphs attract software engineers like honey for bees. We spend hours implementing distributed logging solutions or monitoring systems, and still we have a hard time understanding what's going on.
  • Where we're going, we don't need service discovery (12 March 2022)
    Too many times technology is used to solve problems that, to begin with, should not be considered problems. Service discovery, on many occasions, is a solution in search of a problem.
  • AsyncAPI, a specification for defining asynchronous APIs (23 February 2022)
    Distributed systems governance is a hot topic. At first, it might feel overwhelming. It's important to understand what we need to govern and which tools can help.
  • Is it complex? Break it down! (3 January 2022)
    Sometimes, we choose technology based on the perceived complexity or heaviness. We focus our decisions on the technical solutions and rather than looking deeper at the problems, we stick with what we know. Are we making the right choices?
  • Isn't A supposed to come before B? On message ordering in distributed systems. (20 October 2021)
    We are used to lists, sequences, and procedural approaches. We are constantly under the impression that what we do is ordered. That's not the case. Why are we trying to replicate into software architectures a non-existent ordering?
  • Update me, please (3 August 2021)
    We're so used to notifications that we probably never stopped to think about how to implement them. It might be trivial at first glance. However, in a distributed system, we might face more challenges requiring techniques we don't expect when implementing a notifications infrastructure.
  • Don't keep a saga in both camps (28 July 2021)
    When it comes to distributed systems, autonomy is a guiding star, and coupling is the villain trying to sneak in at every step. Orchestration is a particularly subtle form of coupling, usually detected when it's too late. However, the root cause is somewhere else.
  • Own the cache! (15 July 2021)
    Caches are everywhere and power the internet. When it comes to distributed systems, they are an essential tool in our tool belt. However, special care needs to be put into defining who owns the cache.
  • I'll be back (8 February 2021)
    Time from the perspective of systems design has many nuances and complexities. There are clock drift issues and design issues related to modeling the passage of time. Shall we model the passage of time as a clock does?
  • Do not trust the user mental model: Model behaviors, not data (2 February 2021)
    When designing systems, we say how important it is to model the system following the user mental model. Nonetheless, it works. However, it's not necessarily always the right choice.
  • Transactions? None for me, thanks (30 January 2021)
    Queues are designed for reliability. I personally stress a lot about designing message processing to be as transactional as possible. Is there a use case for unreliable message processing?
  • Ooops, can I try again, please? (21 January 2021)
    When systems fail, we can retry the whole process and be successful. However, there are scenarios in which retrying a subset of the process might be a better choice. Not all failures are born equal.
  • Ehi! What's up? Feedback to users' requests in distributed systems (12 January 2021)
    The system's design proceeds at full speed; all of a sudden, a thunderbolt hits us: how do we go about providing feedback to users? Request handling is asynchronous, and thus results are eventually consistent. What technique can we use to preserve the user context to get back to them with results?