Jakub Nenczak

A common data environment that reads your documents and writes new ones — ingest, chunk, embed, retrieve, then synthesise against a template. Every stage is containerised and independently observable.

• Built a containerised RAG backend on LlamaIndex for document chunking and metadata extraction, with each stage isolated behind its own service boundary.
• Used Qdrant — a Rust vector database — for high-dimensional similarity search, keeping k-NN latency off the request path of ingestion.
• Decoupled storage from day one: MinIO for raw objects, PostgreSQL for metadata, so write scaling and blob scaling are independent problems.
• Wired the whole pipeline into Promtail → Loki → Grafana, because a synthesis step that fails silently is worse than one that fails loudly.

• Python
• Qdrant
• LlamaIndex
• MinIO
• PostgreSQL
• Docker Compose

No framework, no library, no threads. One process, one select() loop, and up to 1024 concurrent file descriptors — all of them allowed to stall halfway through a read or a write without taking the server down.

• Bypassed every web framework and wrote the event loop and the HTTP request parser by hand in C++.
• Single-threaded, non-blocking I/O multiplexed with select(), holding up to 1024 file descriptors without a thread per connection.
• State-machine logic for partial socket reads and writes (EAGAIN), CGI execution via fork(), and memory safety under sustained stress.

• C++
• POSIX Sockets
• TCP/IP
• CGI

Resource contention with no safety net: no deadlock, no livelock, no starvation, and no thread quietly winning at the expense of another. The interesting part is not the solution — it's proving the solution holds.

• Managed OS-level concurrency directly in C with POSIX threads and hand-placed mutexes.
• Fine-grained locking on every shared resource — forks and stdout alike — so logging could not itself become the race.
• Timing verified against death thresholds, because a philosopher that eats late is a correctness bug, not a performance one.

• C
• POSIX Threads
• Mutexes

Lexing, parsing, process lifecycle, and signal handling — with exactly one global permitted, reserved for signal state. Every other piece of context has to be threaded through by hand.

• Bash-inspired shell in C: pipes, I/O redirection including heredoc and append, and environment variable expansion with $?.
• All builtins implemented from scratch (cd, export, unset, env, exit) with child execution via fork() / execve().
• SIGINT and SIGQUIT handled correctly in both parent and child contexts, with zero leaks under Valgrind.

• C
• POSIX
• readline
• fork / execve
• Signals

A convincing 3D world drawn from a flat 2D grid, one ray per screen column. Wolfenstein's trick, rebuilt: DDA traversal, fish-eye correction, and per-column texture sampling inside a tight pixel-buffer loop.

Fig. 005 — Rendered output DDA · per-column texturing

• DDA raycasting engine in C, casting one ray per vertical screen stripe against a 2D tile map.
• Perpendicular wall distance correction to remove fish-eye distortion, with directional texture mapping for N/S/E/W faces.
• Double-buffered pixel rendering through MiniLibX, plus a fully validating parser for the custom .cub config format.

• C
• MiniLibX
• DDA Algorithm
• Vector Math