Focus at 42 Prague involves rigorous memory management and algorithmic efficiency.

• Memory Management: Proficient in using Valgrind and AddressSanitizer to ensure leak-free code.
• UNIX Logic: Experience with process creation, signals, and file descriptors.
• Concurrency: Working with threads and mutexes to solve the "Dining Philosophers" and similar synchronization problems.

---

List of the projects

Note: with respect to 42 Prague's updated code-sharing guidelines, public source code sharing is forbidden.

• Libft: a project about building a custom C library to bypass environmental limits and learn core mechanics. I re-coded standard string functions and built a modular linked-list API from the ground up. The goal was to create a memory-safe, reliable foundation that I can actually rely on for future, more complex work
• Get_Next_Line: project focused on creating a reliable C function to read various streams content line by line, serving as a fundamental tool for handling data input in my future systems and network projects
• ft_printf: implementation of the standard printf (write-function wrapper) function in C, with support for various format specifiers and flags.
• Born2beroot: introduction to virtualization and system administration. I had to set up a Debian server from scratch on a virtual machine, strictly following a set of security rules—everything from configuring sudo groups and LVM partitions to setting up a strong password policy and a custom monitoring script.
• push_swap: introduction to data sorting and algorithm optimization. The goal was to sort a stack of numbers using only two stacks and a very limited set of operations: swapping, pushing, or rotating the top elements.
• minitalk: Engineered a client-server communication system using UNIX signals to facilitate inter-process communication (IPC). By utilizing bitwise manipulation to transmit data via a limited signal set, this project served as a technical foundation for handling more advanced networking and system-level synchronization tasks.
• fract-ol: an exploration of 2D computer graphics and complex number mathematics centered on the rendering of fractal sets. Utilizing the MiniLibX graphical library, this project involved implementing smooth zooming, color mapping, and interactive movement within the Mandelbrot and Julia sets. The focus was on optimizing pixel-by-pixel rendering performance and mastering the mathematical foundations of iterative functions.
• philosophers: an exploration of concurrent programming and multithreaded systems design, centered on the classic 'Dining Philosophers' synchronization problem. The project required managing multiple threads of execution and ensuring thread-safe access to shared resources. Key technical challenges included the implementation of mutexes to prevent data races and the design of a robust arbitration logic to avoid deadlocks and resource starvation within a time-sensitive environment
• minishell: a significant milestone in the curriculum involving the development of a functional command-line interpreter. This project required the orchestration of complex subsystems, including a robust lexical analyzer, a command parser, and an execution engine capable of handling redirections and pipes. Beyond the technical challenges of process synchronization and environment variable management, it served as an introduction to large-scale collaborative software engineering, requiring synchronized development through Git and shared architectural planning.
• cub3D: a project focused on the principles of ray-casting to create a dynamic 3D graphical interface from a 2D map. Inspired by the technical foundations of 1990s first-person shooters, the development involved calculating real-time line-of-sight and perspective projection to simulate depth within a maze. The implementation required rigorous input parsing, efficient image buffer manipulation using the MLX42 library, and strict memory management to ensure a high-performance, leak-free rendering environment.
• NetPractice: a specialized training project focused on the foundational principles of computer networking through the resolution of complex configuration puzzles. Across ten progressive levels, the project required the practical application of TCP/IP addressing, CIDR notation, and subnet mask calculations to restore connectivity within various network topologies. The focus was on mastering the interaction between default gateways, routing tables, and the OSI model layers, providing a rigorous introduction to network administration and systematic troubleshooting.
• CPP00-04: a comprehensive transition from procedural C to Object-Oriented Programming (OOP) in C++. This series of modules focused on the core principles of class design, including data abstraction, encapsulation, and the Orthodox Canonical Class Form. Technical milestones included mastering dynamic memory allocation through constructors and destructors, implementing operator overloading, and understanding subtype polymorphism to build extensible and maintainable software architectures.