The Libft project at 42 consists of recreating a standard C library
by implementing commonly used functions for handling strings, memory, numbers, and linked lists. It also includes data structures such as singly linked lists (t_list) and sometimes dynamic arrays to efficiently manage data sets.

The goal is to gain a deep understanding of memory management using malloc and free, as well as pointer and structure manipulation. This library will serve as a fundamental base for future 42 projects, enabling more optimized and reusable code.

Push_swap is an algorithmic project
that involves sorting a stack of numbers using a minimal number of operations on two stacks (A and B). The goal is to design an optimized algorithm capable of handling lists of various sizes while minimizing the number of instructions. This project challenges the understanding of sorting algorithms, memory management in C, and performance optimization.

It also helps develop skills in data structure manipulation and logical algorithm design, all while adhering to the constraints set by the execution environment.

Minishell is a project from
the 42 school that involves creating a simple Unix shell program.

The goal is to design and implement a basic command-line interface (CLI) that can execute commands, handle pipes, input/output redirection, and manage environment variables, all while mimicking the behavior of a real shell. The project focuses on handling the parsing of user input, managing processes using fork and exec system calls, and implementing built-in commands such as cd, echo, exit, pwd, env, export and unset.

Additionally, the shell must properly manage foreground and background processes, handle signals (such as SIGINT and SIGQUIT), and support process termination.

One of the key challenges is to correctly handle command-line syntax, including parsing for operators like pipes and redirections. The project also requires handling errors and edge cases in a way that ensures the shell runs smoothly.

The goal is to understand the inner workings of shells, improve skills in process management, system calls, signal handling, and memory management, while also developing a deeper knowledge of how operating systems execute commands in a shell environment.

Cub3D is a project from the 42 school that involves creating a 3D raycasting engine, simulating a first-person perspective similar to classic 3D games like Wolfenstein 3D.

The goal is to design and implement a graphical engine that can render a 3D environment based on a simple 2D map, using raycasting to project walls, floors, and ceilings onto the screen.

The project requires handling basic graphics and input management, implementing the raycasting algorithm to detect intersections with walls, and drawing textures to create a visually rich environment. This includes properly mapping textures onto surfaces based on the player's viewpoint and ensuring they scale correctly.

Additionally, the project involves parsing a map file that defines the layout of the environment, including walls, floors, and objects, and converting it into a format that the engine can understand. The engine must interpret and validate the map file, handle potential errors, and ensure a seamless experience. The project also focuses on performance optimization to ensure smooth rendering and responsiveness.

By working on Cub3D, you'll develop a deep understanding of computer graphics, 3D rendering, raycasting algorithms, user input handling, texture mapping, and file parsing, all of which are essential skills in building game engines and graphical applications.

Philosophers is a project that focuses
on solving the classic synchronization problem known as the "Dining Philosophers Problem".

The goal is to simulate a scenario where multiple philosophers, sitting at a table, alternately think and eat, but they need to share limited resources (forks) without causing deadlocks or race conditions.

The project requires designing a solution using semaphores to synchronize access to shared resources between processes and to avoid issues such as deadlock, starvation, and data corruption.

Instead of using threads, we implemented the solution using multiple processes, adding complexity in managing inter-process communication and synchronization.

This project provides a deep understanding of concurrency control, process management, and the implementation of efficient, process-safe systems, with a focus on utilizing semaphores to ensure proper synchronization between processes.

For the ft_printf project of the 42 school cursus, we must recreate the famous C library printf function.

This project teaches us about variadic arguments as well as structures if we plan to implement printf's extra flags.

Get Next Line is a project that involves developing a C function capable of reading a line, character by character, from a file or standard input. The goal is to implement an efficient reading system by handling buffers and dynamically managing memory to adapt to any file size.

This project highlights file handling, memory optimization, and pointer manipulation while adhering to strict constraints on resource allocation and deallocation.

The Inception project at 42 aims
to create a complete infrastructure using Docker to deploy multiple services such as MariaDB, WordPress, Nginx, Redis, Adminer, cAdvisor, an FTP server, etc.

Each service is containerized in isolation and interconnected through a Docker network, ensuring modularity and security.

This project helps develop skills in system administration, virtualization, and container orchestration, while following DevOps best practices.

This project provides step-by-step instructions for configuring a secure Debian virtual machine with strong password policies, SSH configuration, firewall rules, user and group management, and periodic monitoring with cron. Additionally, the project includes a monitoring script that broadcasts system status updates, helping to monitor performance and ensure the system remains secure and operational. Optional bonus implementations are also offered, including setting up WordPress with the LLMP stack (Linux + Lighttpd + MySQL/MariaDB + PHP) and an FTP server.

The goal of the project is to create a server that is able to receive and show messages from a client that you also created, using only 2 UNIX signals.

Because of this constraint, you will need to make a system that can convert the characters you want to send to a binary signal, as well as be able to construct the signal back into the character.

Solong is a 2D game project where players navigate through a maze, collecting items and avoiding obstacles.

It involves tasks like parsing map files, handling player movement, and implementing basic game mechanics using the MinilibX graphics library.

The C++42 program consists of 10 modules, numbered from Module 00 to Module 09, each designed to teach different aspects of the C++ language. These modules progressively introduce both fundamental and advanced topics, providing a comprehensive understanding of C++ programming. Each module contains a series of exercises that focus on specific concepts, allowing you to practice and reinforce your skills.

MD_00 : introduces the basics of C++, focusing on the differences between C and C++ and providing an introduction to Object-Oriented Programming (OOP).

MD_01 : covers memory allocation, references, and pointers to members, teaching you how to manage memory efficiently and work with C++-specific features.

MD_02 : dives into Ad-hoc polymorphism, overloading functions, and the orthodox canonical class pattern in C++, providing deeper insights into object-oriented design.

MD_03 : focuses on Inheritance, teaching you how to create hierarchical relationships between classes in C++.

MD_04 : covers subtype polymorphism, including abstract classes and interfaces, enabling you to design flexible and reusable code.

MD_05 : explores exceptions and error handling using try/catch blocks in C++, helping you manage exceptional conditions in your programs.

MD_06 : teaches you about type casting in C++, explaining the various types of casts and their appropriate use cases.

MD_07 : introduces templates, allowing you to write generic functions and classes that can work with different data types.

MD_08 : focuses on templated containers, iterators, and algorithms, teaching you how to create and manipulate collections of data efficiently.

MD_09 : explores the various standard containers in C++, helping you understand how to use them effectively for data storage and manipulation.

Each module is structured to build on previous knowledge, making it easier to grasp advanced C++ concepts while reinforcing the basics.

The net_practice project is our first networking related project in 42 curriculum. It consists in 10 exercises in which we should configure different small-scale networks into communicating with each other - all of them using the concepts learnt about TCP/IP addressing.

The IRC project at 42 involves developing an IRC server in C++98, following the RFC 1459 standard, to manage client connections and enable real-time message exchange.

It includes the implementation of essential commands such as /NICK to change a nickname, /USER to authenticate, /PASS for password authentication, /JOIN to enter a channel, /PART to leave a channel, /MODE to modify channel settings, /TOPIC to change the topic, /KICK to remove a user, /PRIVMSG and /NOTICE to send private or channel messages, and /QUIT to disconnect from the server.

Additionally, users can create channels dynamically by using the /JOIN <#channel> command, which automatically generates a new channel if it does not already exist.

This project focuses on low-level network programming, socket management, event handling with poll(), and adherence to the IRC protocol, providing a solid understanding of client-server communication and network protocols.

The Transcendence project at 42 is a complete web application developed with a Django backend and HTML, CSS, and Vanilla JavaScript frontend, featuring a secure and high-performance full-stack architecture. It uses an advanced DevOps configuration with Nginx, Redis, and PostgreSQL, ensuring scalability and optimized performance.

The application offers a modern user authentication system, including user management with JWT, OAuth via Google and Intra 42, as well as two-factor authentication (2FA). Features like forgot password, the ability to update personal information, block users, and add friends are also integrated. Users can personalize their profile with an avatar and track their match results in the gaming section.

In terms of gaming, Transcendence offers online games such as Ping Pong, Tic-Tac-Toe, accessible in remote mode, allowing players to compete against each other from a distance. A Ping Pong tournament system is also available. Users can view their match results and track their progress.

The application architecture is a Single Page Application (SPA), ensuring a smooth and dynamic user experience. Socket management enables real-time communication for chat and gaming. All user data is securely stored and regularly updated. The project follows DevOps best practices for efficient service management and reliable deployment, ensuring data security and performance.