Link to the talk on YouTube:
Sketchnote: Every Event, Everywhere, All at Once – Jacqui Read
S
Sketchnote: Modelling up! – Alberto Brandolini
S
Link to the talk on YouTube:
Sketchnote: what we learned about event sourcing and DDD while building a bank – Thomas Bøgh Fangel
S
Link to the talk on YouTube:
Software Architecture is more than Boxes and Arrows
S
I watch many software architecture talks (on-site and virtually), and I am starting to think that my understanding of software architecture differs from that of most speakers. I see a lot of talking about bounded contexts (as in Domain Driven Design), layers (as in Clean /Hexagonal/Onion Architecture), and dependencies (between classes, up-stream/down-stream contexts). Don’t get me wrong; these concepts are important. However, they are just a small part of all the aspects a software...
Your First day on the team = releasing Your first feature
Y
Welcome to our team! Today is your first day, which means it’s the day you’ll release your first feature. You’ll see everything needed to design, implement, and release a feature in our system. We’ll touch on F# language features, our TDD style, and some architecture topics.
This blog post is part of the F# Advent Calendar 2024 (thanks, Sergey, for the organisation).
Onion, Hexagonal, Clean or Fractal Architecture? All of them, and more!!
O
Onion, Hexagonal, Clean, or Fractal Architectures aim to organize how we deal with dependencies in our software architectures. But which one should we choose? After distilling the essence of each approach and comparing the advantages and challenges, I’ll show how to combine all of them into an approach to use evolutionary steps towards an architecture that fits your needs from day one until the software dies. You’ll see that layers and slices aren’t enough. A modularisation that fits the domain...
Evolution of Software Architectures
E
Evolutionary software architecture has gained much traction lately—at least in my bubble. It is one of my favourite topics, and I have presented and conducted workshops on it for over a decade. So, let me add a thought to the discussion:
The evolution of a software architecture has three dimensions:
Technical evolution,
conceptual evolution, and
the evolution of business capabilities
(Mis)estimation – why estimates tend to be wrong
(
Probably every software developer had to estimate the effort needed to implement some wanted software. And the estimate was likely rather wrong. I collected reasons why this happened to me over many years. And I concluded that the estimation approach is fundamentally wrong. Here are my reasons:
Our Experience with Bi-temporal Event Sourcing
O
Bi-temporal event sourcing combines storing data as a sequence of events, which tell what has happened with the data, and the data has two associated points of time, one when the data entered the system and one when the data takes effect. This post is about our 8+ years of experience with bi-temporal event sourcing, along with code samples showing how to achieve this. Feel free to skip the code blocks and just read the conceptual parts. But you’ll miss the beauty of F# 😂 This post is part...
Myths about F#: Code without type annotations is hard to review! No, it’s a relief.
M
After one of my presentations about F#, we had a discussion about the effect of type inference, resulting in almost no type annotations, on code readability and reviewability. The concern was that it makes the code harder to understand, especially when reviewing code, for example, outside of an IDE (GitHub/Azure DevOps/… Pull Requests).
So is there a problem or not? Let’s see.