Recently published articles

Model Context Protocol (MCP): Connecting Context, Agents, and Modern Software Architecture This article presents the Model Context Protocol (MCP) as a structured approach for integration between language model-based agents and corporate systems, with an emphasis on governance, predictability, and security. Unlike direct and ad hoc integrations, the MCP establishes explicit contracts for the exposure of capabilities through tools, resources, and prompts, reducing ambiguities and limiting the agent's access to the domain.

From Document to Code: Unit Tests Derived from Spec Driven Design This article explores the interconnection between Spec Driven Design (SDD) and unit testing, highlighting its importance in agile software development. The specification is presented as the foundation for creating unit tests, ensuring that the implementation meets the defined expectations. Practical examples in C# and Go illustrate the transformation of specifications into tests.

Security in APIs: Implementation of OAuth 2.0 and OpenID Connect in Applications, with a Focus on Protecting Sensitive Data This article explores the importance of security in APIs, highlighting the OAuth 2.0 and OpenID Connect protocols as effective solutions for authentication and authorization. The functioning of OAuth 2.0 is detailed, including its main steps and implementation examples in C# and Go. OpenID Connect is presented as an identity layer on top of OAuth 2.0, with its peculiarities and practical implementations.

When Trust is Faster: The Role of Optimistic Locking in High Scalability Architectures The article explores the use of Optimistic Locking as an effective strategy to improve performance and scalability in web and mobile applications. Unlike Pessimistic Locking, which locks resources and can cause contention, Optimistic Locking allows for multiple simultaneous transactions, assuming that conflicts are rare. The technique is detailed in implementation steps, exemplified in C#, and is recommended for scenarios with a low frequency of writes.

When a Relational Database is Not Enough: The Role of KVS in Modern Architecture This article explores the growing role of Key-Value Stores (KVS) as alternatives to relational databases, especially in contexts that require scalability, flexibility, and high performance. Although relational databases are useful, their limitations in high-demand scenarios are evident. KVS offer simplicity and fast access to data, making them ideal for applications that require low latency and high availability.

Event-Driven Messaging: Implementing RabbitMQ, Kafka, and Azure Service Bus in .NET This article provides an introduction to event-driven messaging, highlighting its importance in distributed systems for asynchronous communication. Three main solutions are explored: RabbitMQ, Apache Kafka, and Azure Service Bus, all applicable in .NET. The text includes guidance on installation and practical examples of publishing and consuming messages for each solution.

Idempotence in Distributed Systems: Ensuring Consistency in APIs and Messaging This article addresses idempotence in distributed systems, highlighting its importance in APIs and messaging. Idempotence ensures that operations can be repeated without changing the result, avoiding inconsistencies, especially in failure situations. The text presents basic concepts, design principles in REST APIs, and practical examples in C# to implement idempotent methods, both in APIs and in message consumers using RabbitMQ.

CQRS and OpenAI: architectural patterns for command-oriented systems and intelligent responses. This article explores the combination of CQRS (Command Query Responsibility Segregation) and OpenAI to develop more robust and efficient systems. CQRS separates read and write operations, allowing for performance optimization and scalability. The integration with OpenAI facilitates the automation of commands and the generation of intelligent responses, enhancing the user experience. The text discusses benefits, such as greater efficiency, and challenges, such as complexity and costs.

Use of out and in in Generic Interfaces: Covariance and Contravariance This article explores the use of covariance and contravariance in generic interfaces in C#, clarifying the `out` and `in` modifiers. It initially defines the concept of generic interfaces, followed by an analysis of the principles of covariance, which allows the use of derived types, and contravariance, which enables the use of base types.