Forem: Aleksandar Sabo

Why Fixers Get Praise but Preventers Get Ignored

Aleksandar Sabo — Tue, 06 Jan 2026 00:00:00 +0000

We often forget an old truth: we don't appreciate what we have until we lose it. Nowhere is this more evident than in the case of peace - whether in a society, an organization, or even a well-functioning machine. No one wonders why or how as long as things work as expected. But the moment something breaks, suddenly everyone wants to know who is responsible and what went wrong.

This says a lot about how we think and operate as a society - we give more credit to those who fix problems than to those who stop them from happening in the first place. The people who quietly keep things from falling apart usually don't get noticed because nothing ever goes wrong on their watch.

How a Friend Taught Me the Cost of Prevention

A friend once worked as a technician to maintain a hospital's X-ray equipment. His job was primarily preventative - he regularly inspected and fine-tuned the machines to ensure they ran smoothly. And they did. They ran so well for so long that some of his coworkers began questioning whether he had any real work. "Everything works perfectly - what does he even do here?"

Frustrated, he changed his approach. He stopped intervening preventatively and began letting the inevitable minor issues occur. As soon as a machine failed - often due to something simple like a blown fuse or a misaligned sensor - he'd step in to "fix" the problem. But this time, everyone noticed. His role became visible. People began thanking him for "resolving" the issue quickly, unaware that the very problems they now praised him for fixing could have been prevented in the first place.

What he did didn't change - just how he went about it. But suddenly, people saw him differently. That shift says a lot about us: we're quicker to praise those who clean up messes than those who ensure the mess never happens.

Taleb and the Hidden Cost of Prevention

In The Black Swan, Nassim Nicholas Taleb discusses this phenomenon in the context of uncertainty and decision-making. He describes a particular form of societal ingratitude - one where we fail to reward those who prevent negative outcomes because those outcomes never become visible.

One of his key examples involves the idea of securing cockpit doors in airplanes before the 9/11 terrorist attacks. Imagine, Taleb writes, if someone had successfully pushed for reinforced cockpit doors in the 1990s. The tragic events of September 11 might never have occurred. But instead of being hailed as a hero, that person likely would have been dismissed as paranoid or criticized for wasting resources on an "unlikely" threat. Because no one would have seen what was prevented, the preventive action would have appeared unnecessary.

Taleb calls this "the problem of silent evidence" - we only see what happened, not what didn't happen. In other words, prevention erases its proof, and with it, the social rewards.

Crisis Managers vs Preventative Architects

In almost every domain, from national security to IT systems, we lionize the crisis manager - the firefighter, the troubleshooter, the person who swoops in when everything is on fire. And they do deserve praise. But we often forget the invisible architects - those who built the fire-proofing in the first place or designed the systems to prevent chaos from emerging.

This skewed reward system has dangerous consequences. It encourages people to allow problems to surface so they can be seen fixing them. In politics, it results in reactive leadership - short-term solutions to long-term problems. In business, it leads to firefighting cultures where the loudest problem-solvers get promoted, even if their negligence or short-sightedness created the issues in the first place.

Why Do We Think This Way?

Human cognition is wired for narrative and cause-effect thinking. We crave visible change, dramatic moments, and heroes we can point to. Preventative action lacks that drama. It's the difference between the story of someone rescuing a child from drowning - and someone who quietly built a fence around the pool years ago.

Peace, stability, and resilience don't make headlines. Disasters do.

The Wisdom of Recognizing Peace

To build better systems and societies, we need to value the unseen work. We must learn to reward the uneventful day, the smooth operation, the long stretch of "nothing happening" - because that is often the result of effort we don't see.

We can start by rethinking our workplace, school, and government encouragements. We can teach children and teams to solve problems and look for weak points before failure. We can publicly celebrate those who design out the need for intervention, not just those who clean up the mess.

Because ultimately, peace is not the default - it's an achievement. And its value becomes tragically clear only when it's gone.

Let's not wait for war to understand the worth of peace.

Setting Up PHPUnit and GitHub Actions for a PHP Project

Aleksandar Sabo — Tue, 06 May 2025 17:21:00 +0000

This tutorial shows you how to set up a basic PHP project with Composer, write tests using PHPUnit, and automate test execution with GitHub Actions. It’s intended for developers who want a clean starting point for building and testing PHP code.

You’ll create the project structure, configure Composer, add a simple test case, and define a GitHub Actions workflow to run tests on each push or pull request. By the end, you'll have a fully working setup for local and automated testing.

Setting Up a PHP Project

Before you begin, ensure that PHP and Composer are installed on your computer.

php --version
composer --version

Initialise Your PHP Project

Create a folder for your project.

mkdir conditional-test-execution
cd conditional-test-execution

Initialize a new PHP project by running composer init in your project directory.

composer init

This will create a composer.json file. Ensure that your composer.json has the following structure.

{  
    "name": "software-witchcraft/conditional-test-execution",  
    "description": "A small demo project for showcasing conditional PHP test execution in GitHub Actions, created to support a tutorial.",  
    "type": "project",  
    "license": "mit",  
    "autoload": {  
        "psr-4": {  
            "SoftwareWitchcraft\\ConditionalTestExecution\\": "src/"  
        }  
    },  
    "authors": [  
        {  
            "name": "Software Witchcraft",  
            "email": "info@softwarewitchcraft.com"  
        }  
    ],  
    "require": {}  
}

Add PHPUnit as a Dependency

Add PHPUnit via Composer. Run the following command in your project's root directory.

composer require --dev phpunit/phpunit ^12

This command installs PHPUnit and its dependencies. The --dev flag indicates that PHPUnit is a development dependency, not required for the production environment.

Configure PHPUnit

Create a phpunit.xml file in your project root. This file will hold your PHPUnit configuration. Here's a basic example.

<phpunit bootstrap="vendor/autoload.php" colors="true">
    <testsuites>
        <testsuite name="My Test Suite">
            <directory>tests</directory>
        </testsuite>
    </testsuites>
</phpunit>

In this file, bootstrap points to Composer's autoloader, and the tests directory is where your test files will reside.

Write Your First Test

Create file Greeter.php in your src folder ...

touch ./src/Greeter.php

... with following content

<?php

namespace SoftwareWitchcraft\ConditionalTestExecution;

class Greeter
{
    public function greet(string $name): string
    {
        return 'Hello, ' . $name . '!';
    }
}

Create a tests directory in your project root.

mkdir tests

Inside this directory, create a test file, for example, GreeterTest.php ...

touch ./tests/GreeterTest.php

... with a simple PHPUnit test class.

<?php 

use PHPUnit\Framework\TestCase;

use SoftwareWitchcraft\ConditionalTestExecution\Greeter;

class GreeterTest extends TestCase
{
    public function testGreetsWithName(): void
    {
        $greeter = new Greeter();

        $greeting = $greeter->greet('Alice');

        $this->assertSame('Hello, Alice!', $greeting);
    }
}

Running Tests Locally

To run your tests, execute the following command in your project root:

./vendor/bin/phpunit --testdox

This command runs all the tests defined in your tests directory. PHPUnit will look for any files ending in Test.php and execute them.

Setup Git Repository and Push Your Project to GitHub

Init you git repository.

git init

Create .gitignore file ...

touch .gitignore

... with following content

/vendor/
/composer.lock
/.phpunit.result.cache
/.idea/
.DS_Store

Add and commit all your changes to your repository.

git add . 
git commit -m "initial commit"

Create a repository on GitHub, and link it to your local repository.

git remote add origin git@github.com:yourusername/your-repository-name.git

Don't forget to update yourusername/your-repository-name!

Push your local repository to GitHub.

git push -u origin main

Now that we have our PHP project and PHPUnit setup complete, let's move on to the next section where we will set up GitHub Actions to automate our testing process.

Setting Up the GitHub Actions Environment

To start leveraging GitHub Actions, you need to set up a workflow. A workflow is a set of automated procedures and tasks that are executed based on defined events, like a push or a pull request.

Create a GitHub Actions Workflow File

In your project repository, create directory .github/workflows.

mkdir -p ./.github/workflows

Inside this directory, create a new file named RunTests.yml (or any other name you prefer, but keep the .yml extension).

touch ./.github/workflows/RunTests.yml

Define the Workflow

Start the YAML file with a name for the workflow and specify the trigger events. Commonly, workflows are triggered on push or pull request events. For example:

name: Run unit tests

on:
    push:
        branches: [ main ]
    pull_request:
        branches: [ main ]

jobs:
    build:
        runs-on: ubuntu-latest

        steps:
            - name: Check out repository code
              uses: actions/checkout@v4

            - name: Install PHP
              uses: shivammathur/setup-php@v2
              with:
                  php-version: '8.5' # Specify the PHP version
                  tools: composer:v2, phpunit:v9.6
                  coverage: none

            - name: Check PHP Version
              run: php -v

            - name: Install dependencies
              run: composer install # Install PHP dependencies

            - name: Run PHPUnit tests
              run: ./vendor/bin/phpunit --testdox # Execute PHPUnit tests

Commit and Push the Workflow File

After setting up the RunTests.yml file, commit it to your repository and push it to GitHub:

git add .github/workflows/phpunit.yml
git commit -m "Add GitHub Actions workflow"
git push origin main

Once you push these changes to GitHub, the Run PHPUnit Tests workflow will be triggered on the next push or pull request to the main branch, automatically running your PHPUnit tests in the specified environment.

You've now set up a complete PHP project with local testing using PHPUnit and automated test execution via GitHub Actions. This setup helps ensure your code stays reliable by catching issues early with every push or pull request. From here, you can continue building features, adding more tests, and extending your CI workflow as needed.

The complete code for this project is available in the GitHub repository. You can explore the structure, test setup, and workflow configuration in one place and use it as a reference or starting point for your own projects.

The Race That Debugged My Software

Aleksandar Sabo — Thu, 17 Apr 2025 14:21:54 +0000

More than 15 years ago, I worked for a company that produced gym training machines. One of those machines was a kayak ergometer—essentially an indoor kayaking simulator. My job was to write firmware for a device that connected to the ergometer and translated sensor data into something athletes could understand and see: speed, force, distance, and so on.

One day, the company owner came to me with a new idea.

Now that we have all this data being sent to the computer, can you build a piece of software that simulates an actual kayak race?

Challenge accepted.

Turning Data Into a Real Race

I went straight to the drawing board, and a few months later, we had something working. The app visualized each athlete as a moving figure in a simulated kayak race. As they paddled on their machines, their avatars raced forward on the screen. It worked beautifully, and we were all proud of the result.

I wanted to test the app in the real world, so I suggested organizing an amateur race in my hometown. I knew some local kayak clubs and was confident people would show up, but my boss had a different idea.

Let's do a real race. In a big European city. Let's do it in Moscow.

We had a few weeks to prepare everything. I tested everything thoroughly—starting and stopping races a hundred times, trying different configurations, asking colleagues to help test in our company gym, and even spending long evenings paddling just to iron out any edge cases.

Things moved fast. In under two months, we were standing in a sports arena in Moscow, ready for the first-ever simulated kayak competition.

Problem #1: Asleep at the Start Line

The first race went perfectly. The second one, too.

Then came the third race. There was a minor issue with the race list—someone mixed up the names—but it got sorted out. The athletes sat on their machines. Everyone was tense. The crowd was ready.

And then... one by one, the machines started turning off.

We had no idea what was going on. Panic. Confusion. What was happening?

We quickly powered them back on and restarted the race. Crisis averted—for now. But I needed to understand what had gone wrong.

The problem was simple: the devices had been idle for too long before the race started, and the battery-saving algorithm kicked in, shutting them down automatically. During development, we had assumed that five minutes of idle time was more than enough. But it wasn't in a live event with last-minute changes and delays.

The fix was easy:

When the device receives the first RACE INIT command, it disables the power-saving mode until it's manually turned off or runs out of battery.

Problem #2: Paddling Nowhere

With that issue fixed, we kept moving forward.

But then another problem showed up.

The athletes were sitting on their machines. The race was about to start. I sent the start signal. They started paddling—and… nothing. Some of their avatars weren't moving.

I stared at the screen, completely confused. There were no errors or warnings. The athletes were clearly paddling, but their figures just stood still. The race continued like that until the end of the day, and I never figured it out on the spot.

My temporary fix was to stop and restart the race, which usually worked. But it wasn't a solution—it was a workaround.

Back in the office the following week, I finally found the root cause:

The application needed calibration data from each machine to calculate distance. And sometimes, the machine returned all zeros instead of valid calibration data.

If that happened, the race app could not calculate movement, so the avatar just stayed still.

The fix? Also simple:

If the app gets all-zero calibration data, send the request again.
If it happens twice, show a clear error message with instructions for resetting the device manually.

From that point on, the issue never surprised us again.

Problem #3: How a Folder Stopped a Race

With those bugs behind us, we gained confidence. We knew that once the race started and all avatars moved, the system would run flawlessly until the end. The critical moment was the start—after that, we could finally breathe.

It was time for the final race of the event. Everyone was ready. The crowd was buzzing. Athletes sat on their machines, waiting. I gave the start signal.

The race began. Avatars moved. It worked.

I finally allowed myself to relax.

One of the local hosts, who had been helping with logistics the entire day, was sitting next to me. He was holding a folder in his hands, and just as we both leaned back in our chairs, he dropped the folder.

It flew through the air and landed directly on my laptop's keyboard.

Right on the Escape key.

And what did I have programmed the Escape key to do?

Cancel the race.

Just like that, the screen went blank. Race canceled.

I turned to the guy and snapped:

You!? Idiot! Why would you do that?!

I'm still ashamed for flying off the handle and saying something hurtful to him.

But really, I was the idiot—not him.

Why would I assign such a critical action to a single keypress with no confirmation? It was a terrible design decision—a lazy shortcut.

The athletes took a 15-minute break. We restarted the race, and this time, everything went fine. As soon as it ended, I removed the Escape-to-cancel functionality from the software.

What I Learned

This project taught me a lot, but one takeaway stands out:

No amount of testing can fully replicate production. Real users will always break things in ways you never expected.

Mocks, test suites, and staging environments are great and necessary—but they’ll never catch everything. The real bugs show up when your code meets reality. Shipping early is the fastest way to uncover what actually needs fixing.

Once I tackled those unexpected issues, the app ran flawlessly for years—and as far as I know, it’s still out there, quietly doing its job somewhere in the world.

Pro tip: don’t wire critical actions to a single keypress.
And maybe keep folders out of keyboard range. Trust me.

If you’re curious to see what it all looked like—the tension before the start, the athletes paddling hard, and the virtual avatars racing neck and neck—a short video from the competition in Moscow captures the atmosphere.

Watch the video here and experience the race for yourself.

How I Built a Free Static Website for Developers Club Using Next.js and Cloudflare

Aleksandar Sabo — Mon, 07 Apr 2025 22:00:00 +0000

Recently, I rebuilt the website for Developers Club—a local non-profit I co-run with a few friends. It’s a community for software developers where we regularly host meetups, workshops, and discussions. One of our goals with this rebuild was to reduce hosting costs to zero, while keeping the setup simple enough for any member of the club to maintain.

If you’re considering doing something similar—building a small, low-maintenance site for a side project, community, or event—this post will walk you through the approach I used and serve as a reference if I ever need to do it again.

Why Go Static?

The original site was hosted on a paid VPS. While it didn’t cost much, even small recurring costs add up for a non-profit. We didn’t need a CMS like WordPress—just a simple, fast, single-page website that we could update by pushing code to GitHub.

Hosting a static website on Cloudflare Pages made perfect sense:

It’s free for static sites.
GitHub integration allows automatic rebuilds on push.
I’ve had great experiences using Cloudflare for DNS, caching, and SSL in the past.

Step 1: Writing and Designing the Site

I wrote the copy for the website and asked my friend Dalibor—who’s great with front-end work—to build the UI using Tailwind CSS and clean HTML.

My initial plan was to integrate his HTML/CSS with Hugo, since I’ve used it for other static sites (including this blog). Hugo is blazing fast, and deploying Hugo sites on Cloudflare is straightforward—something I’ve done several times already.

However, Dalibor went the extra mile and, instead of delivering plain HTML, he built the site using Next.js.

A bit unexpected—but not a big problem.

Step 2: Making Next.js Work as a Static Site

Next.js can work as a static site generator with a few adjustments. Cloudflare Pages supports static Next.js deployments—but you need to configure the project properly.

The code Dalibor provided couldn’t be built with static export due to a module that wasn’t compatible. I first tried modifying the project settings to enable static export, but that didn’t solve the issue. In the end, I decided to rebuild the project from scratch using a clean Next.js static setup and then copied over the source files.

I followed this official guide to get started:

🔗 Deploy a static Next.js site

Basically, all you need to do is set output to ’export’ in next.config.js like this:

module.exports = {
  output: 'export',
};

Step 3: Deploy the Website to Cloudflare

With the static Next.js project ready, the next step was to deploy it to Cloudflare Pages.

I connected the GitHub repository to Cloudflare and selected “Next.js (Static HTML Export)” as the framework. However, the initial deployment failed due to a version mismatch: Cloudflare uses Node 16 by default, which installs Next.js v14—but our project required Next.js v15, which needs Node 20.

To resolve this, I followed this helpful blog post: How to run a website built with Next.js 15 on Cloudflare Pages

Key Fix

To ensure that Cloudflare uses the correct Node version for building the project, I added the following to the package.json:

"engines": {
  "node": ">20.0.0"
},

I also created a .nvmrc file with:

This combination solved the problem and allowed the deployment to complete successfully.

Step 4: Final Tweaks

Once everything deployed successfully, I made a few final touches:

Added a favicon and site description for better SEO.
Slight color adjustments for better contrast.
Integrated Umami Analytics for privacy-friendly tracking. It’s simple and lightweight—perfect for a community site.

Summary and Takeaways

Here’s what I learned and what I’d do again:

Cloudflare Pages is a solid choice for free static site hosting.
Even though I expected to use Hugo, Next.js works well for this use case with the right setup.
Setting the Node version is critical when using the latest Next.js.
Having the project in GitHub makes collaboration and maintenance easy—our members can now contribute with simple pull requests.

In the end, we now have a modern, free, and maintainable website for Developers Club. It’s fast, easy to update, and reflects the spirit of our community: practical and developer-friendly.

If you want to explore the full implementation, check out the GitHub repository. It’s open for contributions or suggestions if you’d like to help improve the site.

How a Designer Took Project Oktan to the Next Level

Aleksandar Sabo — Wed, 19 Mar 2025 23:00:00 +0000

Over the years, I’ve learned that working with skilled professionals always brings additional value to a project—sometimes in ways you wouldn’t expect. While we, as developers, focus on building functional and efficient solutions, professionals in other domains can refine and elevate our work beyond what we initially envisioned.

One such experience was when I was creating a website for my project, Oktan, a desktop application for tracking car expenses, fuel consumption, and service maintenance logs. I wanted the website to have a strong visual appeal, so I hired a designer to create an illustration for the hero section.

The Initial Idea

After a brief discussion about the job, my instructions were simple: create an illustration featuring a car and three people—one changing a tire, one working under the hood, and one taking notes. This scene was meant to convey the core functionality of Oktan: tracking and maintaining car-related expenses in a structured manner.

When the designer sent me the initial sketch, I was already satisfied. In fact, I was ready to approve it as the final version. However, he insisted on continuing to refine it. At first, I didn’t see the necessity, but I trusted his expertise and let him proceed.

The Unexpected Improvement

What followed was a transformation I hadn’t anticipated. The designer added finer details, such as the workers’ hair, toolbox items, headlights shade, the car’s interior, bringing the illustration to life. The final illustration was far beyond what I had imagined—it was polished, professional, and had a level of depth that I wouldn’t have achieved on my own.

This experience reinforced an important lesson: quality professionals bring more than just technical execution; they bring vision, experience, and a commitment to excellence. Sometimes, they see opportunities for improvement that we, as project owners, might overlook simply because we’re too close to our own ideas.

Why This Matters

In software development, it’s tempting to do everything ourselves. But knowing when to bring in experts—whether they’re designers, copywriters, UX specialists, or other professionals—can make a significant difference in the final product. Here’s why:

They Elevate the Project – Skilled professionals don’t just do the job; they refine and enhance it beyond the initial requirements.
They Save Time and Effort – Instead of struggling to achieve a decent result on our own, we can rely on experts to get things done right, faster.
They Bring a Fresh Perspective – An outside perspective can highlight improvements we wouldn’t have considered.
They Ensure Quality – Professionals care about the details, which leads to a more polished and engaging final product.

Final Thoughts

If you’re working on a project—whether it’s an app, a website, or any other venture—consider bringing in specialists when needed. The investment often pays off in ways you didn’t expect. My experience with the Oktan website illustration is just one example, but it serves as a reminder that working with the right people can take your work from “good enough” to something truly outstanding.

I’m sharing the illustrations in this post, so you can see the difference for yourself.

Key-Value Stores

Aleksandar Sabo — Mon, 10 Mar 2025 23:00:00 +0000

Key-value stores provide a simple yet highly efficient way to manage data. Their speed and scalability make them invaluable for caching, session management, and other high-performance applications. While they may not be suitable for all use cases, they complement relational and document databases by offering rapid access to frequently used data. Understanding how they work, their advantages and limitations, and where they fit in modern software architecture is essential for developers.

How They Work

A key-value store is a type of NoSQL database that manages data as a collection of key-value pairs. This structure is similar to a hash table, dictionary, or map in programming. Each data item is assigned a unique key, and retrieving the value requires looking up the corresponding key. This direct lookup mechanism makes key-value stores extremely fast compared to relational databases that require complex query processing.

A generic example of how key-value stores operate:

Storing Data: The application assigns a value to a key.
```
set user:12345 "John Doe"
```
Retrieving Data: The application retrieves the value using the key.
```
get user:12345  # Returns "John Doe"
```
Updating Data: The value can be replaced by assigning a new one to the same key.
```
set user:12345 "Jane Doe"
```
Deleting Data: Some key-value stores support removing keys explicitly.
```
delete user:12345
```

This simple approach allows for rapid access and modifications, making key-value stores efficient for many real-time applications.

Strengths of Key-Value Stores

1. Speed

Key-value stores are optimized for ultra-fast lookups, making them an excellent choice for applications requiring real-time performance. Since retrieving a value requires only a direct key lookup, response times are significantly lower compared to traditional relational databases.

2. Simplicity

The data model is straightforward, making key-value stores easy to implement and maintain. Unlike relational databases, there’s no need to define schemas, indexes, or relationships.

3. Scalability

Many key-value databases, such as Redis and DynamoDB, are designed to scale horizontally across multiple servers. This makes them ideal for handling large-scale applications that require high availability and distributed storage.

Weaknesses of Key-Value Stores

1. Limited Querying Capabilities

Unlike relational databases, key-value stores do not support advanced queries such as filtering, joins, or aggregations. Developers must structure data retrieval around simple key lookups, which can be a limitation for some applications.

2. Not Ideal for Complex Relationships

If your application requires structured relationships between data—such as users, orders, and products in an e-commerce system—a relational database is often a better choice.

3. Limited Space

Many key-value stores, particularly in-memory databases like Memcached, have constrained storage capacity. This means they are typically used for transient data rather than permanent storage.

Common Use Cases

1. Caching Frequently Accessed Data

Key-value stores excel at caching frequently accessed information. For example, a news website may cache trending articles, reducing the need to fetch data from a slower relational database repeatedly.

2. Session Management

Web applications often use key-value stores to manage user session data efficiently. Instead of storing session details in a relational database, storing them in a key-value store ensures quick access and reduces database overhead.

3. Configuration Storage

Applications can use key-value databases to manage configuration settings dynamically. This enables real-time updates without requiring a complete system restart or a complex database migration.

4. Rate Limiting and Queues

Many high-traffic applications use key-value stores to implement rate limiting. For instance, an API service can track requests per user with a key-value store, limiting excessive usage.

Popular Key-Value Stores

1. Redis

Redis is an in-memory key-value store that supports additional data structures like lists, sets, and hashes. It is widely used for caching, session storage, and real-time analytics.

2. Amazon DynamoDB

DynamoDB is a cloud-based, scalable key-value store offered by AWS. It is designed for high-speed transactions and is commonly used in large-scale applications.

3. Memcached

Memcached is a lightweight, high-performance caching system primarily used to accelerate web applications by storing frequently accessed data in memory.

Conclusion

Key-value stores are an essential part of modern software architecture, providing fast, scalable, and efficient data storage solutions. While they have limitations in terms of querying and relational capabilities, their strengths in speed and simplicity make them invaluable for caching, session management, and other performance-critical tasks. Choosing the right key-value store depends on the specific needs of your application, whether it’s high-speed lookups, distributed caching, or real-time analytics.

Oktan: The Car Expense Tracker I Built 15 Years Ago

Aleksandar Sabo — Sat, 01 Mar 2025 23:00:00 +0000

Over fifteen years ago, I created Oktan, a desktop application designed to track car expenses, fuel consumption, and service maintenance logs. This wasn’t just another project—it was my way of bringing structure to something I deeply cared about: understanding and managing expenses in a digital format.

At the time, smartphones were just emerging, but I didn’t own one. That’s why I built Oktan as a desktop application using C++ and the Qt framework, with SQLite as the database. It started as a personal tool but later became publicly available, even earning a mention in Serbia’s leading computer magazine.

The Problem Oktan Solved

Owning a car comes with many hidden costs—fuel, maintenance, insurance, repairs—and I wanted to track them all. The goal was simple:

Log every fuel refill and service cost.
Get insights into how much the car was actually costing.
Make better decisions when it was time to upgrade or replace the vehicle.

Back then, there weren’t many apps available for this purpose, and certainly not as easily accessible as today’s mobile apps.

Development & Challenges

I developed Oktan in my free time over several months, handling all the coding myself while hiring a designer for marketing graphics. The hardest part wasn’t writing the code—it was pushing through to actually release the app. Finishing a project and making it available to users is a challenge many developers face, and Oktan taught me the importance of persistence.

Features & Functionality

Oktan included:

✅ Fuel consumption tracking

✅ Service and maintenance logs

✅ Graphical reports to visualize spending

The Outcome

Though I didn’t track user numbers, those who used Oktan gave me positive feedback. However, I quickly realized a major issue:

💡 People are more interested in knowing where they can save money rather than tracking where they already spent it.

A budgeting-focused app would have likely gained more traction than an expense-tracking tool.

Lessons Learned

Building Oktan was an invaluable experience that helped me:

Learn how to ship a complete product from idea to release.
Understand how to create Windows installers and package Qt apps with all necessary dependencies.
Gain experience with data visualization and charting in Qt.
Develop a structured approach to app architecture, which I later reused in projects like Silos.

Would I Rebuild Oktan Today?

Short answer: No.

Long answer: The market is now flooded with similar apps, and the business potential for such a project is minimal. If I were to rebuild it, I’d choose a mobile-first approach using Flutter, ensuring it runs on both Android and iOS.

Oktan may not be relevant today, but it was a crucial stepping stone in my journey as a developer. It reinforced the importance of finishing projects, understanding user behavior, and choosing the right platform for the problem at hand.

How to Count and Track Checkboxes in Obsidian with Dataview

Aleksandar Sabo — Thu, 20 Feb 2025 23:00:00 +0000

As a developer juggling multiple projects and responsibilities, I rely on Obsidian for personal life management (PLM). One of the ways I keep track of tasks is through simple checklists in various notes. Over time, I found that manually checking each note to see my progress was inefficient. I wanted a way to display an overview of my progress—specifically, the number of completed tasks out of the total—directly on my dashboard.

Obsidian’s Dataview plugin provided the perfect solution for this.

The Goal

My objective was to automatically count checkboxes from a specific file and show a summary like this:

3 / 12 | My Todos

This way, I could quickly assess my progress without opening multiple files. The count should dynamically update whenever tasks are checked or added.

The Solution

Using Dataview inline queries, I wrote the following snippet and placed it in my dashboard note:

`$= dv.page(dv.current().file.folder + "/todo/My Todos").file.tasks?.filter(t => t.completed).length || 0` / `$= dv.page(dv.current().file.folder + "/todo/My Todos").file.tasks?.length || 0` | [[My Todos]]

Breakdown of the Code:

dv.page(...) loads the referenced file (My Todos in this case).
.file.tasks accesses the tasks within that file.
.filter(t => t.completed).length counts the number of completed checkboxes.
.length counts the total number of tasks.
The || 0 ensures the display remains stable even if no tasks exist, preventing errors.

The Result

With this snippet in place, my dashboard now displays:

This provides a real-time overview of my task completion status without requiring manual updates.

Why This Works Well

Dynamic Updates – As tasks are checked off or added, the numbers update automatically.
Minimal Setup – No additional scripting or plugins beyond Dataview are required.
Clear Overview – Helps track progress across multiple files without opening each one manually.

Potential Enhancements

If you manage multiple task lists, you can modify the query to aggregate counts across multiple files or folders. Additionally, Dataview’s table view could be used to show progress for several projects at once.

If you use Obsidian for task management, consider implementing a similar solution to enhance visibility and productivity.

Determining the Date of Monday in the First Week of the Year

Aleksandar Sabo — Tue, 04 Feb 2025 23:00:00 +0000

I had to create a script that generates all weeks in a year and writes their start and end dates. While searching for a solution, I discovered an interesting algorithm that determines the date of Monday in the first week of the year. This seemingly simple task becomes more complex when considering international standards and varying definitions of the “first week.”

Problem Definition

The problem is straightforward:

Input: A year (e.g., 2025).
Output: The date of Monday in the first week of that year.

This isn’t as simple as selecting January 1st because the first week of the year isn’t always the one containing January 1st. This brings us to the ISO 8601 standard.

First week in the ISO 8601 Standard

ISO 8601 defines the first week of the year as the week that contains the first Thursday of the year. This is equivalent to the week that contains January 4th. According to this standard:

A week starts on Monday.
The first week of the year is the one that includes January 4th.

This means:

If January 1st falls on a Monday through Thursday, it’s in the first week of the year.
If January 1st falls on a Friday, Saturday, or Sunday, the first Monday of the first ISO week will be in the following calendar week.

Simple Solution in Any Programming Language

To solve this problem, follow these simple steps:

Identify January 4th of the given year. This date is guaranteed to be in the first ISO week.
Determine the weekday of January 4th. (0 for Monday, 1 for Tuesday, …, 6 for Sunday, depending on the language.)
Subtract the necessary number of days to get back to Monday.

Pseudocode Implementation

function getFirstMondayOfYear(year):
    jan4 = Date(year, 1, 4)
    dayOfWeek = jan4.weekday()  // Assuming 0 = Monday, 6 = Sunday
    firstMonday = jan4 - (dayOfWeek) days
    return firstMonday

PHP Implementation

function getFirstMondayOfYear($year) {
    $jan4 = new DateTime("$year-01-04");
    $dayOfWeek = (int)$jan4->format('N') - 1; // N: 1 (Monday) to 7 (Sunday), adjust to 0-6
    $jan4->modify("-{$dayOfWeek} days");
    return $jan4->format('Y-m-d');
}

echo getFirstMondayOfYear(2025);

JavaScript Implementation

function getFirstMondayOfYear(year) {
    const jan4 = new Date(year, 0, 4); // January is month 0
    const dayOfWeek = jan4.getDay() === 0 ? 6 : jan4.getDay() - 1; // Adjusting Sunday (0) to 6, others to 0-5
    jan4.setDate(jan4.getDate() - dayOfWeek);
    return jan4.toISOString().split('T')[0];
}

console.log(getFirstMondayOfYear(2025));

Using Built-in Methods in Some Languages

Some programming languages offer built-in methods to get the Monday of the first ISO week directly.

Python (Using `isocalendar`)

from datetime import date

def get_first_monday_of_year(year):
    return date.fromisocalendar(year, 1, 1)  # Year, ISO week 1, Monday (1)

print(get_first_monday_of_year(2025))

Java (Using `java.time` API)

import java.time.LocalDate;
import java.time.temporal.WeekFields;
import java.util.Locale;

public class Main {
    public static void main(String[] args) {
        LocalDate firstMonday = LocalDate.of(2025, 1, 1)
            .with(WeekFields.ISO.weekOfYear(), 1)
            .with(WeekFields.ISO.dayOfWeek(), 1);
        System.out.println(firstMonday);
    }
}

C# (.NET) Using `ISOWeek`

using System;
using System.Globalization;

class Program {
    static void Main() {
        var firstMonday = ISOWeek.ToDateTime(2025, 1, DayOfWeek.Monday);
        Console.WriteLine(firstMonday.ToString("yyyy-MM-dd"));
    }
}

Example

For 2025:

January 4, 2025, is a Saturday (day 5 if Monday=0).
Subtract 5 days from January 4:
- January 4 - 5 days = Monday, December 30, 2024.

So, the first Monday of the first ISO week of 2025 is December 30, 2024.

To find the first Monday of the year, anchor to January 4th and count backward to the nearest Monday. This simple approach works consistently across different programming languages.

Extend Hugo/Congo Theme: Adding Links to Unsupported Platforms

Aleksandar Sabo — Sat, 11 Jan 2025 23:00:00 +0000

The Congo theme for Hugo website builder, provides a convenient way to add links to your profiles on various platforms. However, you might encounter a situation where the platform you want to link to isn’t supported by default. For instance, I wanted to add a link to my Goodreads profile, but there was no built-in support for it. In this guide, I’ll show you how to add custom links to the Congo theme with minimal effort.

Important Note: This process leverages features of the Congo theme, not Hugo itself. Keep this distinction in mind as you follow the steps.

Step-by-Step Guide

Find the Icon Head over to Iconfinder and search for an SVG icon representing the platform you want to link to (e.g., Goodreads).
Download the SVG Icon Once you’ve found the appropriate icon, download it and save it to the following directory in your Hugo project:
```
assets/icons
```
Note: The icon must be in SVG format, and its filename must match the platform key you use. For example: goodreads.svg
Edit the SVG Icon Open the SVG file in a text editor or an SVG editor. Change the fill attributes value to currentColor and remove any xml metadata tags to ensure the icon will adapt to the theme’s colors. Here’s an example of a simplified SVG:
```
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
    <path fill="currentColor" d="M..."/>
</svg>
```
Add the Profile Link Open the config/_default/languages.en.toml file (or some other language file depending on your project’s configuration) and locate the params.authors section. Add an entry for the new profile link:
```
[params.author]
links = [
  ...
  { goodreads = "https://www.goodreads.com/your-profile" },
  ...
] 
```
Test the Changes Restart your local Hugo server and verify that the new link appears correctly in the profile links section of your site. The icon should display in your theme’s colors.
Repeat the steps To add links to other platforms.

This approach ensures consistency with the Congo theme’s design while allowing you to personalize your site with links to your favorite platforms. Happy customizing!

Automating Text File Encoding Conversion with Python

Aleksandar Sabo — Sun, 05 Jan 2025 23:00:00 +0000

If you’ve ever worked with text files from various sources, you’ve probably encountered issues with file encoding. For me, this problem became evident when I downloaded subtitles for TV shows that weren’t in UTF-8 encoding. All my devices are set to use UTF-8, so dealing with encoding mismatches can quickly become frustrating — especially when you have to update subtitles for your favorite TV show with 24 episodes per season and 6 seasons in total! Manually opening each file in a text editor and saving it with the correct encoding was a waste of time.

To save time and effort, I decided to create a Python package to automate the process of converting text file encodings.

The Problem: Non-UTF-8 Encodings

Subtitles for older or region-specific TV shows often come in non-UTF-8 encodings, like Windows-1250 or ISO-8859-2. While these encodings might work on most systems, they usually require switching to the correct encoding and then reverting the settings afterward. To avoid this hassle, I decided to standardize everything to UTF-8 and convert all subtitles to this format. Manually converting files every time is tedious and error-prone, so I needed a tool that could:

Handle batch processing of multiple files.
Automatically detect and process all files in a folder.
Be easy to use and configurable for different encodings.

The Solution: `change_encoding` package

The result of my efforts is a Python package simply called change_encoding. It’s designed to be straightforward and effective. Here’s what it does:

Converts all .srt files in a specified folder from one encoding to another.
Creates a separate folder for the converted files, named based on the destination encoding, preserving the originals.
Handles encoding errors gracefully, ensuring the process doesn’t break halfway.

Installation

You can install the package by cloning the GitHub repository and install it:

git clone https://github.com/SoftwareWitchcraft/change_encoding
cd change_encoding
pip3 install .

Usage

Once installed, chenc command will be available on your computer, so you can use the package directly from the command line:

chenc /path/to/folder windows-1250 utf-8

Here:

/path/to/folder is the directory containing the text files to convert.
windows-1250 is the source encoding (you can change this based on your files).
utf-8 is the target encoding.

If you don’t specify the encodings, the package defaults to converting from windows-1250 to utf-8.

NOTE: Please refer to the Python documentation for a list of all supported encodings.

How It Works

The package works by:

Scanning the specified folder for .srt files.
Reading each file with the specified source encoding.
Writing the content to a new file in the target encoding.
Saving the converted files in a subfolder, named based on the destination encoding, within the original directory (for example: in utf-8 subfolder).

Here’s a simple code snippet that forms the core functionality:

def convert_file_encoding(input_file, output_file, from_encoding, to_encoding):
    with open(input_file, 'r', encoding=from_encoding) as infile:
        content = infile.read()
    with open(output_file, 'w', encoding=to_encoding) as outfile:
        outfile.write(content)

Extending the Package

While the package is currently tailored for my needs, there’s potential for extending its functionality:

Auto-detection of source encoding: Using libraries like chardet or charset-normalizer.
Support for additional file types: Beyond .srt, the package could handle .txt or .csv files.
Recursively scanning the subfolders
…

Conclusion

The change_encoding package has simplified a tedious process in my workflow, allowing me to enjoy my TV shows without hassle. Now I can process an entire folder of subtitle files in seconds, ensuring they’re ready to use on all my devices.

If you’re facing similar encoding issues, feel free to try it out or adapt it to your needs. You can find the code on GitHub.

Track your Net Worth in Obsidian

Aleksandar Sabo — Sat, 07 Dec 2024 23:00:00 +0000

I update my net worth document every three months to assess my financial progress. I only tracked my savings and debts in the past, but this approach provided a partial picture of my financial health. For instance, my savings might increase, but I could still be losing money overall—or the reverse could happen when I make investments.

Over time, I realized I needed to track my net worth to understand my finances truly. Tracking my net worth has helped me identify trends, assess financial decisions, and focus on my goals.

In this article, I’ll explain how I track my personal net worth in Obsidian. This method is not set in stone - it’s adaptable to your needs and preferences. If you’re looking for a simple and effective way to manage your finances, this method might work for you, too.

What is Net worth?

Net worth is the difference between your assets (what you own) and liabilities (what you owe). It’s a snapshot of your financial health. Assets include things like cash, investments, property, and other valuables, while liabilities include debts like loans and credit card balances.

Tracking your net worth over time gives you a clear view of how your finances are changing. It helps you understand if you’re accumulating wealth, managing debt effectively, or losing ground. By regularly reviewing your net worth, you can make more informed decisions about spending, saving, and investing to improve your financial health.

How I track my net worth

To track my net worth I use Obsidian.

First I created a simple document with two main sections: assets and liabilities.

Assets: This section includes everything I own that has value, such as cash, investments, properties, and other valuables.
Liabilities: This section lists all the money I owe, like loans or credit card debt.

I then calculate the total value for both assets and liabilities. From there, I create four key pieces of information that are saved in the file’s tag properties:

Date: The date the snapshot was taken.
Assets: The total value of everything I own.
Liabilities: The total value of what I owe.
Net worth: The difference between assets and liabilities.

Here is the example of this file:

---
tags: note
date: 2024-12-01
assets: 525000
liabilities: 305000
net-worth: 220000
---
Parent: [[My NetWorth]]

---
## Net worth: $220.000

Total = Asset - Liabilities
= $525.000 - $305.000

---
## Assets: $525.000

cash:
- Bank: $10.000

investments:
- Awesome startup: $25.000

properties:
- home: $475.000

other valuables:
- car: $15.000

---
## Liabilities: $305.000

loans:
- $300.000

credit card debt:
- $5.000

---

Every three months, I update my net worth by duplicating the most recent file, renaming it, and entering the latest asset and liability values. This ensures I maintain an accurate and up-to-date record of my finances.

Over time, these files create a timeline of my net worth, allowing me to track financial progress and observe how my wealth changes. Using Obsidian, this system makes it easy to access and process the data programmatically, enabling simple visualization of trends and insights.

Visualizing Net Worth Timeline in Obsidian

In Obsidian, you can visualize your net worth timeline in two ways: as a table or as a chart. The table provides a straightforward view of the data, while the chart offers a more visually engaging representation.

Here’s how to set it up.

Step 1: Install Necessary Plugins

To get started, you’ll need to install two community plugins in Obsidian:

Dataview: This plugin lets you query and display data from your notes in a structured format.
Charts: This plugin allows you to create visual representations of your data with customizable charts.

To install these plugins, follow these steps:

Open Obsidian’s settings and navigate to the Community Plugins section.
Enable Restricted Mode if it’s turned off.
Use the Browse option to search for “Dataview” and “Charts.”
Install and enable each plugin.

For more detailed setup instructions, refer to the documentation on their respective websites.

Step 2: Organize Your Data in Files

In Obsidian, start by creating a folder called My Net Worth. Inside this folder, create another folder named notes, which will hold all your quarterly net worth calculations.

Each file in the notes folder should follow the naming format yyyy-mm-dd net worth.md (e.g., 2024-12-01 net worth.md). This consistent naming ensures your files are organized chronologically, making it easy to track your net worth over time.

Step 3: Create a Summary File

In the My Net Worth folder, create a summary file named My Net Worth.md. This file will serve as a dashboard for visualizing your financial progress using both a table and a chart.

At the top of the file, include the following markdown header:

# My net worth



```dataviewjs
  ... you will add your code here ... 
```

Insert the following DataviewJS code to pull data from the notes folder, process it, and generate a timeline of your net worth.

Query Notes from the notes Folder

// Get all pages from subfolder: notes
const currentFilePath = dv.current().file.path;
const currentFolder = currentFilePath.substring(0, currentFilePath.lastIndexOf("/"));

const folderName = "notes"; // Replace with your folder name
const targetFolder = currentFolder + "/" + folderName;

const pages = dv.pages(`"${targetFolder}"`).sort(p => p.date, 'asc');

Extract Data for Visualization

// Extract data from pages
const dateNames   = pages.map(p => p.date.toString().substring(0, 7)).values;
const netWorth    = pages.map(p => p["net-worth"]).values;
const assets      = pages.map(p => p["assets"]).values;
const liabilities = pages.map(p => p["liabilities"]).values;

Create and Render the Chart

// Create and render chart
const chartData = {
    type: 'line',
    data: {
        labels: dateNames,
        datasets: [
            {
                label: 'Net worth',
                data: netWorth,
                backgroundColor: [ 'rgba(33, 150, 243, 0.2)' ],
                borderColor: [ 'rgba(33, 150, 243, 1)' ],
                borderWidth: 1,
            },
            {
                label: 'Assets',
                data: assets,
                backgroundColor: [ 'rgba(76, 175, 80, 0.2)' ],
                borderColor: [ 'rgba(76, 175, 80, 1)' ],
                borderWidth: 1,
            },
            {
                label: 'Liabilities',
                data: liabilities,
                backgroundColor: [ 'rgba(244, 67, 54, 0.2)' ],
                borderColor: [ 'rgba(244, 67, 54, 1)' ],
                borderWidth: 1,
            }
        ]
    }
};
window.renderChart(chartData, this.container);

Create and Render the Table

// Create and render the table 
dv.table(
    ["Date", "Assets", "Liabilities", "Net Worth"],
    pages.values.toReversed().map(
        p => [
            p.date,
            p.assets,
            p.liabilities,
            p["net-worth"]
        ]
    )
);

Final Thoughts: Visualizing Your Financial Progress

When you open the summary file in Obsidian, you’ll see:

Chart: A visually appealing line chart displaying trends for Net Worth, Assets, and Liabilities. Each dataset is color-coded for easy identification.

Table: A detailed table showing the Date, Assets, Liabilities, and Net Worth for each quarter.

As you add more quarterly records, both the chart and table automatically update, providing an up-to-date view of your financial progress.

This setup creates a clear, visual timeline of your net worth over time, helping you easily assess your financial health and track your progress toward financial goals.

Get Started with Sample Files

To make it even easier for you to set up your own net worth tracking system in Obsidian, I’ve prepared a set of sample files that you can download and import directly into your Obsidian vault.

You can download the files here.