Browse Articles
ASP.NET Core & C# Development
8 articles
ASP.NET Core, Web APIs, Entity Framework, Dependency Injection, authentication and production-ready .NET development.
Architecture & Engineering
9 articles
Practical software architecture, Clean Architecture, modular monoliths, and building maintainable systems that scale.
Testing
2 articles
Unit testing, integration testing, test-driven development (TDD), mocking, and strategies for building reliable software.
AI Engineering
3 articles
AI-assisted software development, LLMs, developer productivity, coding assistants, and the evolving role of artificial intelligence in software engineering.
Career & Self-Development
4 articles
Communication, teamwork, leadership, productivity, body language, developer mindset, and professional growth in software engineering.
Articles
The Vibe Coding Traps and Delusions
For a long time, I am thinking about writing something on this topic, but since I was not sure about my thoughts and how to formulate them, I kept silent. The last few months things are getting clearer in my mind, so here I am to express my opinion on current AI development and its influence on software engineering industry and everyday tasks of one developer.I am writing this post in hope that my experience of more than one year actively using LLMs and agents in coding could help someone who is struggling with the entire idea behind. →
Git Merge vs Rebase: How to Keep a Clean Git Commit History
A well-maintained Git log is more than just a record of commits. It is a story of your project’s growth, collaboration, and problem-solving. But as projects scale and teams grow, Git logs can become cluttered, making it harder to trace changes, understand context, or troubleshoot issues. →
Why Soft Skills and Body Language Matter for Software Developers
When we think of software developers, we often imagine them focused only on the (messy) code. But in an usual collaborative work environment, technical skills alone are not enough. Body language does significantly influence how you are perceived, how you connect with your team, and how effectively you convey your ideas.We will try here in a few points to summarize why body language is important for developers and what we should pay attention to: →
The Adapter Pattern in C#: Bridging Incompatible Interfaces
The Adapter Pattern is a structural design pattern that allows objects with incompatible interfaces to work together. Rather than modifying existing code to fit a new system, the Adapter Pattern lets us wrap it with a new interface, acting as a bridge between mismatched parts of your application. →
API Versioning and Integration Testing in ASP.NET Core
In the previous post, we have paid attention on our project structure and organizing the code in multiple layers to achieve better readability and easier maintenance in the future. Now we can focus on long-term sustainability through versioning and testing. →
Clean Architecture in ASP.NET Core: Service & Repository Patterns
In the previous post, we added global error handling and logging using NLog. Now that we’ve made our API more resilient, it’s time to go forwards with cleaning up the architecture and separate concerns. →
Global Exception Handling in ASP.NET Core APIs Using NLog
In the previous post, we set up a basic .NET 9 Web API project. Now it’s time to take things further by adding global error handling and logging to make our API more robust. →
ASP.NET Core Web API Setup: Structure and Database Migrations with FluentMigrator
Welcome to the first post in the “.NET Core Web API – Step-by-Step Best Practices” series. In this series, we’ll walk through building a modern, clean, and maintainable Web API using .NET 9. Each post will focus on a specific aspect, from project setup and architecture to migrations, logging, testing, and versioning. →
Understanding the Prototype Pattern and Deep Cloning in C#
In software development, there are scenarios where creating multiple objects with similar attributes and configurations is necessary. Instead of constructing each object from scratch, a more efficient approach is to duplicate an existing instance. This is precisely what the Prototype Design Pattern facilitates. →
Dependency Injection with the Strategy Pattern in ASP.NET Core
In the previous post, we gave an introduction and explained the basic concept of the Strategy Pattern. Now, we want to go a bit further and demonstrate how it works in practice alongside a dependency injection in .NET Core. Instead of manually instantiating strategies, we let the ASP.NET Core DI container inject the correct implementation at runtime. →