grzenow

Deep Neural Networks projects

Wed, 15 Jan 2025 00:00:00 +0000

This is a collection of projects completed for the Deep Neural Networks course, including:

Multilayer Perceptrons:
- Implementation of ProxyProp (Proximal Backpropagation) algorithm described in this paper.
Computer Vision:
- Implementation of several transformations, AdvProp, and SparseTopK methods.
Natural Language Processing:
- Implementation of SwiGLU and Differential Attention for a decoder-only Transformer architecture.
Reinforcement Learning:
- Implementation of Proximal Policy Optimization (PPO) and Random Network Distillation (RND) for MiniHack environments.

Allezon

Mon, 09 Sep 2024 00:00:00 +0000

Allezon is a data-collection and analytics platform, developed in a team of two. The platform handles 1000 requests per second for millions of users and products.

My role was focused on deploying the application, implementing distributed architecture with load balancing and ensuring scalability to handle high traffic efficiently.

A detailed description may be found here.

Source code

High Performance Computing projects

Tue, 25 Jun 2024 00:00:00 +0000

During the first year of master’s studies, I attended an HPC course and completed two major assignments: one utilizing CUDA and the other using MPI.

Matching in genome variant databases Link to heading

The goal was to implement a system for matching genomic variants from a file agains a database (dbNSFP). The solution consists of two phases: database indexing and matching, with the matching phase optimized using CUDA.

Logic in Computer Science

Fri, 24 May 2024 00:00:00 +0000

This is a collection of projects completed for the Logic in Computer Science course, including:

Propositional logic in Haskell (Part 1):
- Satisfiable formulas, tautologies, disjunctive normal form (DNF), DNF-based SAT solver.
Propositional logic in Haskell (Part 2):
- Conjunctive normal form (CNF), equisatisfiable CNF (ENCF), Davis-Putnam SAT solver.
SAT solving with Z3 in Python (Part 1):
- Generating all satisfying assignments, pebbling formulas, n-queens problem.
SAT solving with Z3 in Python (Part 2):
- Shortest common superstring (SCS) problem, phase transitions for the k-SAT problem.
SMT solving with Z3 in Python:
- Łoś principle, function 91, Sudoku solver.
Intuitionistic propositional logic in Agda:
- Conjunction and disjunction proofs, de Morgan’s laws, weak Pierce’s law.
Intuitionistic first order logic in Agda:
- Universal and existential quantifier proofs, relations.

Source code

Latte Compiler

Sun, 21 Jan 2024 00:00:00 +0000

One of the major projects during my graduate studies was building a compiler for the Latte language, extended with features such as arrays, structs, and objects with single inheritance. The compiler parses Latte code using the BNFC tool and compiles it into x86 assembly.

The compiler’s core is implemented using a Reader-Writer-State monad:

data Reader = Rd
 { func :: Map.Map String TType
 , clss :: Map.Map String ClassEnv
 }
type Writer = [AsmInstr]
data State = St
 { nextlab :: Int
 , newloc :: Int
 , env :: Map.Map String (TType, String)
 , rodata :: Map.Map String String
 , rspOff :: Int
 }

where

Instant Compiler

Sat, 28 Oct 2023 00:00:00 +0000

Instant is a programming language that supports two types of statements:

expression - prints the value of the expression on stdout,
variable = expression - assigns the value of the expression to the variable.

Expressions can consist of integers, variables, and arithmetic operations between them.

The goal of this project was to create a compiler from Instant to JVM and LLVM architectures.

A detailed description can be found here.

Source code

Latte Interpreter

Wed, 10 May 2023 00:00:00 +0000

One of the larger projects I did during my undergraduate studies is undoubtedly an interpreter for the simple programming language Latte.

The interpreter is written in Haskell, and the grammar is parsed into this language using the BNFC tool. The implemented functionalities are described in detail on GitHub (link below), along with numerous examples, so below is a brief overview of the implementation details.

The code of the Latte language is automatically parsed by BNFC and then passed to static type checking. The monad representing the state of the TypeChecker looks as follows:

Executor

Sat, 11 Feb 2023 00:00:00 +0000

Executor is a concurrent programming project. It is a program that executes tasks, monitors their latest outputs (during execution) and terminates them if desired.

The handling of processes has been synchronized in such a way that the Executor immediately informs about task completion and continuously cleans up finished processes or threads it creates. All of this is done without using busy waiting, ensuring CPU resources are not wasted.

A detailed task description (in Polish, though) can be found at the GitHub link below.

Sokoban

Thu, 08 Dec 2022 00:00:00 +0000

Sokoban is a puzzle game created as part of a functional programming course in Haskell.

The game was implemented in Haskell on the CodeWorld platform, where you can play it by clicking on this link.

Controls:

Space - start game
WSAD / Arrow keys - move forward
U - undo move
B - previous level
N - next level
R - reset level
Esc - reset game

Source code

Polynomial degree

Tue, 10 May 2022 00:00:00 +0000

Polynomial degree is a pure assembly project. The goal is to implement the following function

int polynomial_degree(int const *y, size_t n);

The function takes two arguments: a pointer y to an array of integers $y_0,y_1,\ldots,y_{n-1}$ and an integer n representing the length of this array. The function calculates the lowest degree of a single-variable polynomial $w(x)$ with real coefficients, such that: $w(x+k\cdot r)=y_k$ for some real number $x$, a nonzero real number $r$, and $k=0,1,\ldots,n-1$.

Pacman Rivals

Fri, 14 Jan 2022 00:00:00 +0000

Pacman Rivals is a multiplayer game developed by a team of four. It enhances the classic Pac-Man game with a mulitplayer mode and PvP mechanics.

The goal of the game is to collect as many coins as possible while avoiding contact with ghosts roaming the map. Occasionally, various power-ups appear on the map, granting the player bonuses like extra points for coins, the ability to pass through walls, invincibility, and more.

Sparse Multivariate Polynomials

Mon, 21 Jun 2021 00:00:00 +0000

This is a comprehensive project written in C, aimed at implementing fundamental operations on sparse multivariate polynomials, such as addition, subtraction, multiplication, and exponentiation.

The second part of the project is a polynomial calculator that utilizes reverse Polish notation. It allows performing arithmetic operations and displaying the current polynomial on the stack.

The implementation is optimized for efficient dynamic memory allocation, minimizing unnecessary copying and memory allocations. Additionally, the project ensures proper deallocation of all allocated memory, preventing memory leaks. The entire project is documented in Doxygen format.

Pętlik

Tue, 19 Jan 2021 00:00:00 +0000

Pętlik is a small programming language, which syntax is defined by the following grammar with the start symbol Program:

Program → InstructionSequence
InstructionSequence → ε | InstructionSequence Instruction
Instruction → Increment | Repeat
Increment → Variable
Repeat → '(' Variable InstructionSequence ')'
Variable → 'a' | ... | 'z'

Instructions:

Increment: equivalent to ++variable in C, incrementing the variable by 1.

Repeat: equivalent to a C-style while loop:

while (variable > 0) {
 --variable;
 ...
}

The project consist of two components:

Mon, 01 Jan 0001 00:00:00 +0000

Grzegorz Nowakowski Link to heading

Work Experience Link to heading

07.2025-present

Software Engineer II; Google

Developing and extending NodeOS (Google internal Linux-based OS) capabilities

08.2024-06.2025

Linux Intern; Samsung Electronics

Contributing to the development of the Tizen operating system
- Writing Rust bindings for Tizen components
- Developing Tizen C libraries
Working on operating system upgrade

07.2023-02.2024

Technology Development Intern; Point72

Developing a distributed analytical platform as part of the Risk Tech team
- Creating a standalone documentation server
- Improving the performance of the project’s core
Delivering a presentation on Rust features to the team

10.2022-06.2023

Bachelor’s Thesis Intern; ScyllaDB

Integrating Rust to the Seastar framework
- Implementing a macro similar to tokio::test
- Implementing the seatstar::submit_to function
- Exposing basic file I/O functionality
Creating a simple Seastar TCP server using C++ coroutines

Education Link to heading

10.2023-09.2025: MSc, Computer Science; University of Warsaw
Thesis title: NP-hard Metrics for Evaluating Participatory Budgeting Rules
10.2020-07.2023: BSc, Computer Science; University of Warsaw
Thesis title: Seastar as a Rust Asynchronous Runtime

About

Mon, 01 Jan 0001 00:00:00 +0000

Hi, my name is Grzegorz (Gregory in English), and welcome to my blog.

I graduated with a Bachelor’s and a Master’s degree in Computer Science. I work as a Software Engineer, and am in love with strongly-typed languages like Haskell, but don’t do it professionally.

During my education, I attended an algorithmic economics course that covered topics like coalitional game theory and social choice theory. I became fascinated by the latter, so much so that I decided to write my master’s thesis on it.

Contact

Mon, 01 Jan 0001 00:00:00 +0000

In case of any questions, feel free to concact me at: g.nowakowski.dev@gmail.com.