Coder Legion - Recent posts tagged tuesday-coding-tips

Tuesday Coding Tip 28 — (de)serializing JSON string enum in C#

Tue, 27 Oct 2026 09:59:00 +0000

Tuesday coding tips are super short posts about various tidbits mainly from C++, but also from other programming languages I use. You can also follow the #TuesdayCodingTips hashtag on Mastodon and Linkedin.

Last time I covered C# JSON serialization, I only showcased the Newtonsoft.Json library. This time, I will also show the System.Text.Json way.

You might want to (de)serialize enums as strings, rather than numeric values. Since C# does not support enums with an underlying type of string, you need to do some extra work. Namely, you have to annotate each value using the EnumMember annotation and then select the correct converter, once again using annotations.

using System.Runtime.Serialization;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;

public enum Mood
{
    [EnumMember(Value = "happy")]
    Happy,
    [EnumMember(Value = "sad")]
    Sad,
}

public class Object
{
    [JsonProperty("mood")]

    [JsonConverter(typeof(StringEnumConverter))]
    public Mood Mood { get; set; }
}

public static class Program
{
    public static void Main()
    {
        string json = JsonConvert.SerializeObject(new Object
        {
            Mood = Mood.Sad
        });

        Console.WriteLine(json);
        // {"mood":"sad"}
        Console.WriteLine(JsonConvert.DeserializeObject<Object>(json)!.Mood);
        // Sad
    }
}

However, System.Text.Json doesn’t support EnumMember annotations out of the box. It takes the literal name of the property instead. You can play with capitalization using options object, but that’s it. Or you can write your own converter. Or you can just use one of the dozen converters from the Internet that do the hard work for you.

using System.Runtime.Serialization;
using System.Text.Json.Serialization;

public enum Mood
{
    [EnumMember(Value = "happy")]
    Happy,
    [EnumMember(Value = "sad")]
    Sad,
}

public class Object
{
    [JsonPropertyName("mood")]
    // To use EnumMember annotations, install Macross.Json.Extensions nuget
    // and use a different converter
    // [JsonConverter(typeof(JsonStringEnumMemberConverter))]
    [JsonConverter(typeof(JsonStringEnumConverter))]
    public Mood Mood { get; set; }
}

public static class Program
{
    public static void Main()
    {
        Object obj = new()
        {
            Mood = Mood.Sad,
        };

        string json = System.Text.Json.JsonSerializer.Serialize(obj);
        Console.WriteLine(json);
        // {"mood":"Sad"}
        Console.WriteLine(System.Text.Json.JsonSerializer.Deserialize<Object>(json)!.Mood);
        // Sad
    }
}

Tuesday Coding Tip 27 — Aliasing and ‘using’ in C++

Tue, 20 Oct 2026 09:59:00 +0000

Every hello world tutorial starts with the command using namespace std;. This command is dangerous as it allows you to bring all standard symbols into your namespace where they can collide with your own symbols. Depending on the kind of collision, the compiler might not tell you, nor can you be sure which version will be used.

#include <stdexcept>

int min(int a, int b)
{
    std::terminate();
}

#include <cmath>

int main() {
    using namespace std; // dangerous
    // better to import specific names like:
    using std::max;

    return min(10, 20); // which min will be called?
    // ::min would disambiguate to the local function
    // std::min would disambiguate to standard
}

It is better to use the using keyword to selectively bring symbols into the scope or even alias them to be sure they’re unique (note that namespaces alias differently).

#include <filesystem>

// Aliasing namespace works differently
namespace fs = std::filesystem;

// from aliasing classes
using Path = fs::path;

bool fileExists(const Path& path)
{
    return fs::exists(path);
}

The keyword can also be used to expose class template parameters for common usage.

template<class T>
class Foo {
public:
    // Exposing template type saves time
    // to those who need to get to it
    using DataType = T;

    T getItem() const { return T{}; }
};

int main() {
    Foo<int> foo;
    decltype(foo)::DataType item;
    item = foo.getItem();
}

And since C++20, you can bring enum values (selectively or in group) for better ergonomics in enum-based branching.

enum class EmployeeType {
    JuniorDev,
    MediorDev,
    SeniorDev,
    ScrumMaster,
    ProductManager
};

std::string to_string(EmployeeType et) {
    switch (et)
    {
        using enum EmployeeType; // Since C++20
        case JuniorDev: return "junior";
        case MediorDev: return "medior";
        // ...
    }
}

std::string to_string(EmployeeType et) {
    using EmployeeType::JuniorDev;

    if (et == JuniorDev) return "junior";
    // ...
}

Tuesday Coding Tip 26 — JSON (de)serialization in C#

Tue, 13 Oct 2026 09:59:00 +0000

In need of a JSON (de)serializer in C#? One option could be to use the built-in System.Text.Json functionality. Probably the most popular way is to use the Newtonsoft.Json library which has a richer feature set while maintaining overall simplicity.

Things are as simple as having a class with a bunch of public attributes and calling serialize on it. Those attributes don’t even have to be trivial types — anything from DateTime to HashSet can be easily handled.

Deserialization is similarly easy — if a key is present, it will be deserialized. If not, the default value for the attribute will be picked instead.

using Newtonsoft.Json;

namespace NetSandbox;

public class ExtendedValues
{
    public long ErrorCode { get; set; }

    public string Message { get; set; } = string.Empty;
};

public class Property
{
    public string Value { get; set; } = "";
};

public class Protocol
{
    public long Version { get; set; } = -1;

    [JsonProperty("extended", NullValueHandling = NullValueHandling.Ignore)]
    public ExtendedValues? ExtendedValues { get; set; } = default;


    [JsonProperty("machineGuid")]
    public Guid MachineGuid { get; set; }

    public List<Property> Properties { get; set; } = new List<Property>();
};

public static class Program
{
    public static void Main()
    {
        Protocol schema = new()
        {
            Version = 1,
            MachineGuid = Guid.NewGuid(),
            Properties = new List<Property> {
                new Property {
                    Value = "hello"
                },
                new Property {
                    Value = "world"
                }
            }
        };

        var json = JsonConvert.SerializeObject(schema);
        // {"Version":1,"machineGuid":"156717fd-0904-47af-bcb8-ad74d23b9cc7","Properties":[{"Value":"hello"},{"Value":"world"}]}

        var obj = JsonConvert.DeserializeObject<Protocol>(
            """{"machineGuid": "156717fd-0904-47af-bcb8-ad74d23b9cc7"}""");
        // obj.Version contains -1
        // obj.MachineGuid containts "156717fd-0904-47af-bcb8-ad74d23b9cc7"
        // obj.ExtendedValues is null
        // obj.Properties is empty list
    }
}

If you need to, you can use annotations to for example customize the name of the serialized property or whether it will be serialized when it is null.

Extra thought: I originally wrote this post in late 2023. Since then, many people would probably advice you System.Text.Json on the merit of being faster and getting more and more on-part with Newtonsoft on each major release. Since we did a switch to it some time ago, I cannot wholeheartedly recommend it - it is great for simple use cases, but once you have some data structure that evolved over time and you need to be lenient of what you accept over wire and strict in what you send, working with System.Text.Json is a bigger pain, especially around NullValueHandling and DefaultValueHandling.

Tuesday Coding Tip 25 — User-defined literals

Tue, 06 Oct 2026 09:59:00 +0000

C++ has many built-in literals for disambiguating types of constants, such as u for unsigned, f for float, or time-related literals from the chrono header (like ms, h, or min).

The really cool thing is that you can define your own literals (since C++11) to make your domain-specific constants more legible. All these literals overload the operator“” with your custom _suffix. The data type that is supposed to be before _suffix is then determined by the function parameter type (consult the documentation for allowed parameter types: https://en.cppreference.com/w/cpp/language/user_literal ).

Thanks to compile-time computing, these literals don’t have to imply any runtime overhead for your code.

// Language-provided literals
const auto foo = 100u; // implies unsigned int
const auto bar = 10.f; // implies float instead of double

// Library-provided literals
#include <chrono>
using namespace std::literals;

const auto baz = "hello"s; // implies std::string instead of const char*
constexpr auto day = 14d; // If the value > 255, then the stored value is unspecified. 
constexpr auto twoDays = 48h;
constexpr auto week = 24h* 7;
constexpr auto my_duration_unit = 108ms;
constexpr auto theYear = 2021y;

An interesting use-case that I found is that literals can be leveraged to make described bool constants without having to wrap them in a temporary.

// Literal that describes a constant in pixel units
[[nodiscard]] consteval unsigned long long operator""_px(unsigned long long value) {
    return value;
}

const auto SCREEN_WIDTH = 1280_px;

#include <cstddef>

[[nodiscard]] consteval bool operator""_false(const char*, std::size_t) {
    return false;
}

[[nodiscard]] consteval bool operator""_true(const char*, std::size_t) {
    return true;
}

foo("isWindowOpen"_true, "isFullscreen"_false);

Tuesday Coding Tip 24 — Getting template type from an existing object

Tue, 29 Sep 2026 09:59:00 +0000

Nice APIs expose their template types as member aliases so that anybody can get them easily. For other types, you might be able to deduce the type by calling decltype on a return value of some of their functions.

Sometimes, none of that is possible. But there is still a way to get to it. You need to write a template structure that only matches on the type you care about and alias the template parameters so you can access them later, a technique known as ‘type trait’.

#include <vector>

// Base template, only for the compiler
template<class T>
struct UnderlyingVectorType {};

// Overload for vector, note that templates don't have to match
template<class T, class A>
struct UnderlyingVectorType<std::vector<T, A>> {
    using StorageType = T;
    using AllocatorType = A;
};

// Nice types already expose their template types
template<class T>
class NiceType {
public:
    using StorageType = T;
};

int main() {
    int a;
    
    // error: no type named 'type' in 'UnderlyingVectorType<int>'
    // because it resolves to the base template
    // UnderlyingVectorType<decltype(a)>::storageType b;

    std::vector<float> vec;
    using VecStorageType = UnderlyingVectorType<decltype(vec)>::StorageType;
    VecStorageType vec2;
    static_assert(std::is_same_v<VecStorageType, float>);

    NiceType<double> nice;
    decltype(nice)::StorageType myDouble = 0.0;
    static_assert(std::is_same_v<decltype(nice)::StorageType, double>);
}

Tuesday Coding Tip 23 — CMake configure_file

Tue, 22 Sep 2026 09:59:00 +0000

In unit tests, I often don’t want to bother with the working folder of the test binary. But if those tests need physical files from the disc, I need to know their absolute paths (which are different on each machine). Luckily, CMake has a function configure_file that can write CMake variables to a file template.

cmake_minimum_required ( VERSION 3.10 )

set ( USE_MSVC_FEATURES ("${CMAKE_GENERATOR}" MATCHES "Visual Studio 17 2022") )

project ( DEMO CXX )

# CMakeLists.txt
configure_file(
    "${CMAKE_SOURCE_DIR}/TemplateHeader.hpp.in" # input
    "${CMAKE_SOURCE_DIR}/FinalHeader.hpp" # output
)

For example, I can prepare a template for a header that will hold an absolute path to a folder with helper files, and during configuration, I can produce a valid C++ header with the path filled out. CMake will replace variables escaped as @VAR@, ${VAR}, $CACHE{VAR} or $ENV{VAR} and furthermore it can do things like generating #define directives.

// TemplateHeader.hpp.in
#pragma once

#include <filesystem>

#cmakedefine01 USE_MSVC_FEATURES

const std::filesystem::path TESTDATA_FOLDER = "@CMAKE_CURRENT_SOURCE_DIR@/TestFiles";

// Generated FinalHeader.hpp
#pragma once

#include <filesystem>

#define USE_MSVC_FEATURES 1

const std::filesystem::path TESTDATA_FOLDER = "C:/Work/Project/TestFiles";

Full documentation: https://cmake.org/cmake/help/latest/command/configure_file.html

Tuesday Coding Tip 22 — Compile-time computing

Tue, 15 Sep 2026 09:59:00 +0000

As you might know, templates in C++ are turing-complete and you can use them for compile-time computing. But they are unwieldy. So the constexpr/consteval keywords were created, so you can write a normal code and mark it as viable for compile-time execution. consteval means that the function has to be executed during compilation (and then optimized away) while constexpr gives the compiler the opportunity to do so.

#include <array>

template<unsigned limit>
consteval auto ComputeFibonacciLookup()
{
    std::array<int, limit> result = { 0 };

    unsigned n_1 = 0;
    unsigned n_2 = 1;
    for (unsigned i = 0; i < limit; i++)
    {
        result[i] = (n_1 + n_2);
        n_2 = n_1;
        n_1 = result.at(i);
    }

    return result;
}

constexpr const auto FIB_LOOKUP_TABLE = ComputeFibonacciLookup<10>();
static_assert(FIB_LOOKUP_TABLE.size() == 10u);
static_assert(FIB_LOOKUP_TABLE[0] == 1);
static_assert(FIB_LOOKUP_TABLE[1] == 1);
static_assert(FIB_LOOKUP_TABLE[2] == 2);
static_assert(FIB_LOOKUP_TABLE[3] == 3);
static_assert(FIB_LOOKUP_TABLE[4] == 5);

Why is this useful? For example, you can generate a lookup table to optimize runtime speed while maintaining the table itself via an algorithm, not hard-coded values. Or you can write compile-time unit tests for your code. These are handy the compilation will error out if you have any undefined behavior in your code (that does not happen for regular compilation).

constexpr bool divide(int a, int b)
{
    return (a / b) != 0;
}

// Static assert guaratees compile-time execution
static_assert(divide(10, 5)); // ok

// compilation error, division by zero is UB
// error: static assertion expression is not an integral constant expression
static_assert(divide(10, 0));

Extra thought: This tip was originally written three years ago. Since then, many more constexpr variants of standard containers and language constructs were added to the language. Meaning you can do more advanced stuff in the compile time. With C++26, you can even allocate memory and throw exceptions. The compiler will also check that you properly deallocate memory, which is very clever.

Edit 15.9.2026: Fixed the first code example as per Mike Dabydeen comment. Kudos for the correction!

Tuesday Coding Tip 21 — Dangers of Enums

Tue, 08 Sep 2026 09:59:00 +0000

C++ and C# have a caveat in their enum types. Each enum has an underlying storage type which limits a maximum number of values and how much space it takes in memory. However, it also works the other way — it says how many distinct values the enum handles.

If you define an enum with just three values, if it has an underlying type of uint8, it handles 256 distinct values. You can take any integer up to 255, cast it to that enum type, and get a “valid” value. When branching on an enum, you need to keep in mind that you might get an undefined value, especially if it was deserialized from the wire.

To add insult to injury, compilers won’t warn you by default. Only pattern matching does for C#. C++ can warn you if you don’t cover a defined enum value in a switch statement, but you must not use the default case — preventing you from correctly handling ill-formed values.

#include <iostream>

enum class Mode : char {
    Primary,
    Secondary
};

std::string to_string(Mode mode)
{   
    switch (mode)
    {
        case Mode::Primary: return "Primary";
        // With -Wswitch-enum
        // warning: enumeration value 'Secondary' not handled in switch
    }
}

std::string to_string2(Mode mode)
{
    switch (mode)
    {
        case Mode::Primary: return "Primary";
        // With -Wswitch-enum
        // no other warning
        default: return "Undefined";
    }
}

std::string to_string3(Mode mode)
{
    switch (mode)
    {
        case Mode::Primary: return "Primary";
        case Mode::Secondary: return "Secondary";
        // With -Wswitch-enum
        // no other warning
    }
}

int main()
{
    auto&& str = to_string3(static_cast<Mode>(42));
    std::cout << str << std::endl; // Output is an undefined behaviour
    return 0;
}

Tuesday Coding Tip 20 — Be `explicit`!

Tue, 21 Jul 2026 09:59:00 +0000

If you choose to add a conversion operator for your class in C++, be sure to mark it as explicit or you can get nasty side-effects that will be hard to debug. For example, having an implicit conversion operator to bool will make the operator less-than “work” for your class, meaning that class can be used as a key for std::map and suddenly, all hell breaks loose.

#include <iostream>
#include <vector>

class A {
public:
    operator bool() {
        return true;
    }
};

class B {
public:
    explicit operator bool() {
        return true;
    }
};

int main() {
    // This is ok
    std::cout << (A() < A()) << std::endl;
    A a;
    if (a); // implicit conversion allowed

    // Error: error: invalid operands to binary expression
    std::cout << (B() < B()) << std::endl;
    B b;
    if (bool(b)); // explicit conversion required

    return 0;
}

Similarly, it is good practice to mark single parameter constructors explicit to prevent implicit conversions from trivial data types or to possibly track places where your object is copied.

class A {
public:
    A(int) {}
    A(const A&) {}
};

class B {
public:
    explicit B(int) {}
    explicit B(const B&) {}
};

int main() {
    A a1 = 10; // ok
    A a2 = { 10 }; // ok
    A a3 = a1; // ok

    B b1 = 10; // error: no viable conversion, explicit constructor is not a candidate
    B b2 = { 10 }; // error
    B b3 = B{10}; // ok
    B b4 = b1; // error
    B b5 = B{b1}; // ok

    return 0;
}

Tuesday Coding Tip 19 — [[nodiscard]] annotation

Tue, 14 Jul 2026 09:59:00 +0000

Since C++17, one can use [[nodiscard]] annotation to mark API functions whose return values should not be discarded without consideration. This usually applies to methods that make no sense to call without evaluating their return value (like predicate functions such as empty or a factory function). The compiler will issue a warning if the return value is not handled.

class [[nodiscard]] A {};

// OR

class B {
public:
    [[nodiscard]] B() = default;
};

// Enums can be nodiscard too
enum class [[nodiscard]] State {
    Default,
    Foo,
    Bar
};

int main()
{
    // warning: ignoring temporary created by a constructor declared with 'nodiscard' attribute
    A();
    B();
}

But beware! Sometimes it might be tempting to return some scope guard that will maintain postconditions automatically at the end of the scope using RAII (such as committing transactions). However, a user of your API can pipe the result of your nodiscard function into a std::ignore helper which causes the temporary to destruct immediately, defeating the idea of end-of-scope cleanup.

#include <tuple> // std::ignore

class [[nodiscard]] A {};
class B {
public:
    [[nodiscard]] bool isOk() const { return true; }
};

// no need for nodiscard, A is nodiscard
A foo() {
    return A();
}

// B is not nodiscard, mark it explicitly
[[nodiscard]] B bar() {
    return B();
}

int main()
{    
    foo(); // warning: ignoring temporary created by a constructor declared with 'nodiscard' attribute
    bar(); // warning

    std::ignore = foo(); // ok
    auto b = bar(); // ok
    b.isOk(); // warning
    if (b.isOk()) {} // ok
}

Tuesday Coding Tip 18 — Generating random numbers in C++

Tue, 07 Jul 2026 09:59:00 +0000

Classic C way of generating random numbers is to set the current time as a seed and then modulo results of the rand function to get somewhat random numbers (modulo can introduce bias based on the implementation of rand).

#include <iostream>
#include <random>

// Get random integer in range <min, max)
int getRandomNumber(int min, int max)
{
    return rand() % (max - min) + min;
}

int main()
{
    // seeding with current time to get different output each time
    srand(time(NULL));

    for (int i = 0; i < 10; i++)
        std::cout << getRandomNumber(10, 20) << std::endl;
}

C++11 introduces the concept of engines, adaptors, and distributions. Engines are seedable and give you random numbers similar to rand() calls. However, each engine is implemented differently, impacting its speed and memory footprint. Adapters tamper with RNG output, such as shuffling the order of output values or discarding them.

Distributions transform the output from the generators to get values in certain ranges and probabilistic properties, such as the middle value being the most probable (normal distribution). Distributions are more nuanced than just using the modulo operator so their outputs are more suitable for cryptography use-cases.

#include <iostream>
#include <random>

// Get random integer in range <min, max)
int getRandomNumber(int min, int max)
{
    return rand() % (max - min) + min;
}

int main()
{
    std::random_device rd; // non-seedable source of non-deterministic numbers from hardware
    std::mt19937 generator(rd()); // deterministic generator with uniform distribution
                                  // seeded with totally random number

    std::uniform_int_distribution<> distribution(10, 19);

    for (int i = 0; i < 10; i++)
        std::cout << distribution(generator) << std::endl;
}

Tuesday Coding Tip 17 — Wrapping C APIs

Tue, 30 Jun 2026 09:59:00 +0000

Resource Acquisition is Initialization (RAII) is an awfully named principle saying that your class should be fully usable after construction and should clean itself up in the destructor (in other words, no (de)init methods). This principle is common in modern programming languages and is also adopted in modern C++ codebases.

But what if you work with C-like API like fopen? It returns a pointer you need to manually free before it goes out of scope. Otherwise, you leak memory and open file handles. This is where smart pointers come to the rescue as you can wrap raw pointers with them and give them custom callbacks to execute when they leave the scope.

#include <cstdlib>
#include <iostream>
#include <memory>

// MSVC disallows calling fopen
#pragma warning(disable : 4996)

void CloseFile(FILE* f)
{
    std::cout << "Closing file" << std::endl;
    fclose(f);
}

auto SafeFopen(const char* path, const char* mode)
{
    return std::unique_ptr<FILE, decltype(&CloseFile)>(
        fopen(path, mode), CloseFile);
}

int main()
{
    auto&& fp = SafeFopen("myfile.txt", "w");
    return 0;
    // Outputs: Closing file
}

Tuesday Coding Tip 16 — Creating objects in existing memory

Tue, 16 Jun 2026 09:59:00 +0000

C++ allows you to scrap your OS’ memory allocators, get yourself a huge chunk of memory and write your own allocators (they can be used with the standard library). It’s a hardcore optimization, but here’s a related tip that might be handy in normal projects as well.

When using the operator new, one can provide it with an already allocated memory, so it runs a constructor for a particular type in there. After that, reinterpret that memory as a pointer to your desired object and use it normally. However, deletion is a bit more complicated, as you have to call the destructor on that object manually (because delete must be called on the original memory, not the object).

// using some template type T
auto&& buffer = static_cast<std::byte*>(::operator new(sizeof(T)));
if (!buffer) throw std::bad_alloc();

new (buffer) T();
auto&& object = reinterpret_cast<T*>(buffer);

// ...

object->~T(); // call destructor
delete[] buffer; // properly release memory

I used this trick when implementing a resource manager that needs to hold any user data type (that is still default-constructible in my case): link

Tuesday Coding Tip 15 — Mathematical constants in C++

Tue, 09 Jun 2026 09:59:00 +0000

Since C++20, you can include header <numbers> and use many commonly used, precomputed mathematical constants like Pi, Phi, square root of 2 and 3, natural logarithms of 2 and 10, and many more! Even better, you can choose their precision by specifying the underlying type via a template.

And since C++17, the <cmath> header contains some special math functions I’ve never heard of like cylindrical Bessel functions, associated Legendre polynomials, or Riemann zeta function.

#include <iostream>
#include <numbers>
#include <iomanip> // std::setprecision
#include <limits> // std::numeric_limits

template<typename T>
void printConstant(T value)
{
    const auto default_precision{std::cout.precision()};

    std::cout << std::setprecision(std::numeric_limits<T>::digits10 + 1);
    std::cout << value << std::endl;

    std::cout << std::setprecision(default_precision);
}

int main()
{
    using namespace std::numbers;
    printConstant(pi_v<float>);
    printConstant(pi_v<double>);
    printConstant(pi_v<long double>);

    /* Outputs:
    3.141593
    3.141592653589793
    3.141592653589793239
    */
}

Constants are documented here: https://en.cppreference.com/w/cpp/numeric/constants
Special functions are documented here: https://en.cppreference.com/w/cpp/numeric/special_functions

Tuesday Coding Tip 14 — Pattern matching in C#

Tue, 02 Jun 2026 09:59:00 +0000

Since C# 7, you can use pattern matching to write simple and safer code. First, it allows you to return a value from a switch expression, saving you the hassle of creating a temporary on a separate line.

public enum State {
    None, Foo, Bar
}

public void PrintState(State state)
{
    // Original switch
    switch (state)
    {
        case State.Foo:
            Console.WriteLine("Foo"); break;
        case State.Bar:
            Console.WriteLine("Bar"); break;
        default:
            Console.WriteLine("None"); break;
    }

    // Rewritten switch
    Console.WriteLine(state switch {
        State.Foo => "Foo",
        State.Bar => "Bar",
        _ => "None"
    });
}

Second, it can match not only on discrete values but expressions as well and the compiler can warn you if some expression is redundant (relational patterns).

public static string SubjectiveTemp(int degrees)
{
    // Relation patterns were added in C# 9
    return degrees switch
    {
        -273 => "Absolute zero",
        >-273 and <-10 => "Freezing cold",
        >-10 and <10 => "Cold",
        >10 and <25 => "Livable",
        _ => "HOT!"
    };
}

Third, it can match on more than one value through records, lists, etc. As a cherry on top, pattern matching also encapsulates type and null matching.

public static void CustomPrint<T>(T? value)
{
    if (value is int)
        Console.WriteLine($"int: {value}");
    else if (value is string)
        Console.WriteLine($"string: {value}");
    else if (value is null)
        Console.WriteLine($"null");
    else
        Console.WriteLine("unknown");
}

Note that when pattern matching, the _ symbol is the discard pattern, matching everything that reaches it. Also, switches do not by default warn the user if they forget a branch (usually with enums). Pattern matching does detect and warns on such occasions.

More on pattern matching: https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/functional/pattern-matching

Tuesday Coding Tip 13 — Deleting problematic overloads

Tue, 26 May 2026 09:59:00 +0000

Suppose you have a C++ function for opening a file stream that accepts a path to a file and a string (view) with open-mode specifications (like fopen). The issue is, even though your API is strongly typed, users can still swap the arguments by accident and don’t get a compile time error, due to implicit conversions from string-like constants.

Luckily, there is an easy hack with which you can disable implicit conversions for one particular function by explicitly deleting all overloads (via auto template) and allowing just one particular version. The coolest thing is that even the return value doesn’t have to match!

#include <filesystem>

using path = std::filesystem::path;

void fopen2(const auto&, const auto&) = delete;

FILE* fopen2(const path& fp, const std::string& mode)
{
    /* dummy implementation */
    return nullptr;
}

int main()
{
    // error: call to deleted function 'fopen2'
    // note: candidate function [with auto:1 = char[11], auto:2 = char[2]] has been explicitly deleted
    fopen2("myfile.txt", "r");

    // This is ok
    fopen2(path { "myfile.txt" }, std::string { "r" });
    return 0;
}

Tuesday Coding Tip 12 — Stack trace

Tue, 19 May 2026 09:59:00 +0000

C++23 brings a new feature that I always wanted since I’ve seen it in C# — stack trace.

When combined with exceptions, it can immensely help with the analysis of user error reports, when you cannot simply attach a debugger. The code snippet shows how to create an exception class that can automatically capture stack trace at the point where it was constructed.

#include <iostream>
#include <stacktrace>
#include <stdexcept>

class stacktrace_error : public std::runtime_error
{
public:
    stacktrace_error(std::stacktrace trace = std::stacktrace::current())
        : std::runtime_error(std::to_string(trace))
    {}
};

void bar() { throw stacktrace_error(); }
void foo() { bar(); }

int main()
{
    try
    {
        foo();
    }
    catch (std::exception& e)
    {
        std::cerr << e.what() << std::endl;
        /* OUTPUTS:
        0> C:\...\Main.cpp(19): Sandbox!bar+0x44
        1> C:\...\Main.cpp(25): Sandbox!foo+0x20
        2> C:\...\Main.cpp(31): Sandbox!main+0x32
        3> D:\a\_work\1\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl(79): Sandbox!invoke_main+0x39
        4> D:\a\_work\1\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl(288): Sandbox!__scrt_common_main_seh+0x12E
        5> D:\a\_work\1\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl(331): Sandbox!__scrt_common_main+0xE
        6> D:\a\_work\1\s\src\vctools\crt\vcstartup\src\startup\exe_main.cpp(17): Sandbox!mainCRTStartup+0xE
        7> KERNEL32!BaseThreadInitThunk+0x14
        8> ntdll!RtlUserThreadStart+0x21
        */
    }
}

The API even allows you to iterate over each stack entry, but honestly — who needs that?

Note: Linux versions of GCC and Clang have this stupid idea of requiring you to manually link stacktrace (akin to math library), because -std=c++23 is apparently not enough of a feature flag. So don't forget to use -lstdc++_libbacktrace argument for compilation.

Tuesday Coding Tip 11 — null-coalescing operator

Tue, 12 May 2026 09:59:00 +0000

Some languages, like C# or Javascript, have a special operator ?? which is a specialization over the normal ternary operator. It either returns the value of the left operand or, if it is null, it returns the value of the right operand.

Furthermore, the ??= operator allows you to only assign to a variable if it is null. Syntax among languages might differ, so check out this overview: https://en.wikipedia.org/wiki/Null_coalescing_operator

var a = null;

// Initialize b with a, or with 42 if a is null
var b;
if (a == null) b = 42;
else b = a;

// Shorter version with ?? operator
var c = a ?? 42;

// Update a with something if it is null
a ??= 24;

What’s Your Worst Production Incident So Far? (And What It Teaches You as a Developer)

Tue, 05 May 2026 22:23:59 +0000

The Problem → “It Worked Locally… Until Production Broke Everything”

Every developer has that moment.

You deploy with confidence.
Tests pass. Code looks clean. Everything seems fine.

Then production happens.

Suddenly:

Users can’t log in
Payments fail
APIs start timing out
Your phone won’t stop buzzing

And you’re sitting there thinking:

“How did this even happen?”

If you’ve never experienced a production incident, you’re either new… or it’s coming.

The Solution → Learn From Incidents, Don’t Just Survive Them

Production incidents are painful.

But they’re also one of the fastest ways to grow as a developer.

Not because they break your system
But because they expose how you think, design, and prepare.

My Worst Production Incident (And Why I’ll Never Forget It)

Let me be real.

One of my worst incidents came from something that looked harmless.

A simple update.

Nothing complex.

Just a small change to improve performance.

What Happened

We deployed a backend update (Laravel API).

Shortly after:

Requests started slowing down
Some endpoints began failing
Database CPU usage spiked

At first glance, nothing obvious stood out.

Monitoring showed increased load but no clear root cause.

Caution: The most dangerous production issues are the ones that don’t fail immediately they degrade your system gradually.

The Root Cause

After digging deeper, we found it:

A query that worked fine in development
But under production traffic?

It became a bottleneck.

Missing index
Repeated calls
No caching

One small oversight… multiplied by thousands of requests.

What Made It Worse

It wasn’t just the bug.

It was everything around it:

No proper caching strategy
Limited visibility into queries
Logs weren’t detailed enough
No tracing to follow requests

So debugging took longer than it should have.

Note: Production issues are rarely caused by one mistake they are usually a combination of small gaps.

The Real Lessons That Changed How I Build Systems

That incident forced a shift in how I approach development.

1. “Works Locally” Means Nothing at Scale

Local environments lie.

They don’t simulate:

Real traffic
Concurrency
Data volume

Now, I always ask:

“What happens when this runs 1,000 times per minute?”

2. Observability Is Not Optional

After that incident, I stopped treating logging and monitoring as “extras.”

Now I ensure:

Structured logs
Query tracking
Request tracing

Because when something breaks, you need answers fast.

3. Caching Is Not Just an Optimization

Before, caching felt like a “nice to have.”

Now?

It’s part of system design.

Reduce repeated queries
Improve performance
Protect your database

Tip: If your system depends on repeated data access, caching should be part of your first design not an afterthought.

4. Small Changes Can Have Big Impact

The change that caused the issue?

It looked insignificant.

But in production, scale amplifies everything.

Now I treat every change like it can break something.

Because it can.

5. Incidents Are Feedback, Not Failure

At the time, it felt like failure.

Now I see it differently.

That incident improved:

My debugging skills
My system design thinking
My awareness of edge cases

How I Handle Production Risks Now

Here’s what I do differently today:

Before Deployment:

Review code with edge cases in mind
Test with realistic data
Think about performance impact

During Development:

Add logs intentionally
Structure responses clearly
Avoid unnecessary queries

After Deployment:

Monitor closely
Watch metrics and logs
Be ready to respond fast

The Question Every Developer Should Ask

Instead of avoiding incidents, ask:

“Am I prepared when it happens?”

Because it will.

And when it does, your preparation matters more than your code.

FAQ What causes most production incidents?
Common causes include untested edge cases, performance issues, missing caching, and poor observability.

How can developers reduce production failures?
By improving testing, adding proper logging, using caching, and monitoring system behavior in real time.

Is it normal to have production incidents?
Yes. Every developer and team experiences them. What matters is how you learn and improve from them.

Final Thoughts

Every developer has a “worst production incident.”

It’s not a matter of if it’s when.

But here’s the difference:

Some developers panic…
Others learn, adapt, and become better.

The real goal is not to avoid mistakes completely.

It’s to:

Detect them faster
Understand them better
Fix them smarter

Call to Action

Now I’ll ask you:

What’s your worst production incident so far?

Share it with your team
Talk about it
Learn from it

Because sometimes: The best lessons don’t come from success they come from things breaking at the worst possible time.

Tuesday Coding Tip 10— CTest

Tue, 05 May 2026 09:59:00 +0000

CMake can do many things and instrumenting your test suite is one of them. Use add_test to tell cmake it should run a particular command with given parameters. If it returns zero, it succeeded. You can use it to simply run a testrunner binary or to make a matrix of input parameters that are expected to not crash the program.

cmake_minimum_required ( VERSION 3.26 )

project ( testrunner )
add_executable ( ${PROJECT_NAME} Main.cpp )

enable_testing()
add_test(
   NAME "Example with no params"
   COMMAND ${PROJECT_NAME}
)

add_test(
   NAME "Example with help param"
   COMMAND ${PROJECT_NAME} -h
)

In order to add_test do anything, one has to also call enable_testing(). Running the tests is just a matter of running ctest from command line. Just note that ctest requires you to specify a build configuration if you have more than one.

Tuesday Coding Tip 09 — Source location

Tue, 28 Apr 2026 09:59:00 +0000

If you want to log a filename and line number prior to C++20, you need to use the likes of __FILE__ and __LINE__ macros. To use those easily, you have to create a wrapper macro for logging, which usually leads to an ugly macro bonanza.

#include <iostream>
#include <format>

void log(
    const std::string& message,
    const std::string& fileName = __FILE__,
    unsigned lineNo = __LINE__)
{
    std::cout << std::format(
        "{}({}): {}\n",
        fileName,
        lineNo,
        message);
}

#define LOG(msg) log(msg, __FILE__, __LINE__)

int main()
{
    log("hello world");
    // logs: example.cpp(7): hello world
    // Note that __FILE__ and __LINE__ are expanded at their
    // position, not at the callsite
    LOG("hello world2");
    // logs: example.cpp(22): hello world2
    // Wrapping the call in another macro with explicit placement
    // of __FILE__ and __LINE__ makes them expand at the correct place
}

C++20 introduces std::source_location, a regular object that can be constructed as a default value of a logging function parameter and passed along as the user needs.

#include <iostream>
#include <source_location>
#include <format>

void log(
    const std::string& message,
    std::source_location location = std::source_location::current())
{
    std::cout << std::format(
        "{}({}) {}: {}\n",
        location.file_name(),
        location.line(),
        location.function_name(),
        message);
}

int main()
{
    log("hello world");
    // logs: example.cpp(19) int main(): hello world
}

Tuesday Coding Tip 08 — Explicit template specialization

Tue, 21 Apr 2026 09:59:00 +0000

While template instantiation can be used to move your template implementation from header files to object files for a given subset of types, specialization allows you to override the default template implementation for a particular type.

Specialization requires that you first define the template implementation and then you can implement any number of specializations for given types. This way, you can override free functions (while maintaining their overall signature) or you can override whole classes (and you don’t have to respect their interfaces). This way, you can create drop-in replacements for library containers specialized for particular types and try to optimize them for your use case.

#include <filesystem>
#include <iostream>
#include <string>

template<class T>
T concat(T a, const T& b)
{
    return a + b;
}

namespace fs = std::filesystem;

fs::path concat(fs::path a, const fs::path& b)
{
    return a / b;
}

int main()
{
    using namespace std::string_literals;
    std::cout << concat("aaa"s, "bbb"s) << std::endl;        // outputs: aaabbb
    std::cout << concat("aaa", "bbb").string() << std::endl; // outputs: aaa\bbb
    return 0;
}

The specialization can also be partial and it can be inline/const whatever even if the original template is not.

#include <iostream>
#include <string>

template<class T>
struct CustomType
{
    T foo() { return T {}; }
};

template<>
struct CustomType<std::string>
{
    std::string bar() { return "hello world"; }
};

int main()
{
    CustomType<int> ct1;
    std::cout << ct1.foo() << std::endl; // outputs: 0
    CustomType<std::string> ct2;
    std::cout << ct2.bar() << std::endl; // outputs: "hello world"
}

Last but not least, if you’re implementing a template and need to change only a few lines of implementation for one particular type, you don’t need specialization. Instead, use constexpr conditions — they are evaluated in compile time and optimized away when the compiler emits its own specialized code.

#include <concepts>
#include <filesystem>
#include <iostream>
#include <string>

template<class T>
T concat(T a, const T& b)
{
    if constexpr (std::is_same_v<T, std::filesystem::path>)
        return a / b;
    else
        return a + b;
}

int main()
{
    using namespace std::string_literals;
    using path = std::filesystem::path;
    std::cout << concat("aaa"s, "bbb"s) << std::endl; // outputs: aaabbb
    std::cout << concat(path{ "aaa" }, path{ "bbb" }).string()
              << std::endl; // outputs: aaa\bbb
    return 0;
}

Tuesday Coding Tip 07 — Exposing internal bits of .NET projects

Tue, 14 Apr 2026 11:49:31 +0000

C# has a number of visibility keywords and their combinations. A peculiar one is ‘internal’ which restricts the visibility of the symbols to the current assembly. However, that can be tweaked.

You can manually specify the names of assemblies to which the ‘internal’ bits will be visible. Why is this useful? Because you can expose otherwise private parts of your code to assemblies like unit tests and test code with ease. No more ‘friend’ shenanigans like in C++ unit tests!

Ways how to configure this evolved over the years and the most up-to-date approach seems to be in configuring the project file directly (with the latest MSVC and .NET 5+).

<Project>
    <!-- ... --->

 <ItemGroup>
  <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
   <_Parameter1>$(AssemblyName).Tests</_Parameter1>
  </AssemblyAttribute>
 </ItemGroup>

</Project>

Tuesday Coding Tip 06 - Explicit template instantiation

Tue, 07 Apr 2026 09:59:00 +0000

Templated code in C++ must be defined in the header files (or a function within the same .cpp file). This is because whenever a templated function is called, the compiler generates a new implementation using the concrete type the function was called with. If you split the definition from the declaration, you need to tell it what implementations to generate and link.

That’s what explicit template instantiation is for. It is useful when you’re writing generic code for a well-known subset of types, like string manipulation. It cannot be used for totally generic types because you need to be able to list all types the template will be used with (otherwise the user will get a linker error).

// .hpp
#pragma once

#include <string>
#include <concepts>

// Note me using constructible_from instead of is_same_v. This will
// get me into trouble
template<class T>
concept NarrowOrWideString = std::constructible_from<std::string, T>
|| std::constructible_from<std::wstring, T>;

template<NarrowOrWideString StringType>
StringType StrTransformation(StringType source);

template<NarrowOrWideString StringType>
class ClassTemplate
{
public:
    static StringType StrTransformation(StringType source);
};

// .cpp
template<NarrowOrWideString StringType>
StringType StrTransformation<StringType>(StringType source)
{
   /* some transformation */
   return source;
}

template std::string StrTransformation<std::string>(std::string);
template std::wstring StrTransformation<std::wstring>(std::wstring);


template<NarrowOrWideString StringType>
StringType ClassTemplate<StringType>::StrTransformation(StringType source)
{
   /* some transformation */
   return source;
}

template class ClassTemplate<std::string>;
template class ClassTemplate<std::wstring>;

// main.cpp
int main()
{
   {
      // This links, note the explicitly created string in parameters
      auto str = StrTransformation(std::string("aaa"));
    
      auto wstr = StrTransformation(std::wstring(L"bbb"));
    
      // ERROR: Type does not conform to concept
      // auto num = StrTransformation(10);
    
      // ERROR: Type does conform to concept,
      // but template was not instantiated for const char[4]
      // auto str2 = StrTransformation("aaa");
    
      // This works, template overload was explicitly specified
      // and the concept allows conversion of const char* to std::string
      // Note that if I used is_same_v instead of constructible_from,
      // I couldn't use const char* as an argument.
      auto str3 = StrTransformation<std::string>("aaa");
    
      // Or I can make an alias
      constexpr auto&& StrTransformationA = StrTransformation<std::string>;
      auto str4 = StrTransformationA("aaa");
   }
  
   {
      // ERROR: C++ template type deduction is not good enough
      // auto str1 = ClassTemplate::StrTransformation(std::string("aaa"));
    
      // I need to be explicit
      auto str2 = ClassTemplate<std::string>::StrTransformation("aaa");
    
      // Or make an alias
      using ClassTemplateA = ClassTemplate<std::string>;
      auto str3 = ClassTemplateA::StrTransformation("aaa");
   }
}

Tuesday Coding Tip 05 - Object initialization in C++

Tue, 31 Mar 2026 09:26:00 +0000

There is a five-hundred-page book about C++ initialization out there. Why? Because we cater to way too many styles and many constructor capabilities. This tip is not about explaining all the options but rather about some good practices you can use to minimize mistakes.

The “classic” or pre-C++11 way of initializing objects has the pitfall of triggering the “most vexing parse”. In such case, the compiler cannot tell whether you are calling a constructor or making a function declaration. And because C allowed for function declaration inside functions, it will pick the function declaration. You can omit the braces for the default constructor, but you can still encounter problems as shown in the ‘mvp2’ case. Trunk versions of GCC and Clang emit a helpful warning in this case.

// Classic C++ style
Object obj1(param1, param2); // This works
Object mvp1(); // Most Vexing Parse
Object mvp2(int(param1), int(param2)); // Also MVP

The “modern”, “universal” or post-C++11 way is also not the best one. It is consistent with struct initialization but can invoke incorrect constructors if you intermix normal parameters and std::initializer_list as demonstrated with the std::vector.

// Modern (uniform) C++ style
Object obj2{param1, param2};
Object obj2_2 = {param1, param2};
std::vector<int> vec(10); // vector containing ten default constructed items
std::vector<int> vec{10}; // vector containing one element with value 10

Then you have what I call a “Java” style. It’s verbose and has the same issues if you use curly braces. At least it doesn’t trigger MVP. The last version is what I often use due to its similarity to many other languages where you use var or let to denote the variables and usually specify the type name after the variable name.

// Verbose Java style
Object obj3 = Object(param1, param2);
Object obj3_2 = Object{param1, param2};

// Modern language style
auto obj4 = Object(param1, param2);
auto obj4_2 = Object{param1, param2};

Note that even though there is an assignment operator, no assignment, copy or move is happening — objects are constructed directly.

I recommend using the “modern language style” with simple braces only for regular constructors and curly braces only for initializer-list constructors. It makes your intent clear and prevents you from accidentally shooting yourself in the foot. “Java style” might be preferable for class attribute declarations, with the same rules regarding braces.

Tuesday Coding Tip 04 - Precompiled headers

Tue, 24 Mar 2026 10:59:00 +0000

Do you use CMake and need to improve your C++ compile times? There’s a technique called precompiled headers. Usually, it is somewhat obtuse to set up, MSVC tends to force you to include the precompiled header in every single .cpp file.

With CMake, you can use a single command to instantly boost your compile times with zero invasiveness. On my hobby project, I reduced compile time down from 3m30s to just 30s (in single threaded CI, I went from 7m to 3m30s).

# PROJECT_NAME refers to target that was used with
# add_library or add_executable command
target_precompile_headers ( ${PROJECT_NAME}
    PRIVATE
        <vector>
        <format>
        <map>
        <unordered_map>
        <array>
        <optional>
        <expected>
        <fstream>
        <filesystem>
        <functional>
        <concepts>
        <memory>
        <string>
        <cstdint>
        <DGM/dgm.hpp>
        <TGUI/tgui.hpp>
        <json.hpp>
)

Just remember to only include headers that don’t change often, presumably never. Good candidates are std headers and third party header-only dependencies.

Tuesday Coding Tip 03 - Structured bindings

Tue, 17 Mar 2026 10:59:00 +0000

Since C++17, we can use “structured bindings”. These allow you to perform tuple, array, or even structure unpacking. Such unpacking is commonly helpful when iterating over maps, so you don’t have to define an alias for key and value manually. It is equally useful when a function returns a tuple.

// Iterating over key-value pairs
auto myMap = std::unordered_map<std::string, int>{ /* ... */ };
for (auto&& [key, value] : myMap)
{ /* ... */ }

// Tuple unpacking
auto&& [index, quantity, name] = std::tuple{10, 30, "a"};

// Struct member aliasing
struct S {
    int veryLongAndDescriptiveName;
    std::string anotherVeryWordyName;
};

auto&& [index2, name2] = S{}; // s is of type S

// Array unpacking
auto&& [first, second, third] = std::array{1, 2, 3};

Unpacking struct members and arrays is just a cherry on top. You won’t use it much, but it is there should you ever need it!

Tuesday Coding Tip 02 - Template with type-specific API

Tue, 10 Mar 2026 11:00:00 +0000

What if you had a template class and you wanted to give it extra methods for certain specializations?

For example, you might want to make a templated initialization guard and you want it to be as non-intrusive as possible. So you want it to support arithmetic operations if the underlying type is an arithmetic type.

Before C++20, you could leverage std::enable_if. However, such code is clunky and unreadable:

#include <type_traits>
#include <string>

// Pre C++20
template<class T>
class TemplatedClass
{
public:
  template<class = typename std::enable_if<std::is_integral<T>::value>::type>
  void foo() {}
};

int main()
{
  TemplatedClass<int> a;
  a.foo(); // OK

  TemplatedClass<std::string> b;
  b.foo(); /* Error:
  error: failed requirement 'std::is_integral<std::basic_string...>' requested here
  error: no matching member function for call to 'foo'
  note: candidate template ignored: couldn't infer template argument ''
  */
}

With C++20, you can use concepts and the requires keyword to clean up the syntax significantly, either by in-place definition of type properties or by defining a dedicated concept. It also improves readability of error messages.

#include <type_traits>
#include <string>

// C++20, requires
template<class T>
class TemplatedClass2
{
public:
  template<typename = void>
  requires std::is_integral_v<T>
  void foo() {}
};

// C++20 with concept
template<class T>
concept IsIntegral = std::is_integral_v<T>;

template<class T>
class TemplatedClass3
{
public:
  template<typename = void>
  requires IsIntegral<T>
  void foo() {}
};

int main() {
  TemplatedClass2<int> a;
  a.foo(); // Ok

  TemplatedClass3<std::string> b;
  b.foo(); /* Error:
  error: no matching member function for call to 'foo'
  note: candidate template ignored: constraints not satisfied [with $0 = void]
  note: because 'std::basic_string<char>' does not satisfy 'IsIntegral'
  note: because 'std::is_integral_v<std::basic_string<char> >' evaluated to false
  */
}

Tuesday Coding Tip 01 - C++ Concepts

Tue, 03 Mar 2026 11:00:00 +0000

Concepts are a C++20 feature that greatly simplifies templated code and allows you to build powerful type trait restrictions.

#include <concepts>

class Interface {
public:
    ~Interface() = default;
};

template<class T>
concept DerivedFromInterface = std::derived_from<T, Interface>;

// Note how 'class' or 'typename' is replaced with 'DerivedFromInterface'
template<DerivedFromInterface ObjectType>
void DoSomethingWith(ObjectType& object) {}

// Usage
class A final : public Interface {};
A a;
DoSomethingWith(a);

For example, you can create a function that accepts a concrete type that implements a certain interface, potentially allowing the compiler to optimize away the virtual table. Or you can define static interfaces where an object is required to have certain methods or even attributes, even if it doesn’t implement any inheritance-based interface. Or you can restrict the function to be called only with a small subset of well-known types.

#include <concepts>
#include <string>

template<class T>
concept Serializable = requires(T&& object)
{
    // Object has callable method 'serialize' which
    // returns something that works same as std::string
    { object.serialize()} -> std::same_as<std::string>;
};

template<Serializable T>
void UploadSerializable(const T& object)
{
    auto data = object.serialize();
    // ...
}

// Usage
class Settings {
public:
    std::string serialize() const { return ""; }
};

Settings settings;
UploadSerializable(settings);

Concepts do not replace dynamic polymorphism as you cannot do everything in compile-time. Still, it can open new optimization opportunities and help you write in-place construction functions like std::make_unique without an excessive amount of unreadable templates.

#include <concepts>
#include <string>
#include <memory>

// A function that accepts any string, disregarding if wide or narrow
template<typename T>
requires std::is_same_v<T, std::string> || std::is_same_v<T, std::wstring>
void DoSomethingWithAString(const T& str) {}

// A better implementation of make_unique which checks whether the
// object can be created from given arguments
template<class T, class ... Args>
requires std::constructible_from<T, Args...>
std::unique_ptr<T> make_unique(Args&& ... args)
{
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

Lastly, among the benefits to the syntax, they improve the compiler error messages, making life of your users way simpler.