Software developers spend most of their time reading code, not writing it. Due to this fact, the code should read like a book so that it can be easily understood not only by compilers but also by other developers.

I will not share with you the standard and well-known naming conventions here. I’ve put together some common intrusive naming violations that static code analyzers usually don’t report and how to fix them.

Weasel Words in Names

Programmers often use weasel words like “Temp”, “Dto”, “Info”, “Item”, “Base”, etc., which do not add any value to the names.

Usually, it is enough to simply remove…

Good developers constantly learn from the various sources available: open-source projects, books, video courses, conferences.

Another important source of knowledge is good blogs, where mature developers, technical leaders, or architects share their experience and are ready to answer your questions.

I have collected the 5 best blogs from my personal list, which I have followed for many years and which I really like because they have a big positive impact on my career.

1. Enterprise Craftsmanship

The author of the blog writes in-depth articles, mainly on domain-driven design, unit testing and CQRS.

Some good articles:

• In Defense of Lazy Loading
• Verifying collaborations at…

Abstracting the application logic from DateTime.Now property is a common task for developers to enable unit testing.

When DateTime is hard-coded into logic, unit tests will not be reliable.

In the following example, a unit test can only pass if it is executed on a very fast machine:

DateTime.Now instance used in application logic will often have a different number of milliseconds / ticks than DateTime.Now used in test case assertion.

There are at least 5 ways to solve the DateTime.Now problem in unit tests and make them run predictably.

1. IDateTimeProvider Interface

One of the most common approaches is to introduce…

Objects can instantiate other objects directly by calling the new keyword, but this approach is often not the best choice.

Instantiating the object is a separate responsibility that should be carried over from the client code to separate classes/methods called factories.

What do software developers need to deliver quality work fast? In addition to fundamental knowledge in computer science, extensive experience, critical thinking, developers should use libraries available on the market so as not to reinvent the wheel and complete tasks or troubleshoot issues much faster.

The NuGet Gallery provides thousands of libraries, and some of them are real diamonds that can be hard to find.

NodaTime

NodaTime library was created by John Skeet to address the various problems related to date and time, time duration, time zones, calendar systems, and more that the built-in .NET types (DateTime, DateTimeOffset and others) have.

…

Good unit tests help software developers catch regression issues that might accidentally arise during refactoring, bug fixing, or integrating new features into an existing codebase.

There are many best practices for creating a useful unit test suite, and we’re going to take a look at several important ones.

Unit Tests Comply with the F.I.R.S.T.

The execution time for the entire suite should be Fast and take seconds, not minutes. Slow tests will increase the time developers need to refactor the logic, as they often run the entire test suite to ensure that there are no new regression issues. …

The purpose of the strategy design pattern boils down to replacing parts of some generic algorithm at runtime.

Real-life Scenarios for Using the Strategy Pattern

• The data can be converted to CSV, HTML, JSON formats. In the future, there can be a need to also add a support for Markdown format. In this scenario, the code can be abstracted from how the data is transformed using a strategy pattern to make it easier to extend the application.
• Some application services might need to switch between different data storage: database, file system, message bus, another service (by making an HTTP call). …

Web applications are made up of several interconnected layers: the client side, the web framework, the ORM, and, at the very bottom, the database.

When an application is running slowly, the performance bottleneck can be hidden at one of several levels:

• The table may be missing an index in the database.
• There may be an N+1 issue in Entity Framework.
• Application logic actively “mutates” immutable data types, which leads to a lot of allocations into the heap.
• The web framework does not compress large responses before sending them to the client.

The database, like any other complex application component, has…