<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"><channel><title>Kamil Grzybek Blog</title><description>Software Engineering &amp; Architecture</description><link>https://www.kamilgrzybek.com/</link><item><title>10 common broken rules of clean code</title><link>https://www.kamilgrzybek.com/blog/posts/10-common-broken-clean-code-rules/</link><guid>https://www.kamilgrzybek.com/blog/posts/10-common-broken-clean-code-rules/</guid><description>From time to time I am asked to do code review of an application. I like doing this, because it is always learning experience. I can see how others program, what problems they have and how they solve them. Except that I can see code written in various conditions and by people with different skills and experience. I prepared a list of 10 popular _&quot;clean code&quot;_ broken rules which I often encounter during this code reviews and I would like to share this list with you.</description><pubDate>Tue, 16 Oct 2018 08:14:00 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Automated Tests: Strategy</title><link>https://www.kamilgrzybek.com/blog/posts/automated-tests-strategy/</link><guid>https://www.kamilgrzybek.com/blog/posts/automated-tests-strategy/</guid><description>The third in a series of articles about automated testing. This time about effective testing strategy and approaches.</description><pubDate>Tue, 05 Dec 2023 09:52:00 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Automated Tests: Testability</title><link>https://www.kamilgrzybek.com/blog/posts/automated-tests-testability/</link><guid>https://www.kamilgrzybek.com/blog/posts/automated-tests-testability/</guid><description>The second in a series of articles about automated testing, devoted to an important quality attribute from the point of view of testable architecture - testability.</description><pubDate>Thu, 06 Apr 2023 09:00:00 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Automated Tests: The Why</title><link>https://www.kamilgrzybek.com/blog/posts/automated-tests-the-why/</link><guid>https://www.kamilgrzybek.com/blog/posts/automated-tests-the-why/</guid><description>The first article in a series on automated testing discussing why you should test your software in an automated manner at all.</description><pubDate>Thu, 30 Mar 2023 08:14:00 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Cache-Aside Pattern in .NET Core</title><link>https://www.kamilgrzybek.com/blog/posts/cache-aside-pattern-in-net-core/</link><guid>https://www.kamilgrzybek.com/blog/posts/cache-aside-pattern-in-net-core/</guid><description>Often the time comes when we need to focus on optimizing the performance of our application. There are many ways to do this and one way is cache some data. In this post I will describe briefly the _Cache-Aside Pattern_ and its simple implementation in .NET Core.</description><pubDate>Mon, 29 Oct 2018 09:55:00 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Attributes of Clean Domain Model</title><link>https://www.kamilgrzybek.com/blog/posts/clean-domain-model-attributes/</link><guid>https://www.kamilgrzybek.com/blog/posts/clean-domain-model-attributes/</guid><description>There is a lot of talk about clean code and architecture nowadays. There is more and more talk about how to achieve it. The rules described by Robert C. Martin are universal and in my opinion, we can use them in various other contexts. In this post I would like to refer them to the context of the Domain Model implementation, which is often the heart of our system. We want to have a clean heart, aren&apos;t we?</description><pubDate>Mon, 28 Oct 2019 07:52:26 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Database change management</title><link>https://www.kamilgrzybek.com/blog/posts/database-change-management/</link><guid>https://www.kamilgrzybek.com/blog/posts/database-change-management/</guid><description>Database change management is not an easy task. It is even more difficult when we are at the beginning of a project where the data model is constantly changing. In this post I will describe what we need to do to have a good database change management mechanism.</description><pubDate>Mon, 26 Nov 2018 20:23:00 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Domain Model Encapsulation and PI with Entity Framework 2.2</title><link>https://www.kamilgrzybek.com/blog/posts/domain-model-encapsulation-ef/</link><guid>https://www.kamilgrzybek.com/blog/posts/domain-model-encapsulation-ef/</guid><description>Domain Model encapsulation implementation with Persistence Ignorance in mind using Entity Framework.</description><pubDate>Wed, 13 Feb 2019 13:13:00 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Domain Model Validation</title><link>https://www.kamilgrzybek.com/blog/posts/domain-model-validation/</link><guid>https://www.kamilgrzybek.com/blog/posts/domain-model-validation/</guid><description>In previous post I described how requests input data can be validated on Application Services Layer. I showed FluentValidation library usage in combination with Pipeline Pattern and Problem Details standard. In this post I would like to focus on the second type of validation which sits in the Domain Layer – Domain Model validation.</description><pubDate>Mon, 04 Mar 2019 08:40:00 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Company, don&apos;t waste your programmers time</title><link>https://www.kamilgrzybek.com/blog/posts/dont-waste-your-programmers-time/</link><guid>https://www.kamilgrzybek.com/blog/posts/dont-waste-your-programmers-time/</guid><description>In this post I would like to raise the subject of wasting programmers time which can be easily saved. What&apos;s more, it is said time is money so we can save both! This post is especially for management people (managers, directors, CTOs) but developers should also think about whether they use their potential one hundred percent.</description><pubDate>Mon, 22 Oct 2018 09:12:00 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Feature Folders</title><link>https://www.kamilgrzybek.com/blog/posts/feature-folders/</link><guid>https://www.kamilgrzybek.com/blog/posts/feature-folders/</guid><description>Today I would like to suggest a less-common, but in my opinion a much better way to organize our codebase. Meet the Feature Folders.</description><pubDate>Mon, 03 Dec 2018 14:44:00 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>GRASP - General Responsibility Assignment Software Patterns Explained</title><link>https://www.kamilgrzybek.com/blog/posts/grasp-explained/</link><guid>https://www.kamilgrzybek.com/blog/posts/grasp-explained/</guid><description>GRASP – General Responsibility Assignment Software Patterns (or Principles). There are far fewer materials on the Internet about this topic, so I decided to bring it closer because I think the principles described in it are as important as the SOLID principles.</description><pubDate>Mon, 08 Apr 2019 20:37:26 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Handling concurrency - Aggregate Pattern and EF Core</title><link>https://www.kamilgrzybek.com/blog/posts/handling-concurrency-aggregate-pattern-ef-core/</link><guid>https://www.kamilgrzybek.com/blog/posts/handling-concurrency-aggregate-pattern-ef-core/</guid><description>In this post I would like to discuss a frequently overlooked, though in some circumstances very important topic – concurrency handling in context of protection of the so-called Domain Invariants.</description><pubDate>Thu, 14 May 2020 05:22:26 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Handling Domain Events: Missing Part</title><link>https://www.kamilgrzybek.com/blog/posts/handling-domain-event-missing-part/</link><guid>https://www.kamilgrzybek.com/blog/posts/handling-domain-event-missing-part/</guid><description>Some time ago I wrote post about publishing and handling domain events. In addition, in one of the posts I described the Outbox Pattern, which provides us At-Least-Once delivery when integrating with external components / services without using the 2PC protocol. This time I wanted to present a combination of both approaches to complete previous posts. I will present a complete solution that enables reliable data processing in the system in a structured manner taking into account the transaction boundary.</description><pubDate>Tue, 18 Jun 2019 20:16:26 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>How to publish and handle Domain Events</title><link>https://www.kamilgrzybek.com/blog/posts/how-to-publish-handle-domain-events/</link><guid>https://www.kamilgrzybek.com/blog/posts/how-to-publish-handle-domain-events/</guid><description>Domain Event is one of the building blocks of Domain Driven Design. It is something that happened in particular domain and it captures memory of it. We create Domain Events to notify other parts of the same domain that something interesting happened and these other parts potentially can react to.</description><pubDate>Thu, 11 Oct 2018 17:28:00 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>How to store sensitive configuration data</title><link>https://www.kamilgrzybek.com/blog/posts/how-to-store-sensitive-configuration-data/</link><guid>https://www.kamilgrzybek.com/blog/posts/how-to-store-sensitive-configuration-data/</guid><description>In this post I would like to discuss places where we can store configuration of our application and warn against keeping sensitive configuration data in the code repository. Additionally, I will show example of configuration based on User Secrets and Environment Variables in .NET Core.</description><pubDate>Thu, 08 Nov 2018 06:42:00 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Modular Monolith: Architectural Drivers</title><link>https://www.kamilgrzybek.com/blog/posts/modular-monolith-architectural-drivers/</link><guid>https://www.kamilgrzybek.com/blog/posts/modular-monolith-architectural-drivers/</guid><description>In the first post about the architecture of Modular Monolith I focused on the definition of this architecture and the description of modularity. In this post I would like to discuss some of the most popular, in my opinion, Architectural Drivers which can lead to either a Modular Monolith or Microservices architecture.</description><pubDate>Thu, 26 Dec 2019 21:20:26 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Modular Monolith: Architecture Enforcement</title><link>https://www.kamilgrzybek.com/blog/posts/modular-monolith-architecture-enforcement/</link><guid>https://www.kamilgrzybek.com/blog/posts/modular-monolith-architecture-enforcement/</guid><description>In previous posts we discussed what is the architecture of Modular Monolith and architectural drivers that can affect its choice. In this post, I would like to focus on ways to enforce chosen architecture.</description><pubDate>Sun, 22 Mar 2020 19:41:26 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Modular Monolith: Domain-Centric Design</title><link>https://www.kamilgrzybek.com/blog/posts/modular-monolith-domain-centric-design/</link><guid>https://www.kamilgrzybek.com/blog/posts/modular-monolith-domain-centric-design/</guid><description>In previous posts in this series, I covered what a Modular Monolith is, what its architecture looks like and how this architecture can be enforced. Then I described architectural drivers for this architecture and styles of integration between modules. In this post I would like to go deeper - a level lower and describe how such architecture can be designed. We are not going to implement this architecture yet - we will focus on its technology-agnostic design.</description><pubDate>Mon, 30 Nov 2020 23:31:00 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Modular Monolith: Integration Styles</title><link>https://www.kamilgrzybek.com/blog/posts/modular-monolith-integration-styles/</link><guid>https://www.kamilgrzybek.com/blog/posts/modular-monolith-integration-styles/</guid><description>In this post, I would just like to discuss the missing part – Integration Styles for modules in Modular Monolith architecture.</description><pubDate>Sun, 26 Jul 2020 20:37:26 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Modular Monolith: A Primer</title><link>https://www.kamilgrzybek.com/blog/posts/modular-monolith-primer/</link><guid>https://www.kamilgrzybek.com/blog/posts/modular-monolith-primer/</guid><description>Many years have passed since the rise of the popularity of microservice architecture and it is still one of the main topics discussed in the context of the system architecture. The popularity of cloud solutions, containerization and advanced tools supporting the development and maintenance of distributed systems (such as Kubernetes) is even more conducive to this phenomenon.</description><pubDate>Mon, 02 Dec 2019 22:30:26 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Processing commands with Hangfire and MediatR</title><link>https://www.kamilgrzybek.com/blog/posts/processing-commands-with-hangfire-mediatr/</link><guid>https://www.kamilgrzybek.com/blog/posts/processing-commands-with-hangfire-mediatr/</guid><description>In previous post about processing multiple instance aggregates of the same type I suggested to consider using eventual consistency approach. In this post I would like to present one way to do this.</description><pubDate>Sat, 29 Sep 2018 17:26:00 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Processing multiple aggregates - transactional vs eventual consistency</title><link>https://www.kamilgrzybek.com/blog/posts/processing-multiple-aggregates-transactional-vs-eventual-consistency/</link><guid>https://www.kamilgrzybek.com/blog/posts/processing-multiple-aggregates-transactional-vs-eventual-consistency/</guid><description>When we use Domain Driven Design approach in our application, sometimes we have to invoke some method on multiple instances of aggregate of the same type.</description><pubDate>Wed, 26 Sep 2018 19:22:00 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>REST API Data Validation</title><link>https://www.kamilgrzybek.com/blog/posts/rest-api-data-validation/</link><guid>https://www.kamilgrzybek.com/blog/posts/rest-api-data-validation/</guid><description>This time I would like to describe how we can protect our REST API applications from requests containing invalid data (data validation process). However, validation of our requests is not enough, unfortunately. In addition to validation, it is our responsibility to return the relevant messages and statuses to our API clients. I wanted to deal with these two things in this post.</description><pubDate>Wed, 20 Feb 2019 22:48:00 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Simple CQRS implementation with raw SQL and DDD</title><link>https://www.kamilgrzybek.com/blog/posts/simple-cqrs-implementation-raw-sql-ddd/</link><guid>https://www.kamilgrzybek.com/blog/posts/simple-cqrs-implementation-raw-sql-ddd/</guid><description>In this post I wanted to show you how you can quickly implement simple REST API application with CQRS using the .NET Core.</description><pubDate>Mon, 04 Feb 2019 07:09:00 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Strangling .NET Framework App to .NET Core</title><link>https://www.kamilgrzybek.com/blog/posts/strangling-net-framework-app-to-net-core/</link><guid>https://www.kamilgrzybek.com/blog/posts/strangling-net-framework-app-to-net-core/</guid><description>Each technology becomes obsolete after some time. It is no different with the .NET Framework - it can be safely said that after the appearance of the .NET Core platform, the old Framework is slowly disappearing. Few people write about this platform, at conferences it has not been heard for a long time in this topic. Nobody starts a project in this technology. Only the .NET Core everywhere... except for a beloved legacy systems.</description><pubDate>Tue, 07 Apr 2020 05:22:26 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>The Outbox Pattern</title><link>https://www.kamilgrzybek.com/blog/posts/the-outbox-pattern/</link><guid>https://www.kamilgrzybek.com/blog/posts/the-outbox-pattern/</guid><description>Sometimes, when processing a business operation, you need to communicate with an external component in the Fire-and-forget mode. The question that arises is whether we are able to guarantee the atomicity of our business operation from a technical point of view?</description><pubDate>Mon, 11 Mar 2019 20:20:26 GMT</pubDate><author>Kamil Grzybek</author></item><item><title>Using Database Project and DbUp for database management</title><link>https://www.kamilgrzybek.com/blog/posts/using-database-project-dbup-management/</link><guid>https://www.kamilgrzybek.com/blog/posts/using-database-project-dbup-management/</guid><description>In previous post I described two popular ways to manage database changes - state versioning where you keep whole current design of your database and versioning of transitions to desired state. In this post I wanted to show implementation of these two approaches in .NET environment combined together – what I think is the best way to manage database changes.</description><pubDate>Mon, 26 Nov 2018 20:23:00 GMT</pubDate><author>Kamil Grzybek</author></item></channel></rss>