Architecture-notes on Code4IT

Davide's Code and Architecture Notes - Metrics, Logs, and Traces: the three pillars of Observability

Tue, 18 Nov 2025 00:00:00 +0000

Learn the differences between metrics, logs, and traces - the three pillars of Observability in distributed systems - and how to use them effectively.

Davide's Code and Architecture Notes - Software Architecture vs Software Design

Tue, 01 Jul 2025 00:00:00 +0000

Software Architecture and Software Design are terms that look similar but refer to two totally different aspects of software. Let’s find the differences and their purposes.

Harnessing the Power of Jitter: Enhancing Retry Patterns with a bit of randomness

Tue, 06 May 2025 00:00:00 +0000

Operations may fail for transient reasons. How can you implement retry patterns? And how can a simple Jitter help you stabilize the system?

D2: like Mermaid, but better. Syntax, installation, and practical usage tips

Tue, 04 Feb 2025 00:00:00 +0000

D2 is an open-source tool to design architectural layouts using a declarative syntax. It’s a textual format, which can also be stored under source control. Let’s see how it works, how you can install it, and some practical usage tips.

Fitness Functions in Software Architecture: measuring things to ensure prosperity

Tue, 07 Jan 2025 00:00:00 +0000

Non-functional requirements matter, but we often forget to validate them. You can measure them using Fitness Functions.

Davide's Code and Architecture Notes - the Error Management Trio, and how it affects your software architecture

Tue, 05 Nov 2024 00:00:00 +0000

When designing a software system, we naturally focus more on the happy flow. But we should carefully plan to handle errors that fall into three categories: Validation, Transient, and Fatal.

Davide's Code and Architecture Notes - Practical creation of C4 Model diagrams with Structurizr

Tue, 17 Sep 2024 00:00:00 +0000

The C4 Model is one of the most famous ways to describe software architectures. Let’s see some practical usage with Strucutrizr.

Davide's Code and Architecture Notes - Web APIs vs REST APIs vs pseudo-REST APIs

Tue, 30 Jul 2024 00:00:00 +0000

When describing a web service, people often use the wrong terms. Are you really creating a REST API, or is it some sort of pseudo-REST?

Davide's Code and Architecture Notes - Arc42 Documentation, for a comprehensive description of your project

Tue, 02 Jul 2024 00:00:00 +0000

How is your project structured? What are the driving forces? If you don’t know how to express this info, you should try the Arc42 template to create a strong foundation for your documentation.

Davide's Code and Architecture Notes - Introducing SLI, SLO, and SLA

Tue, 19 Mar 2024 00:00:00 +0000

Non-functional requirements. How can you ensure you meet them? Let’s understand SLO, SLA, and SLI, and how they affect your SDLC.

Davide's Code and Architecture Notes - Cache Expiration vs Cache Eviction (and Eviction Policies)

Tue, 06 Feb 2024 00:00:00 +0000

Caching helps your applications be more performant. However, depending on the cache size, you’ll need to sacrifice some items to make space for others. Let’s see some strategies.

Davide's Code and Architecture Notes - Tracking decision with Architecture Decision Records (ADRs)

Tue, 09 Jan 2024 00:00:00 +0000

When designing a system’s architecture, you have many choices to make. How can you track them? ADRs are formal documents to track the reasons behind your decisions, giving context and info about the consequences of each choice.

Davide's Code and Architecture Notes - 4 algorithms to implement Rate Limiting, with comparison

Tue, 07 Nov 2023 00:00:00 +0000

You should always put a limit to the number of incoming requests. Otherwise, you can have your systems exposed to malicious attackers. Let’s see the four main algorithms to implement Rate Limit.

Davide's Code and Architecture Notes - Pros and Cons of API Gateways (with vendors comparison)

Tue, 10 Oct 2023 00:00:00 +0000

API Gateways are often a component of a microservices architecture. But they are not a silver bullet - they have some downsides to consider!

Davide's Code and Architecture Notes - CAP Theorem: it's not just «Pick two»

Tue, 12 Sep 2023 00:00:00 +0000

«Consistency, Availability, and Partition tolerance. Pick two». Is it really THAT simple? Let’s learn a bit more about the CAP theorem.

Davide's Code and Architecture Notes - L4 vs L7 Load Balancer

Tue, 27 Jun 2023 00:00:00 +0000

If you need to handle lots of incoming requests, you should manage the incoming traffic by balancing the load across different servers. You should consider adding a Load Balancer: it’s a layer of abstraction that handles requests, availability, and security in a centralized place.

Davide's Code and Architecture Notes - Testing Pyramid vs Testing Diamond (and how they affect Code Coverage)

Tue, 30 May 2023 00:00:00 +0000

Testing Pyramid and Testing Diamond are two ways of managing automated tests. We’re going to learn what they are and how they are built in relation to Unit Tests, Integration Tests, and End-to-end Tests.

Davide's Code and Architecture Notes - Postel's law for API Robustness

Tue, 18 Apr 2023 00:00:00 +0000

A system should be robust: it should be able to resist change and, well, not generate regressions. Postel’s law helps define a mindset to create robust APIs.

Davide's Code and Architecture Notes - Understanding Elasticity and Scalability with Pokémon Go and TikTok

Tue, 21 Feb 2023 00:00:00 +0000

Elasticity and Scalability: two important Architectural attributes, similar but quite different

Davide's Code and Architecture Notes - Server-side caching strategies: how do they work?

Tue, 24 Jan 2023 00:00:00 +0000

Cache-aside, Read-through, Write-through, Write-behind: quite easy on the surface, but let’s go a little deeper!