Forem: Oleg

Revisiting an Old Project — and the Endless Spiral of Dependencies

Oleg — Mon, 13 Oct 2025 04:50:10 +0000

I wanted to make a simple post about an old project I once worked on. And this one is not the one I intended to make.

To write the post, I needed to make a screenshot.
To take that screenshot, I had to rebuild the project.

This project is rarely touched, and it was originally started with Ant and Eclipse — when there was no Android Studio yet. No surprise the IDE didn’t like the Gradle version 5.4.1, and insisted on 8.5. This started my Saturday evening journey to make a screenshot of the app…

Gemini CLI didn’t help a lot with the upgrade unfortunately. I spend around 20 minutes with upgrade of Gradle, configuration, and library versions. This wasn’t that bad as moving from Ant to Gradle :-D

The project was now successfully built… but something wasn’t right at the runtime. So I had to debug.

Android Studio, however, decided to fight back. It wouldn’t show Java variables at breakpoints until it finished indexing all files — including every single C++ file, even the ones outside the project. I increased the IDE max heap size to 5 GB — still no luck.

Come on, Android Studio, I don’t need C++ symbols indexed; I just want to see my Java variables!

Then I realized what was taking the entire indexing effort — my boost dependency. I realized that indeed, I used boost::filesystem for file operations, and the IDE was trying to index the entire Boost library, all the headers references in the Android.mk file.

“Fine,” I thought. “Let’s just remove Boost — C++17 already has std::filesystem. I’ll update the code.”

I asked Gemini CLI agent to remove the boost dependency with std::filesystem , it immediately burned my daily quota, and actually wasn’t even half done. I replaced it rather quickly myself with grep and sed. And also upgraded the compiler to C++17… and got an error about boost/geometry, which I’d completely forgotten was also there.
So I added Boost back to Android.mk.

This time, the build failed with a mysterious message:

error: no template named 'unary_function' in namespace 'std';
did you mean '__unary_function'?

Turns out my old Boost (1.69.0) doesn’t play well with C++17. I needed at least Boost 1.75.0.
Alright — time to update Boost.

Except… the Boost website no longer offers simple source archives (as it was back in 2014). Now there are only platform-specific .tar.gz bundles for Unix & Windows. So I went to GitHub and found the boost is modularized into independent repos (with umbrella repo present that includes everything with submodules). However, the point was to use only what is necessary to reduce the burden of Android Studio indexer, so I cloned boostorg/geometry and checked out “boost-1.75.0” tag.

What I got next was:

geometry.hpp:24:10: fatal error: 'boost/config.hpp' file not found

Basically, boost::geometry depends on the boost::config. No problem, lets do the same trick with the “boostorg/config”. Then another error of missing header of other lib. I ended up cloning assert, config, core, geometry,math,throw_exception … and the list kept expanding. Nah. This would not help me much if I have to include the whole boost lib again.

What was I doing…

Eventually, I rolled back the boost upgrade changes, and decided to increase the IDE heap size to the max 8192MB, and there were no indexing anymore. Breakpoint worked, and debugger showed me variable values.

All I wanted was a screenshot.
Hours later, I finally re-assembled the project and fixed the bug, learned about Boost modular repositories on Github, and questioned every career choice I’ve ever made ;-)

Made a game in C++ no engines used

Oleg — Thu, 12 Dec 2024 11:57:01 +0000

The game I created 12 years ago, written in C++, no game engine, built for Android and iOS.

Recently I dug it from my dusty projects closet and decided to bring it back to life. To measure how much dust — let’s see what changed since then? Ant is no longer used as build system for Android, Apple released Swift and Metal (luckily OpenGL ES still works), Google released Kotlin, new IDE as well… Getting it compiling again was a challenge, but I guess this story worth a separate post. Now the game is available in the AppStore (link).

Next — I will share some insights from game development process, why it was built, what tools I used, level builders, etc.

Subscribe to not miss it

Read Committed transaction isolation in PostgreSQL

Oleg — Thu, 04 Jul 2024 15:13:47 +0000

Recently I was reading “Designing Data-Intensive Applications” book. It covers lots of topics related to creation of reliable, scalable and maintainable data systems and one of the chapter covers a concept of transactions - its meaning, use cases, levels of isolation and reasons why application developers should choose the right one. While many books and articles cover transaction isolation level with pure SQL examples for database users, I decided to go a bit deeper and check how a theory gets connected with actual implementation. As a software engineer with C++ background, it's interesting to check out the source code of one of the widely used open source databases - PostgreSQL. According to Statista it takes 4th place in most popular databases 2023. Typically first go Microsoft SQL, MySQL, Oracle and PostgreSQL.

To make the study interesting and constructive and limit the study scope, I will try to answer a question - how does transaction isolation work in general, and how database maintains READ COMMITTED isolation level in particular?

There are 4 transaction isolation levels in PostgreSQL:

DIRTY READ
READ COMMITTED
REPEATABLE READ
SERIALIZABLE

Read committed level guarantees that:

transaction will see only committed results (no dirty reads). Transaction won’t see uncommitted changes of other concurrently running transactions
writing to the database will overwrite only committed data (no dirty writes)

Let's start with some SQL code and illustrations, and then explore the source code. First create a simple table:

CREATE TABLE public.employees (
  id SERIAL PRIMARY KEY,
  name VARCHAR NOT NULL,
  surname VARCHAR NOT NULL,
);

One row is sufficient for our case:

INSERT INTO accounts ("name", "surname") VALUES ("Phil", "Smith")

Lets run the following magic query

# SELECT xmin, xmax, ctid, * FROM employees;
  xmin  | xmax | ctid  | id | name | surname 
--------+------+-------+----+------+---------
 218648 |    0 | (0,1) |  1 | Phil | Smith
(1 row)

Interesting numbers are in the response. Those are initial tuple attribute values for the inserted record of the first employee, but lets run two other transactions A and B concurrently (or sequentially for simplicity):

-- transaction A
BEGIN;
UPDATE employees SET name = "Bob" WHERE id = 1;
COMMIT;

-- transaction B
BEGIN;
SELECT name FROM employees WHERE id = 1;
SELECT name FROM employees WHERE id = 1;
COMMIT;

and run the magic query again

# SELECT xmin, xmax, ctid, * FROM employees;
  xmin  | xmax | ctid  | id | name | surname 
--------+------+-------+----+------+---------
 218651 |    0 | (0,2) |  1 | Bob  | Smith

xmin has slightly increased, and ctid has changed as well. Those are quite a clue for understanding how MVCC works. But let's take a step back and try to see what happens when those transactions run concurrently, i.e. what names become visible to transaction B.

The diagram above illustrates non-repeatable read problem with read-committed guarantee. Transaction B accesses the seemingly same row twice. First time SELECT reads the value after the transaction A executed an update on that row, but before that change was committed. READ COMMITTED isolation level prevents dirty (uncommitted) reads. Next in a timeline, transaction A commits the changes and transaction B accesses that row again. This time it will read an updated row, or actually a new tuple. By the way this may be dangerous in certain contexts, e.g. financial domain when performing the changes in account’s balance, thus for those tasks a stronger isolation might be needed.

So how does transaction isolation work in PostgreSQL?

Without concurrency control, client may see inconsistent half-written data. The way to guarantee consistent view is by introducing isolation for the requests, and the basic approach is through adding table level read-write locks, but such locks create a high level of contention between read and update transactions, resulting in very slow access. Here comes MVCC that allows concurrent read and write operations without locking the entire table. It may implement multiple levels of isolation, and Read Committed is a default one in PostgreSQL. What a particular transaction sees depends on its isolation level. With read committed level transactions see a snapshot of the database at the start of each transaction, i.e. see point-in-time consistent views. This isolation is achieved through data versioning - due to concurrent transactions there might be multiple versions of rows at a time visible to different transactions. Each row modification is associated with transaction, that either created, modified or deleted row. Each row also contains a visibility marker, indicating when row is visible and when it becomes invisible (after deletion or update). Isolation provides guarantees for concurrent data access.

How exactly does MVCC track versions?

Remember that magic query we ran and the produced results? Let's try to understand what those mean and have a look at tuple declaration in http_details.h. HeapTupleFields catches my attention because it contains t_xmin, t_xmax and t_infomask from HeapTupleHeaderData also seems an important attribute - they seem to provide tuples with the necessary versioning, visibility levels required for transaction isolation. There are more attributes of course, but these must be describing the basic cases.

typedef struct HeapTupleFields
{
  TransactionId t_xmin; /* inserting xact ID */
  TransactionId t_xmax; /* deleting or locking xact ID */
  union
  {
     CommandId t_cid; /* inserting or deleting command ID, or both */
     TransactionId t_xvac; /* old-style VACUUM FULL xact ID */
  } t_field3;
} HeapTupleFields;

From the same header I read that

t_infomask is uint16 attribute and among other things it has bits enriching the xmin and xmax values, describing whether those are COMMITTED, INVALID or FROZEN.
xmin - is used to store transaction XID, assigned at INSERT and UPDATE commands
xmax - kinda invalidating or expiring a tuple, set by UPDATE or DELETE. It might be also used for row locks

What happens when row gets updated while being repeatably read by another transaction?

Create new tuple

When a transaction updates a tuple, it actually creates a new version of it (AKA copy-on-write approach) with its own XID and New tuple's header has XMin value equal to transaction XID - 218648.

Mark old tuple for deletion

The old tuple's Xmax (Transaction ID of the last transaction to modify the tuple) is set to the XID of the updating transaction. Future transactions should not be able to see it (at least after commit). When tuple has non-zero xmax may actually have a few interpretations depending on the other flags set in tuple header (e.g. xmax is also assigned when tuple is locked for update), but for simplicity I will omit those details.

Vacuum old tuple

The Xmin and Xmax values are also used during the garbage collection process to determine which tuples are no longer visible to any active transaction. Tuples with an Xmax that is less than the current transaction's XID and when no other current transactions access the old tuple (e.g. deleted or replaced) - they can be safely removed during vacuuming.

There are more interesting things happen to the states of tuples, transactions and snapshots. For example, tuple state and its visibility is well described in heapam_visibility.c

Why don't concurrent transactions see new tuple until XID 218649 is committed?

At a start up of each transaction, one requests a snapshot object, containing information about all running transactions. Let's have a look at procarray.c file and very descriptive comment of GetSnapshotData function:

Having a snapshot object describing currently running transactions and XIDs "boundaries" is quite helpful for complying with READ COMMITTED isolation level. From the example above, no other transaction of such isolation level will see "name = Bob" until transaction 3 is successfully committed.

heapam_visibility.c seems to be the right place to look for understanding how a snapshot type impacts the tuple visibility for transaction.

Those functions rely on tuple header fields (Xmin, Xmax and a few flag values), snapshot object to determine the visibility of the tuple to other transactions.

The end

It was surprisingly fun to read PostgreSQL source code. Git blame reported that some lines were more than 20 years old. Methods frequently are well documented with comments and not only describe what a particular function does, but also conditions under which this function must be invoked, what kind of locks it uses, what optimisations were tried before, etc. For those who wants to dig deeper and explore the tuple states I recommend to start with htup_details.h.

Linux TTY on LCD 16x2 screen

Oleg — Sun, 04 Dec 2022 11:03:50 +0000

Yet another just for fun project. I decided to make use of a small LCD screen from Arduino kit & Raspberry Pi.

Inspired by historical teletype access to the computers & also challenges to use low-end tech as working setup (e.g. full day work on Raspberry Pi or Chrome books). Even today terminal is used, mostly by software developers, to run system commands for managing files, writing code, debugging, building apps, managing configs, etc. It’s sometimes surprising how much can be done by using only terminal and no fancy GUI at all.

What I want - is to use see TTY in LCD screen as if it is the only screen available.

Breadboard

There are many articles available on how to connect LCD 1602 to Raspberry Pi (e.g. this). The only component I miss is the trimpot for contrast. I replaced it with 1K Ohm resistor and contrast turned out to be about right.

Once the LCD is connected, a simple program in Python will be able to render characters. I used a program from an article as a scaffold and quickly rendered first “Hello, World!”.

TTY

TTY stands for teletype. It's a user interface device that uses text for input and output. On Linux if you run tty command, it returns user’s terminal name. The original terminals in Linux are /dev/ttyX - as I understood those are available with CTRL + ALT + F1 console.

There are also /dev/pty/ that functions as a pseudo-TTY - that acts like physical, but is not a real one. If you open a term app in Ubuntu or SSH to it and run tty command output will show it’s a pseudo-terminal.

The greatest article I can recommend on TTY - The TTY demystified. I am also looking for more resource to learn more on TTY subsystem. Any sources you can recommend?

The next task - is to read the TTY in Linux and pass it to the LCD.

I was sure there should be a way to access it and was considering writing a TTY driver for it, but came across this Reddit post that exactly what I want and mentions VCS.

VCS - man vcs - virtual console memory

Example of its contents:

$ hexdump -c /dev/vcs2
0000000
*
00001e0   R   a   s   p   b   i   a   n       G   N   U   /   L   i   n
00001f0   u   x       1   1       r   a   s   p   b   e   r   r   y   p
0000200   i       t   t   y   2
0000210
*
00005a0   r   a   s   p   b   e   r   r   y   p   i       l   o   g   i
00005b0   n   :       o   l   e   g
00005c0
*
0000780   P   a   s   s   w   o   r   d   :
0000790

What my Python program does is pretty straightforward:

continuously reads characters from /dev/vcs
renders lines on LCD screen

But entire TTY currently doesn’t fit the LCD screen, it has to be resized. stty tool helps with that:

stty cols 16 rows 2

After that the output become correct and TTY is usable.

Conclusion

I played around with terminal on such screen. Tasks such as ls that needs multiple line output are better be used in combination with less so you can conveniently scroll the content as there are only 2 rows available.

I managed to create a simple C++ program that prints Hello World, compile and run it 😀 and a few commands in Python interpreter.

Here is a short demo video:

youtube.com

References:

https://www.mbtechworks.com/projects/drive-an-lcd-16x2-display-with-raspberry-pi.html

https://www.reddit.com/r/raspberry_pi/comments/fnd8rk/full_linux_tty_on_lcd1602/