DEV Community: Anton Dolganin

Rust: Transparent Wrappers with Deref Coercion

Anton Dolganin — Thu, 08 Jan 2026 16:41:00 +0000

The Newtype pattern (struct Username(String)) is great for type safety, but it often feels clunky because you lose direct access to the inner type's methods. Implementing the Deref trait solves this, making your wrapper behave like the data it holds.

Why Use It

Zero-Cost Abstraction: Strict type differentiation (e.g., Username vs. Password) without the boilerplate of proxying every method.
API Ergonomics: Seamlessly use methods like .len(), .is_empty(), or .contains() directly on your custom struct.

Implementation


use std::ops::Deref;

struct Username(String);

impl Deref for Username {
    type Target = str; // The type we want to "mimic"

    fn deref(&self) -> &Self::Target {
        &self.0 // Return a reference to the inner value
    }
}

In Action

Thanks to Deref Coercion, the compiler automatically triggers .deref() when it encounters a type mismatch that can be resolved by a reference.


let name = Username("Anton".to_string());

// 1. Direct access to &str methods
println!("{}", name.len());        
println!("{}", name.contains("a")); 

// 2. Passing to functions expecting &str
fn greet(s: &str) {
    println!("Hello, {s}");
}

greet(&name); // Coercion kicks in here

Intent Matters: Only use this when the wrapper is conceptually a “smart pointer” or a transparent extension. If the inner type’s methods could break your struct’s internal logic, stick to manual method delegation.

Rust CI: Security, Dependency Policy, Coverage Gate, and Fast Builds

Anton Dolganin — Sun, 23 Nov 2025 16:52:38 +0000

A typical GitHub Actions workflow for Rust:

runs-on: ubuntu-latest

steps:
  - uses: actions/checkout@v4

  - name: Install cargo-audit, cargo-deny, tarpaulin, chef
    run: cargo install cargo-audit cargo-deny cargo-tarpaulin cargo-chef

  - name: Security check
    run: cargo audit

  - name: Dependency policy check
    run: cargo deny check

  - name: Test coverage gate
    run: cargo tarpaulin --fail-under 80

  - name: Build using cargo chef
    run: |
      cargo chef prepare --recipe-path recipe.json
      cargo chef cook --recipe-path recipe.json
      cargo build --release

This pipeline:

performs security validation,
enforces dependency and license policies,
ensures test coverage quality,
and builds your Rust project quickly using dependency caching.

What each step does:

Security check (cargo-audit)

cargo audit

Scans Cargo.lock for vulnerable, deprecated, or compromised dependencies using the RustSec advisory database.

Dependency policy check (cargo-deny)

cargo deny check

Validates your dependency graph: licenses, banned crates, duplicates, and other policy rules.

Test coverage gate (cargo-tarpaulin)

cargo tarpaulin --fail-under 80

Measures test coverage and fails the CI pipeline if coverage is below 80%.

Fast build using cargo-chef


cargo chef prepare --recipe-path recipe.json
cargo chef cook --recipe-path recipe.json
cargo build --release

prepare: generates a dependency recipe.
cook: builds and caches dependencies separately.
cargo build --release: final build using a warmed dependency cache.

via @Let's Get Rusty

Makefiles — add a make help command

Anton Dolganin — Wed, 19 Nov 2025 17:48:57 +0000

If you’re using Makefiles — add a make help command.
It auto-parses comments and shows all tasks instantly.

Simple hack, huge productivity boost.

help:
    @awk 'BEGIN {FS=":"} \
    /^#/ {comment=substr($$0,3)} \
    /^[a-zA-Z0-9_-]+:/ {printf "\033[36m%-20s\033[0m %s\n", $$1, comment}' Makefile

Scraping and Summarizing LinkedIn Jobs with a Chrome Extension + ChatGPT

Anton Dolganin — Tue, 09 Sep 2025 13:06:40 +0000

Intro

Scrolling through endless job descriptions on LinkedIn can be overwhelming.

I wanted a faster way to get the essence of a role — so I built a small Chrome extension.

This extension:

Scrapes job descriptions from LinkedIn (directly from the job page)
Cleans up the text (removes tags, weird spacing, extra line breaks)
Sends it to ChatGPT with a custom prompt
Displays a structured summary right inside the popup

All processing happens locally in the browser, and ChatGPT is called directly via API. No backend, no middlemen.

How It Works

Install the extension locally (Load unpacked in chrome://extensions)
Open any LinkedIn job post
Click the extension icon → job description appears in a popup
Hit Send to ChatGPT → receive a clean, structured summary (role, requirements, stack, seniority)

Why Build It?

I often check LinkedIn job posts but most descriptions are long walls of text.

This extension reduces noise and lets me quickly see if a role is relevant.

It’s also a fun example of how browser scripting + OpenAI API can be combined for productivity.

Setup

Clone repo and load unpacked in Chrome:

git clone https://github.com/anton-ds/linkedin-scraper-ext

Then add your OpenAI API key and prompt in the Options page.

Wrap-up

If you’re curious, the code is open-source:

👉 https://github.com/anton-ds/linkedin-scraper-ext

Would love feedback, ideas, or PRs!

String + Length: A Zero-Overhead Trick in C

Anton Dolganin — Mon, 01 Sep 2025 13:39:46 +0000

📌 Problem

In C you often need to keep a string together with its length. Calling strlen() every time means extra memory scans. We want it compact and efficient.

✅ Solution

A tiny trick with typedef + macro:


typedef struct { const char *p; size_t n; } sv;
#define SV(s) { (s), sizeof(s) - 1 }

struct Messages {
    sv error, version, rep_prefix;
};

static const struct Messages mess = {
    SV("error"),
    SV("version"),
    SV("Server reply: ")
};

After preprocessing it becomes:


static const struct Messages mess = {
    { ("error"),          sizeof("error") - 1 },
    { ("version"),        sizeof("version") - 1 },
    { ("Server reply: "), sizeof("Server reply: ") - 1 }
};

— string and its length, no redundant strlen().

Usage


#include <stdio.h>

int main(void) {
    fwrite(mess.rep_prefix.p, 1, mess.rep_prefix.n, stdout);
    fwrite("OK\n", 1, 3, stdout);
    return 0;
}

Handy in network protocols, logging, binary formats — string + size always at hand, zero overhead.

The “best stack” is a myth

Anton Dolganin — Fri, 11 Jul 2025 21:00:21 +0000

There’s no universal tech stack that fits every project.
When choosing a stack, I always focus on 3 things:

The task — what really needs to be done
The team — who will maintain it tomorrow
The context — budget, deadlines, infrastructure

Sometimes it’s Java + Kafka + Kubernetes.
Sometimes it’s just PHP + MySQL on a basic VPS.

Both can be right, if they solve the problem.

Working on combat logic that’s completely independent of the game code

Anton Dolganin — Fri, 27 Jun 2025 22:30:47 +0000

The idea is to let a designer (aka a human) create combat mechanics through an editor, which are then delivered to the game as JSON. It’s exciting to apply old knowledge to new areas like this.

P.S. Spent a good while wrestling with the grid system. Eventually tracked it down to an issue with child components in the engine.

PostgreSQL: Don't Rush to Index BOOLEAN Columns

Anton Dolganin — Mon, 23 Jun 2025 22:03:28 +0000

It might feel natural to index is_active — but in PostgreSQL, it often does more harm than good.

Why?

BOOLEAN has only three values: true, false, NULL.

If values are evenly distributed (e.g. 50/50), the B-tree index is inefficient. The planner will usually pick a sequential scan instead of using the index.

Index helps when:

One value is rare (e.g. 1% are false)
Queries target only rare values

Better option: use a partial index

CREATE INDEX idx_inactive ON users (id) WHERE is_active = false;

Rust for Kids

Anton Dolganin — Wed, 11 Jun 2025 22:04:41 +0000

This article doesn’t aim to teach you Rust or unveil some hidden feature. It’s more like an experiment — a way to show a kid what Rust looks like on the inside (Rust, not the kid), rather than how to write idiomatic Rust code.

In other words, devs are used to judging a language by how well it fits into their mental model of “how code should be written.” And when it doesn’t? That’s when the frustration kicks in.

Here, I tried flipping the perspective — think “picture book”: how the language lives and breathes, not how we’ve learned to structure it.

⚠️ Disclaimer: This article isn’t about Copy types like i32, f64, bool, char, or &T. We're diving into move types — like String — where values are actually moved around.

Alright, let’s roll.

We’ll start with a core idea in Rust: a value (a memory cell) can only have one owner at a time.
Let’s introduce a bit of “storybook” notation:

let = “let it be”
= = “takes ownership”
mut = “money”, yep, just a money ;)

let

Let’s let a own a House:


let a = String::from("House");

Now let’s let b own that same House. According to the rules, the previous owner has to move out — no exceptions:


let b = a;

At this point:


println!("a = {}", a);

Boom — error.

Why? Because a no longer has the right to do anything with the value (its former House). Ownership was transferred, and Rust enforces that hard.

mut

But wait — there’s more. Just owning a House doesn’t mean you can start remodeling it. Think of it like renting someone else's place — ownership without modification rights.

So this will trigger an error:


b.push_str(" with Pool"); // 🔴 error

If you want to make changes, you have to buy the House with some extra money mut.


let mut c = b;
c.push_str(" with pool");
println!("{}", c); // House with pool

Now c has the keys and the renovation permit.

We can share access to the House — say, by letting a buddy crash for a while. You hand them a copy of the keys using &:


let d = &c;
println!("{}", c);
println!("{}", d);

But there’s a catch. According to the social contract, if guests are inside, no renovations allowed. The following code will throw an error:


let d = &c;
c.push_str(" with sandbox");// can't renovate while guests are over
println!("{}", c);
println!("{}", d);// guest is here

You have to wait until the guests leave:


let d = &c;
println!("{}", d);// guest leaves
c.push_str(" with sandbox");

Still confused? There’s a full “guest etiquette” section at the end of the article.

& mut

Now let’s say your buddy wants to add a hot tub. Since that’s a modification to the House, you ask him to chip in — and in return, you give him the real keys with change privileges: &mut.


let e = &mut c;
e.push_str(" and with hot tub");
println!("{}", e);

Just remember: same rule applies — if someone else is holding the keys, you can’t do any remodeling. In fact, while your buddy is chilling in the hot tub, you can’t even enter the house:


let e = &mut c;
e.push_str(" and with hot tub");
println!("{}", c);
println!("{}", e);// buddy’s in the hot tub

You have to wait for them to finish:


let e = &mut c;
e.push_str(" and with hot tub");
println!("{}", e);// buddy’s done
println!("{}", c);

This only applies when you gave out “paid” access (&mut) — not when you just let someone couch-surf with &.

mut &mut

Now we rent out the House again — to another buddy, this time with full mod rights. But this buddy also has their own extra money — mut.


let mut f = &mut c;
f.push_str(" and with garden");

Things are going well, and we decide to buy a second place: Apartment.


let mut c2 = String::from("Apartment");

Our buddy’s not slacking either — “Let me try out the Apartment too,” he says, waving his mut wallet. So he moves out of the House, into the Apartment, and starts upgrading that too:


f = &mut c2;
f.push_str(" with elevator");

Same core idea: ownership with editing rights = &mut. And declaring let mut f means this buddy isn’t tied to just one location — he can move between places and make changes. Because money mut, yep

After he’s gone, we end up with both properties modified:


println!("c: {}", c);
println!("c2: {}", c2);
//c: House with pool and with sandbox and with hot tub and with garden
//c2: Apartment with elevator

Note: When I say “the buddy left,” I mean it literally — he’s gone, out of scope. Rust tracks that. If a variable is no longer used later in the code, Rust considers it dead — like you called delete on it.

That’s why things can seem weird: while the guest is “around,” you’re blocked from doing stuff, but it’s not always clear they’ve “left.” Rust figures it out by analyzing whether the variable is used again — if not, it’s safe to proceed.

Functions

With a few rare exceptions, the same rules apply to functions too. I won’t overload this post with function examples — maybe next time :)

Logic Separation — One Thread per Role

Anton Dolganin — Sun, 08 Jun 2025 17:22:14 +0000

You write:


std::thread network(serve_clients);
std::thread game(game_loop);
std::thread logger(flush_logs);

Yes, everything still runs in sequence (depending on CPU), but the logic is cleanly separated across threads.

It’s way simpler than stuffing everything into one giant loop with a million ifs.
Even on a single core — this model is easier to read, test, and extend.
And once you upgrade to 4+ cores — performance improves instantly, without changing the architecture.
Bonus: each thread handles its own domain. Easier to reason about, debug, and scale independently

Cloud build of Unreal Engine 5.5 server for €0.5

Anton Dolganin — Mon, 02 Jun 2025 18:52:39 +0000

Let’s start with the problem. Although Unreal Engine is cross-platform, it makes logical sense to host the server on Linux. Of course, you could host it on a Mac, but it’s hardly justifiable. So, a reasonable question arises — how do you build the server for Linux?

Next is the problem of building the server for Linux while working on another OS:

On Linux, there are no issues if you have the resources and space (at least 200 GB of storage, preferably with 8 cores and 32 GB of memory).
On Windows, it involves a lot of workarounds, but the problem can be the same as in point 1.
On Mac – this is my case – no matter how hard I tried, I couldn’t get it to work, and each such experiment would overheat the Mac, disrupting my other tasks.

The solution? I decided to try building it in the cloud. Ideally, I wanted it to be so cheap that I could do it over and over again.

AWS does offer something similar, but only through a request (not to be confused with GameLift), and it would probably cost a fortune. I found a solution for just 50 cents 😉

And about the time. In general, building such a project is a slow process on any hardware. But just a heads-up — on the chosen configuration below, it took me 5-6 hours from logging into the server to running the built server.

Below is a dry todo list for copy-pasting, with some comments. But trust me, I learned my lessons the hard way while working through the drafts.

Server selection

I was choosing between:

AWS, but for a suitable machine, I’d be paying around the same 50-70 cents per hour, if not more.
DigitalOcean, about twice as cheap as AWS, but with very inconvenient scaling — either not enough resources or space. Or I’d have to purchase extra volumes, which isn’t cost-effective.
Unexpectedly, my choice fell on Hetzner Cloud. Specifically, their cloud infrastructure, where you can also run a server by the hour. And it only costs €0.093. Isn’t that awesome?!

Here, it’s not worth being stingy and it’s best to go for this one right away:

Because you’ll need about 200 GB of storage, and it runs much faster on 8 cores. Yes, I did experiment with the previous option as well.

The OS is Ubuntu. And it has to be version 22.04, as it’s the officially supported version by Epic. Without reading the requirements, I installed the latest version right away, and the build failed at the final stages — it was frustrating (ispc.generated files didn’t build).

Preparation and building the engine

You need to create a user in the sudo group, since building as root is not allowed. Since the server is purely for a single task for a few hours, I didn’t bother with security or permissions systems — I just created a user named builder.
And of course, you should also update the packages.

apt update && sudo apt upgrade -y
adduser builder
usermod -aG sudo builder

When creating the user, it will ask for a password — you’ll need it later.

Next, simply switch to the created user and from there, you can clone the engine repository of the required version (as a reminder, this article is about version 5.5). To access and clone the UE repository, don’t forget that your GitHub account needs to be linked to your EpicGames account.

su - builder
git clone --branch 5.5 https://github.com/EpicGames/UnrealEngine.git

The above operation will take about half an hour. Next, go to the engine directory, run the setup and generation steps, and also remove two plugins that the server doesn’t need — otherwise, they’ll just get in the way.
At the setup stage, you’ll be prompted to enter the password for the builder user.

cd UnrealEngine/
./Setup.sh
./GenerateProjectFiles.sh
rm -rf ./Engine/Plugins/Fab
rm -rf ./Engine/Plugins/Bridge

Now we’ve reached the most critical stage — the build (approx. 3 hours). To be safe, we’ll run everything inside screen, so we can easily reconnect later if we get disconnected (screen -r).

screen -S unreal_build
make

Building the game server

Alright, we’ve finished building the engine, now let’s move on. A quick reminder — we’re currently in the engine directory, so let’s move up a level and clone our own project.

cd ../
git clone https://github.com/anton-ds/DedicateTest.git

After cloning, switch to the engine directory and run the server build command. This will take a couple more hours, but future rebuilds of the server will definitely be faster.

cd UnrealEngine/
./Engine/Build/BatchFiles/RunUAT.sh BuildCookRun \
    -project="/home/builder/DedicateTest/DedicateTest.uproject" \
    -noP4 -platform=Linux -server -build -cook -stage -pak -archive \
    -archivedirectory="/home/builder/DedicateTest/BuildOutput"

A reminder: builder is our user under which we’re building, and it’s also the name of the directory where we cloned the project (in my case, it’s DedicateTest). The final result will appear in the BuildOutput subdirectory of our project.

Running the server and connecting the client

I deliberately did not mention how to properly develop multiplayer games in Unreal Engine in this article (since, to be honest, it’s mostly ready out of the box), because the title suggests you are reading this for a specific purpose — building the server — and you already know how everything else works.

It’s worth noting here that the cloud server has completed its task and can be deleted. You simply copy the BuildOutput/LinuxServer directory to your production server and launch it there. However, I recommend checking the following steps once on the current setup.

On the server, switch to the directory containing our server build and launch the server (first, make sure to open the port the server will listen on — in my case, it’s 7777). Keep in mind, we are still working under the user builder, and we’ll continue as this user. The project code is — DedicateTest.

sudo ufw allow 7777/udp
sudo ufw reload
cd ./LinuxServer
./DedicateTestServer.sh ThirdPersonMap -port=7777

Also, note that in the server launch parameters I specify the name of the map the server will run. In my case, it’s more convenient this way.

Alright, let’s assume your client is built on the same version — launch the game. Perhaps you already have the logic for connecting to the server implemented, but if not, you can open the in-game console (~) and enter a command with the server IP and port.

open <ip>:7777

In the server logs, you should see a successful connection from your client’s IP. Once you connect with another client, you’ll be able to interact between clients through the server.

But there’s a catch...

Compatibility

There’s a logical requirement — both the server and the client must be built from the same code version. However, Unreal Engine takes this even further — for example, a build from source and a build from the binary version (the one you run from the Launcher) are actually different builds. (And sometimes this version mismatch doesn’t even immediately throw an error)

The simplest and most reliable solution is to build the client from source as well, and this is even recommended for multiplayer games. But we assumed that, for now, we either can’t or don’t want to do this.

So, the compatibility error manifests as follows — when the client connects, the server throws an error in the logs:

LogHandshake: CheckVersion: Incompatible version. bValidHandshakeVersion: 1, bValidNetVersion: 0, GHandshakeEnforceNetworkCLVersion: 0, RemoteMinVersion: 3, RemoteCurVersion: 4, MinSupportedHandshakeVersion: 3, CurrentHandshakeVersion: 4, RemoteNetworkVersion: 2530911350, LocalNetworkVersion: 4263286266, RemoteNetworkFeatures: GenericReplication, LocalNetworkFeatures: GenericReplication

CheckVersion: Incompatible version ... RemoteNetworkVersion: 2530911350, LocalNetworkVersion: 4263286266.

For a quick fix to check if your client works with the server (important! This fix is NOT for production!), you can do the following. Or, you can write your own version checking logic.

In the Source/DedicateTest/DedicateTest.cpp file (the filename may vary depending on your project’s name), add the following:

// Copyright Epic Games, Inc. All Rights Reserved.

#include "DedicateTest.h"
#include "Modules/ModuleManager.h"

class FDedicateTestModule : public FDefaultGameModuleImpl
{
public:
    virtual void StartupModule() override
    {
        FNetworkVersion::IsNetworkCompatibleOverride.BindStatic(&FDedicateTestModule::IsNetworkCompatible);
        FNetworkVersion::GetLocalNetworkVersionOverride.BindStatic(&FDedicateTestModule::GetLocalNetworkVersion);
    }

    virtual void ShutdownModule() override
    {
        FNetworkVersion::IsNetworkCompatibleOverride.Unbind();
        FNetworkVersion::GetLocalNetworkVersionOverride.Unbind();
    }

    static bool IsNetworkCompatible(uint32 LocalNetworkVersion, uint32 RemoteNetworkVersion)
    {
        // here you can add your own logic for checking network compatibility
        return true;
    }

    static uint32 GetLocalNetworkVersion()
    {
        // must be equal to the server version
        return 4263286266;
    }
};

IMPLEMENT_PRIMARY_GAME_MODULE( FDedicateTestModule, DedicateTest, "DedicateTest" );

That number 4263286266 is the network version number from the server logs. Rebuild the client build (not the server), and run it. Everything should work.

That’s it — don’t forget to delete the build server. 😉