Marimo is an open-source reactive notebook for Python. Traditional Jupyter notebooks have a hidden state which often leads to incoherence among cell states and reproducibility issues. Marimo solves this problem by representing the notebook as a directed acyclic graph which allows for reactively updating any downstream dependencies.

⊕Demonstration of an embeddings scatterplot. The marimo cell below displays datapoints reactively depending on the current selection in the plot.

This is the first major open-source project that I have contributed to. There is an incredible learning factor to it as the project is actively maintained and people constantly review and constructively criticise every pull-request.

Contributions

Recently I made an observation on attentional bias when encountering new words: after being presented with a new word for the first time, I see it everywhere from that point on, including in the books that I read. Usually I unconsciously memorise the sentence it appears in, which helps me tremendously remembering its meaning in the long-term.

Lex is an NLP tool which was developed around this observation. Its goal is to facilitate exhaustive vocabulary acquisition. Given a new book that I’m about to read, Lex selects all words that I do not know yet by referring to a reference vocabulary. It then contextualises them, i.e. for every new word it finds the surrounding context. This allows me to learn new words before reading a book.

Link to GitHub repository

This project focused on implementing and training two models for neural machine translation from scratch: the lexical attention model as described in Nguyen and Chiang (2017) and a basic implementation of the Transformer architecture and the multi-head attention mechanism according to Vaswani et al. (2017).

The models were trained on German-to-English data.

Link to repository

This project focused on learning how to take models proposed in research papers, often represented by 5-10 equations, and putting them into use for a simple downstream task.

The form of the English predicate depends on the subject of the sentence. “The pen are on the desk” is incorrect, there is no number agreement. The task is to have a model predict the predicate form (singular [VBZ] or plural [VBP]) based on all words preceding the predicate.

This project involved the implementation and training of two models. Recurrent neural networks (RNNs) are inherently well-suited for this task due to their ability to learn long-range dependencies. As they suffer from the vanishing gradient problem, the Gated Recurrent Unit (GRU) variant was implemented for comparison.

The models were adjusted for the agreement task and trained on a small set of training data in the following form:

Back-propagation-through-time was used for training, with varying lookback values. The results were promising given the limited amount of data used for training:

Link to repository

This project implemented various RL algorithms from scratch using OpenAI’s gym environment for training and evaluation of agents.

Link to repository

⊕This project was part of a recurring University course and its codebase can thus not be published. Please contact me if you are interested in further details about its implementation.

This project implemented three small experiments using the official Linux kernel.

The first experiment focused on implementing a custom aging scheduling policy, a scheduling technique where there is an increase in priority as a process is waiting for runtime. This is used to avoid starvation among processes.

The second part involved experimentation with the memory subsystem of Linux. First a shared memory kernel module was implemented to facilitate shared memory usage among different user application. This was achieved by using a character device and memory mapping. In the second step, a custom memory analyser collects and prints various memory statistics in the following format:

root@linux-exp:/proc/1# cat memstats
Virtual Memory Area Stats:
    Total VMAs: 152
    Biggest VMA Size: 66973696
    Readable VMAs: 148
    Writable VMAs: 42
    Executable VMAs: 27
    Shared VMAs: 0
    Private VMAs: 152
    Locked VMAs: 0
    Executable Image VMAs: 26
    Page 23
    File Backed VMAs: 130
    Anonymous VMAs: 22

Physical Pages Stats:
    Total Physical Pages: 2978
    Number of Pages Swapped Out: 0
    Read-Only Pages: 2839
    Writable Pages: 139
    Number of Shared Pages: 0
    Number of Special Pages: 1
    Number of Huge Pages: 0

The third experiment involved manipulating filesystem functionalities. First a read censor was implemented, censoring certain strings present in a file upon read if it was tagged with a special xattr key. Second, filtering functionality for the output of running ls was implemented. Depending on the xattr tag of the listed directory, certain file types are omitted from the output (such as regular files, directories, character devices, symlinks,…). This was achieved by amending the ls system call in the Linux source code.

Website redesign for ericjanto.com with a focus on minimalism and a brutalist, text-only and monochrome presentation.

This involved extensive research into table design beforehand, collected in an are.na channel.

⊕One of the main benefits is that it allows for extensive use of marginalia.

Further research went into digital document layout. This led to a custom article layout using the ideas demonstrated by Edward Tufte’s books and handouts.

⊕Layout design of the new website featuring side notes.

This is the first year no framework was used for the implementation. A custom static-site generator was built with a single dependency on Pandoc to convert Markdown to HTML.

Link to project

⊕This project was part of a recurring University course and its codebase can thus not be published. Please contact me if you are interested in further details about its implementation.

This project implemented an advanced search engine for the Archive of Our Own (AO3). The AO3 comprises a vast collection of fan fiction, 502GB in size with ~15 million documents written in English, with an average length of 2600 terms.

The priority was to allow for fast look-up times of ranked documents given the user query. This was achieved by using a positional inverted index along with td-idf ranking.

⊕Overall system architecture of the search engine.

Technical report