My personal space

We Began to Forget: Demystifying Spring Framework

Thu, 15 Jan 2026 00:00:00 +0000

We began to forget how to pass parameters to functions.

Before @Bean, before @Configuration or @PropertySource and certainly way before WebSecurityConfigurerAdapter objects were responsible not only for their own behaviour, but also for creating everything they depended on.

public class OrderService {
    private final PaymentProcessor processor;
    public OrderService() {
        this.processor = new StripePaymentProcessor();
    }
}

This code works, but it also quietly locks many decisions inside the class, because OrderService now decides which payment processor is used, how it is created, and when its lifecycle starts, and once this happens, changing that decision means changing the code itself. Configuration and behaviour start to mix, breaking single responsibility principle.

We Began to Forget: Public Morozov Anti-Pattern

Mon, 05 Jan 2026 00:00:00 +0000

I decided to start new series of blogs called “We Began to Forget”. The idea is simple and a little melancholic. Software engineering has a short memory, patterns get discovered and then forgotten, lessons get relearned. These posts are small memory refreshers about important aspects of our craft with a strong focus on clever hacks rather than things you can read in clever books. Books will make sure the good patterns will live on, but tribal knowledge has to be passed by word of mouth.

Hi there 👋

Thu, 18 Jan 2024 00:00:00 +0000

Father of 2, FP enthusiast, Software Engineer, Geek

Currently

Principal Software Engineer, Atlassian

Playing solution architect and tech lead roles for the new cloud platform development from inception to production roll out.

Specialized in

Design and architecture using AWS services

Proficient with Languages and Stacks:

Java and Kotlin: 18 years Spring Framework Javascript and Typescript: 18 years AngularJS, React Scala: 10 years typelevel and ZIO stacks Clojure: 1 year, Rust 1 year

Avoiding Stringly Typed

Thu, 24 Feb 2022 00:00:00 +0000

There’s this saying that you shouldn’t have String as your function input unless you expect three volumes of War and Peace as valid input. So unless it’s your case and you want to improve your codebase to be more precise in type signatures, I invite you to discuss one possible option. I’ll use the following API as our case study:

interface EmailSender {
  void sendEmail(String from, String to, String subject, String body);
}

there’s an obvious ambiguity in the type signature here. All of the arguments are of the same type and can be easily misplaced. Not to mention that any string is accepted as a valid input that, as it seems, suppose to only be a valid email.

Consistency: There and Back Again

Sun, 18 Jul 2021 00:00:00 +0000

What is Consistency token? Link to heading

A consistency token represents the state of a resource or entity at a given point in time. It is opaque to consumers, returned in the ETag header by data modifying APIs. Consumers may cache some of these tokens in a request-local or short-term cache when coordinating a number of calls to control the consistency they require via a custom Event-Stream-State request header(s) with the following format (as per standard RFC definition):

Cross-Compiling Scala in Gradle project

Mon, 20 May 2019 00:00:00 +0000

It is quite common and widely spread practice for Scala projects to cross-compile and publish several artifacts for multiple versions of Scala compiler. As a rule, for the purposes of creating several versions of one artifact teams using SBT where this feature is avaiable right out of the box and can be configured in a couple of lines. But what if we want to cross-publish our Scala project the same way without using SBT?

Monads Explained

Fri, 01 Feb 2019 00:00:00 +0000

Referential transparency Link to heading

Referential transparency is a nice property of pure functional programming languages that allow us to reason about the behaviour of our programs. It guarantees that all expressions are always evaluating to the same result in any context. What it gives to the programmer is an ease of equational reasoning about any pure program as they used to do it in math.

Here you are!

Sat, 26 Jan 2019 00:00:00 +0000

Hi, there.

If you’re reading this that means that you’ve ended up in my personal blog. Welcome! I’ll try to keep it short and interesting for both of us.

In the past few years, I’ve got fascinated by the topic of pure functional programming. I was lucky enough to see it being applied in real-world projects, I learned a lot from people practising it at their everyday work. And today, I believe I grasped enough knowledge on this topic for me to share it with you as a series of educative blog posts.