Compile time N-dimensional Euclidean vector.

Solving all Advent of Code challenges using C++23.

Solving Advent of Code 2022 challenges using Python as a C library.

Reading Modern C by Jens Gustedt and writing some small C apps.

Small command line app for converting Git log data to CSV and JSON. Mainly for filling a PostgreSQL database with data for local experimentation on different index combinations.

Reading The Economy and creating visualizations based on economics data with Vega-Lite.

Solutions to Advent of Code 2021, written in Rust. Implements automated downloading of problem inputs and uploading of solutions.

Screenshot shows a part of a memoized, recursive solution to problem number 21 of Advent of Code 2021.

Tiny C library for detecting bit patterns.

Self-driving bots for the Robotini racing simulator with deep reinforcement learning (RL). The deep RL algorithm used to train these bots is deep (recurrent) deterministic policy gradients (DDPG/RDPG) from the TensorFlow Agents framework.

The recording shows the RL algorithm exploring the simulator environment in real-time, driving multiple cars simultaneously by streaming actions to the Robotini racing simulator. The DDPG TensorFlow agent is running on a Linux machine with an RTX 2080 Ti, while the racing simulator is running on a MacBook Pro. Both machines are in the same local area network, communicating over TCP.

Golang solutions to Advent of Code 2020. Screenshot of a solution to the problem of day 6.

Write text on the GitHub contribution heatmap by autogenerating commits.

Each character of the input text is mapped to (x, y) coordinates, defined by the corresponding "Tiny" font glyph, and then to timestamps where x is weeks and y is days. Git commits are then generated at each timestamp to "render" the text.

Simple, stateless web backend for parsing Debian package info status files (e.g. /var/lib/dpkg/status) and rendering them as HTML. Written in Python using only standard library packages.

Risk management server and client for automatic, high frequency trading. Written in C++17 without third-party dependencies.

Exploring the C++ API of gRPC.

This project simulates a scenario where multiple clients submit high-latency tasks to a server over a gRPC streaming connection. In this example, tasks are simulated by clients sending URLs, which the server fetches asynchronously with HTTP GET requests. The server returns unique keys for each URL, which the client can use to request the actual response contents. The server runs its own thread pool to perform URL requests using libcurl. All components are implemented as Docker containers for easier dependency management and compilation.

Python toolbox built on top of TensorFlow for end-to-end spoken language identification.

I created this toolbox for automating my MSc thesis experiments at Aalto University. The toolbox aims to utilize TensorFlow as much as possible, which provides high performance feature extraction and model training pipelines for huge datasets. The largest speech dataset I used for training a convolutional neural network consisted of 3.2 terabytes of 16 kHz mono waveforms.

High-performance computing experiment, studying the feasibility of using Rust as a replacement for C++ when doing parallel computing.

The algorithm used in this example has a cubic time complexity and all performed optimizations aim to reduce the constant factors. Most optimizations focus on reducing memory access latency to increase data throughput in a small arithmetic-heavy loop. The results show that it is possible to write Rust that generates 64-bit x86 Intel code that matches the performance of C++ compiler output.

I also wrote a tutorial website which explains this experiment in more detail.

Small CUDA library for recording GPU memory access timestamps and indexes during CUDA program execution.

The recorded data is saved as JSON, which allows the user to replay the memory access pattern in the browser. The animations displayed here show two memory access patterns, where the slower one accesses memory mostly in column-major order while the faster one uses more linear reading to read full cache-lines.

Simple GPU memory simulation written in pure JavaScript.

This simulator can be used for demonstrating simple GPU performance aspects such as memory access latency, caching, concurrent execution by multiple streaming multiprocessors, and memory access coalescing.

Exploring how to deploy a stateful web service with stateless, asynchronous backend workers on Kubernetes.

CPython extension written in C++ for finding matching patterns in two texts.

This library implements the Running-Karp-Rabin (RKR) greedy string tiling (GST) algorithm. The worst case time complexity of GST is cubic, but the RKR modification utilizes hashing of subpatterns to reduce the amortized time complexity to linear.

Interactive 2D game with fluid dynamics written in C++.

Final project for an object oriented programming course. Physics provided by the LiquidFun library (based on Box2D) and graphics with the SFML framework.

Python code search engine.

Final project for a web information retrieval course. My idea is to index Python code by the string representation of its abstract syntax tree (AST). This makes all queries ASTs, which are subtrees of indexed code, allowing the usage of well-known information retrieval algorithms designed for regular text documents. This also means that variable names will not affect search results, as can be seen from the screenshot.

A result from avoiding real work for a few hours.

Exploring how to use Clojure as a backend web service.

The web service is stateless and computes shortest paths between graph nodes. In the client code, the graph is a constellation of connected satellites, orbiting a planet. Each edge denotes an unobstructed view between two satellites, which can be used for communications. The shortest path is computed from a point A on the planet's surface through these communication links to point B and highlighted in the UI.

Python library for converting programming assignment results into HTML.

Designed for Python assignments that are graded using a unit-test based test suite. This was part of a larger effort where I rewrote the grading pipeline of an algorithms course at Aalto University using Python's unittest module.