Blogs on Ivaldo de Oliveira Batista Júnior

Who Signs Off on AI Decisions?

Thu, 30 Jul 2026 09:00:00 -0300

Who owns the decision?

When a system denies credit, prioritizes a patient, or recommends a course of treatment, it is not acting alone. Before an output ever exists, someone has decided which data matters, what kind of error is tolerable, and when the machine may act without human review.

The ethical question, then, is not whether the model has morals. It is: who is willing to put their name to the decision?

Being a Developer Is Not Just About Writing Code

Wed, 01 Jul 2026 10:45:14 -0300

Introduction

For a long time, many people looked at software development as the act of writing code. A developer would receive a requirement, open the editor, write classes, functions, queries, screens, tests, and deliver something that runs.

That view is understandable, but incomplete.

Code is the most visible part of our work. It is the artifact that goes to the repository, passes through review, enters the pipeline, and reaches production. But before code exists, there is interpretation. There is context. There are tradeoffs, conversations, doubts, decisions, and responsibilities.

Spec Driven Design: Automating Software Generation with AI Agents and GitHub Templates

Fri, 24 Oct 2025 10:01:04 -0300

The End of “Boilerplate”: AI Generating Projects, Not Just Code

How much time does your team spend configuring a new project? Creating Controllers, registering the DbContext, defining the csproj… all before writing the first line of business logic?

Tools like GitHub Co-pilot have changed how we write code, but they are assistants. The next leap is generative automation: using AI to create the entire structure of a project.

The problem? Pure AI is “creative chaos.” It can “hallucinate” and deliver inconsistent results, breaking the architectural standards we fight so hard to establish.

Supercharging C# Logs with [CallerFilePath] and [CallerLineNumber]

Tue, 07 Oct 2025 09:15:00 -0300

Introduction

It’s 3 AM. A critical alert wakes you up: a service in production is failing. You open the logs, desperately searching for a clue, only to find a sea of generic messages like "An error occurred during processing". Frustration mounts. Where in the thousands of lines of code did this happen? We’ve all been there. This moment is where the true value of well-structured logging becomes painfully clear.

Writing good logs is an act of empathy—empathy for your future self and for the colleagues who will have to debug your code under pressure. Fortunately, the .NET platform provides powerful, yet simple, tools to turn our logs from ambiguous notes into precise, actionable information. In this article, we’ll explore how to use the [CallerFilePath] and [CallerLineNumber] attributes to enrich our logs, making debugging faster, more efficient, and much less stressful.

Unlocking the Saga Pattern with .NET 9, MassTransit, and RabbitMQ: Orchestrating Microservices with Confidence

Sat, 13 Sep 2025 14:00:00 -0300

Introduction: The Pain of Inconsistency

In the world of microservices, each service has its own database, its own source of truth. This autonomy is fantastic for scalability and decoupling, but it presents us with a monumental challenge: how do we ensure the consistency of a business process that spans multiple services?

Imagine a simple e-commerce flow:

The Orders Service creates a new order.
The Payments Service processes the credit card.
The Inventory Service debits the product from the inventory.

If the order is created and the payment is approved, but the Inventory Service fails (perhaps the item went out of stock at the last second), what happens? The customer has been charged for a product they won’t receive. The overall state of the system has become inconsistent. Trying to solve this with direct HTTP calls and complex try-catch blocks is a path to fragile code and a maintenance nightmare.

Hexagonal Architecture in .NET: From Controllers to Ports & Adapters in a Real Project

Mon, 08 Sep 2025 15:15:00 -0300

Introduction: The Pain of Coupling

If you’ve been developing with .NET for a while, you’ve probably seen or written a Controller like this: it receives an HTTP request, validates the data, handles business logic, talks directly to Entity Framework, maybe calls another API with HttpClient, and finally, returns an ActionResult. At first, it seems productive. But over time, this controller becomes a monster: fragile, difficult to test, and terribly coupled to technology.

Hangfire and Decentralized Queues: Practical Guide for .NET Developers | Hangfire e Filas Descentralizadas: Guia Prático para Desenvolvedores .NET

Mon, 11 Aug 2025 00:00:00 +0000

Hangfire and Decentralized Queues: Practical Guide for .NET Developers

In modern software architecture, background job processing is a key element for scalability and user experience. Hangfire is a powerful .NET library that enables you to manage and process jobs in a decentralized queue without needing external services. This article will guide you through its concepts, benefits, real-world use cases, and a complete example you can run today.

What is Hangfire?

Hangfire was created to simplify background processing in .NET applications. It allows developers to schedule and execute jobs asynchronously without manually managing threads, timers, or message queues.

Optimizing PostgreSQL for .NET Apps | Otimizando PostgreSQL para Aplicações .NET

Mon, 11 Aug 2025 00:00:00 +0000

Optimizing PostgreSQL for .NET Apps

When building high-performance applications with .NET and PostgreSQL, database tuning can make the difference between a smooth, scalable product and a bottleneck-prone system. In this article, we’ll explore performance best practices, PostgreSQL configuration tweaks, and .NET-side optimizations for faster queries and better resource utilization.

Why PostgreSQL for .NET?

PostgreSQL is one of the most reliable, powerful, and extensible relational databases. Combined with the Npgsql driver, it offers native .NET support, strong ACID compliance, and advanced features like JSONB, full-text search, and partitioning.

The Complete Guide to Logging in Blazor WASM: From Basics to Advanced with a Custom Provider

Tue, 08 Jul 2025 11:55:00 -0300

If you’ve ever developed for the web, you know the feeling: a user reports an error you can’t reproduce. “Something went wrong when I tried to save,” they say. No further details. If the problem happened on the server, you likely have logs to investigate. But what if the error occurred entirely in the user’s browser? The console logs, if they ever existed, were lost forever the moment the tab was closed.

Security Isn't About Pentesting: How to Prevent Vulnerabilities Before the First Commit

Sat, 14 Jun 2025 19:50:00 -0300

Introduction: The Illusion of the “Security Wall”

In the world of software development, there’s an old and dangerous practice: treating security as a final step. Teams spend months developing and, just before launch, they “throw the code over the wall” for a security team or a penetration test (pentest) to find the flaws. This model isn’t just inefficient; it’s expensive and risky.

The truth is, the most effective security is born with the code. In this article, we’ll explore the concept of Shift-Left Security: the practice of moving security to the beginning of the software development lifecycle (SDLC).

Practical Guide to Implement Cybersecurity in Small Businesses

Mon, 14 Oct 2024 09:47:54 -0300

1. Introduction

In the digital age, cybersecurity is no longer a luxury reserved only for large corporations. For small and medium-sized enterprises (SMEs), implementing cybersecurity measures has become a critical necessity. According to a 2023 Verizon report, 43% of cyber attacks target small businesses. This is because cybercriminals view SMEs as easy targets, often with inadequate defenses and valuable data.

This guide will offer practical and accessible steps for small businesses to significantly strengthen their cybersecurity posture.

Challenges and Solutions in Migrating Applications to Microservices

Wed, 04 Sep 2024 06:36:23 -0300

Challenges and Solutions in Migrating Applications to Microservices

Introduction

In recent years, the microservices architecture has become a widely adopted approach for companies looking to scale their applications more efficiently and flexibly. This architecture allows large applications to be divided into small, independent services, where each service is responsible for a specific part of the business logic. Unlike the monolithic architecture, where all components are interdependent and run in a single environment, microservices offer greater flexibility for development, deployment, and scalability.

Generating PDFs in Blazor WebAssembly with jsPDF and html2canvas

Mon, 26 Aug 2024 11:07:09 -0300

Introduction

When designing and developing modern web applications, we often encounter the need to generate PDF documents from HTML content. Whether to provide reports, receipts, or simply to allow users to save information in a portable and widely accepted format, PDFs are an indispensable resource.

However, when developing applications with Blazor WebAssembly, an emerging framework that offers a client/server-like programming experience in the browser, implementing this functionality can present challenges. The interaction between the C# language used in Blazor and the JavaScript libraries commonly used for PDF generation, such as jsPDF and html2canvas, can be complicated.

Implementing Hosted Services in ASP.NET Core

Sun, 25 Aug 2024 07:56:16 -0300

Introduction

In the dynamic world of programming, learning to work effectively with various frameworks is crucial. This article explores an important feature in the .NET universe – Hosted Services in ASP.NET Core.

Hosted services are fundamental components that allow long-running tasks to be executed in the background, providing an elegant way to free up resources and enable applications to continue functioning without interruption. In a world where speed is essential, the ability to perform background tasks is invaluable. For ASP.NET Core applications, hosted services are the perfect solution for effectively managing tasks that would otherwise consume valuable resources.

The Importance of Developing Empathy for Your Future Self and Future Developers: Writing Clear and Readable Code

Wed, 06 Dec 2023 14:35:51 -0300

Introduction

In the world of software development, the code we write today will be read, maintained, and expanded by others, including our future selves. A lack of clarity and readability in code can lead to difficulties, wasted time, and increased errors. Developing empathy for our future selves and future developers is essential to creating sustainable and efficient code. This article will discuss the importance of this empathy and present practices for writing clear and readable code.

Software Design Patterns Not Always the Best Solution

Mon, 25 Sep 2023 14:35:51 -0300

Introduction

Software design patterns are often hailed as the holy grail of best practices in software engineering. They provide pre-defined solutions to common problems, promoting efficiency and readability. However, every tool has its limitations, and design patterns are no exception. This article aims to dive into the nuances of when design patterns can be more of a hindrance than a help.

Overview of Design Patterns

Design patterns are not just technical solutions to common problems; they also serve as a common language that can enhance communication among developers. Concepts like Singleton, Observer, and Strategy have become part of the standard lexicon in software engineering. However, it is crucial to understand that these patterns are not universal remedies, and applying them indiscriminately can have consequences.

_An Unexpected Error Was Encountered While Executing a Wsl Command

Wed, 16 Aug 2023 14:58:47 -0300

Introduction

If you’ve ever delved into the world of software development on a Windows machine, it’s likely you’ve encountered the promising combination of Docker and WSL2. This duo, when operating in harmony, promises a smooth and effective experience, bringing the Windows development environment closer to the Linux universe. However, as many of us have discovered, things don’t always go as expected.

Imagine starting your day, ready to dive into your project, only to be greeted with the following error message:

Managing Authentication in Web Applications Case Study Blazor WebAssembly

Tue, 08 Aug 2023 14:35:51 -0300

Introduction

Overview of the Challenge

In modern web applications, securely storing authentication tokens and associated information is essential to protect the integrity and confidentiality of user data. The issue becomes even more complex when considering the need to persist this information across browsing sessions without compromising security.

The challenge is how to balance the need for accessibility and security in these cases.

Article Objective

The purpose of this article is to explore a specific approach to this challenge using in-memory storage with Blazor WebAssembly on the .NET platform.

Mediator Design Pattern: Simplifying Interactions in Distributed Systems

Sun, 09 Jul 2023 14:35:51 -0300

Introduction

In recent years, computing has witnessed a significant shift toward distributed systems. The need for scalability, availability, and flexibility has driven the development of complex architectures where different software components interact to provide comprehensive functionalities. However, as distributed systems evolve, an inherent challenge arises: the complexity of interactions between these components.

Communication between distinct parts of a distributed system is essential but often results in increased coupling between components. As new modules are added or modified, direct interactions can lead to a web of dependencies, making system maintenance and expansion an arduous task. This is where the Mediator Design Pattern comes into play.

The Art of Problem Solving Methodology Learning

Sun, 01 Jan 2023 14:35:51 -0300

Introduction

In our journey through life, we face a multitude of problems, ranging from daily small obstacles to complex challenges that require deep reflection and collaboration. Whether in the realm of technology, sciences, arts, or everyday life, the ability to approach and solve problems is universally valuable.

However, while problems are a constant, solutions are not. And the key to finding these solutions often lies not in the answer itself but in the approach we take. Methodology—or the structure and processes we apply in the search for solutions—plays a crucial role in determining not only whether we solve a problem but also how efficiently and effectively we do so.

Automating API Client Generation: An Efficient Approach with GitHub Actions and OpenAPI

Wed, 26 Oct 2022 16:36:23 -0300

Automating API Client Generation: Improve Your Productivity with GitHub Actions

In software development, continuous integration and continuous delivery (CI/CD) are essential for increasing productivity and minimizing errors. A common challenge is ensuring that API clients (components that consume APIs) are always up-to-date with API changes. Lack of synchronization can lead to failures and inconsistencies in the system. To address this problem, an effective strategy is to automate the generation of API clients whenever a new version of the API is released. This article discusses how you can use GitHub Actions to automatically generate and update API clients, focusing on tools like NSwag and Kiota, to ensure that API clients are always in sync with the latest version of the API.

Simplifying the API Gateway: From Swagger to Ocelot in One Step

Fri, 26 Aug 2022 16:36:23 -0300

Introduction

In a scenario where microservices are increasingly adopted, managing APIs becomes a critical task. In this context, solutions like Ocelot emerge as powerful options to serve as API gateways. However, manually configuring ocelot.json files can be cumbersome and error-prone. This is where our project comes in: the Swagger to Ocelot Converter.

The Problem

Anyone who has worked with Ocelot knows that the API gateway configuration is done through an ocelot.json file. While flexible and powerful, manually filling out this file can be time-consuming, especially in projects with multiple APIs and routes.