Hey! 👋

This is where I keep all my coding projects from my time at 42. I'm studying at 1337 (part of the 42 Network) and I'm learning everything from scratch - starting with C programming and working my way up to building entire web apps.

What makes 42 different is there are no teachers and no lectures. Instead, you figure things out on your own, work on real projects, and learn alongside other students. Every project has to go through peer reviews (we call them "corrections") before you can move forward. It's intense, but it's a great way to learn how to code and solve problems.

In this repo, you'll find my progress through the whole curriculum - from basic stuff like coding my own C library to more complex projects like building web servers and creating full-stack applications. Each project taught me something new about computer science and software development.

Table of Contents

• 📚 Curriculum
• 🚀 Projects
  • 💻 Core Programming Fundamentals
  • 🐧 Unix & System Programming
  • 🔍 Algorithms & Data Structures
  • 🎨 Computer Graphics
  • 🌐 Network Programming
  • 🧩 Object-Oriented Programming
  • ☁️ DevOps & Cloud
  • 🏗️ Full-Stack Development
  • 🏆 Achievement Summary
• 🗺️ Project Progression Map
• 🛠️ Skills
• 📊 Stats
• 📝 Blogs and Articles
• 📞 Contact

Curriculum

The 42 curriculum is structured like a galaxy of projects, organized in concentric circles from basic to advanced:

Inner Circle (Common Core)

• Begins with fundamental C programming
• Projects increase in complexity as you progress
• At certain points, you can choose between different projects:
  • For example, between graphics projects (FdF/fract-ol) or Unix projects (minitalk/pipex)
  • Some levels offer multiple project options, where you only need to complete one to progress
• All mandatory phases must be completed to finish the common core -Required for activities like internships and student exchange

Outer Treks

• A collection of diverse project trails available after the inner circle

• Covers various specialization areas:

  • Operating Systems
  • Web Development
  • Graphics
  • Network & System Administration
  • And more...

These tracks allow students to specialize in their preferred areas of software development and computer science.

Note: The Holy Graph visualization above maps the complete curriculum structure. The turquoise nodes indicate completed projects, while grey nodes represent projects yet to be tackled. Each connection line shows the prerequisites needed to unlock the next project, with some levels offering multiple paths to choose from.

Projects

The following table lists the projects I've completed as part of the 42 Cursus. Each project is linked to its repository, where you can find the project's description, requirements, and my implementation.

Core Programming Fundamentals

Foundation Phase
Project	Details
libft	Objective: Create a custom C library implementing standard functions and additional utilities
	Implementation: Memory functions (malloc, free, memset, memcpy) String operations (strlen, strcpy, strcat, split) List management (linked list creation and manipulation) Character utilities (isalpha, isdigit, toupper, tolower)
	Technical Stack:
	Key Learnings: Low-level memory management Data structure implementation Pointer manipulation Code modularization
ft_printf	Objective: Recreate the printf function with core format specifiers and various flags
	Implementation: Format specifiers (%c, %s, %p, %d, %i, %u, %x, %X) Flag handling (width, precision, alignment) Buffer management for efficient string handling Error detection and input validation
	Technical Stack:
	Key Learnings: Variadic functions implementation String formatting algorithms Type conversion techniques Memory optimization strategies
get_next_line	Objective: Develop a function that reads lines from file descriptors
	Implementation: File descriptor handling and management Static variable utilization Buffer management and optimization Memory leak prevention
	Technical Stack:
	Key Learnings: File operations and I/O handling Memory management techniques Static variable usage Buffer optimization strategies

Unix & System Programming

System Administration & Process Management
Project	Details
Born2beroot	Objective: Set up and configure a secure Linux server with strict rules
	Implementation: System administration and security setup User and group management Service configuration (SSH, UFW, sudo) System monitoring script development
	Technical Stack:
	Key Learnings: Linux system administration Security policy implementation Service management System monitoring and maintenance
Minitalk	Objective: Create a client-server communication system using UNIX signals
	Implementation: Signal handling (SIGUSR1, SIGUSR2) Bit manipulation for data transfer Client-server architecture Error handling and recovery
	Technical Stack:
	Key Learnings: Inter-process communication Signal handling mechanisms Binary data transmission Process synchronization
Philosophers	Objective: Solve the dining philosophers problem using threads and mutexes
	Implementation: Thread creation and management Mutex implementation for resource control Deadlock prevention strategies Performance optimization
	Technical Stack:
	Key Learnings: Concurrent programming concepts Thread synchronization techniques Resource sharing management Race condition prevention
Minishell	Objective: Create a basic shell interpreter similar to bash
	Implementation: Command parsing and lexical analysis Process creation and management Built-in command implementation Signal handling and environment management
	Technical Stack:
	Key Learnings: Shell program architecture Process control and execution Environment variable handling Collaborative development

Algorithms & Data Structures

Algorithm Implementation & Optimization
Project	Details
Push_swap	Objective: Develop an efficient sorting algorithm using two stacks with limited operations
	Implementation: Custom sorting algorithm development Stack data structure management Operation sequence optimization Algorithm complexity analysis
	Technical Stack:
	Key Learnings: Algorithm optimization techniques Stack operations and manipulation Time complexity analysis Problem-solving methodologies

Computer Graphics

Graphics Programming & Visualization
Project	Details
Fract-ol	Objective: Create a graphical program to explore and render various fractals
	Implementation: Fractal rendering algorithms (Mandelbrot, Julia) User input and event handling Color mapping and gradients Zoom and navigation features
	Technical Stack:
	Key Learnings: Graphics programming fundamentals Complex number mathematics Event-driven programming Optimization techniques
Cub3D	Objective: Develop a 3D game engine using raycasting techniques
	Implementation: Raycasting algorithm implementation Map parsing and validation Texture mapping and rendering Player movement and collision detection
	Technical Stack:
	Key Learnings: 3D graphics fundamentals Linear algebra application Game physics basics Team collaboration

Network Programming

Network & Protocol Implementation
Project	Details
NetPractice	Objective: Master network configuration and TCP/IP fundamentals
	Implementation: IP addressing and subnetting Network topology design Routing configuration Network troubleshooting
	Technical Stack:
	Key Learnings: Network architecture principles IP addressing schemes Subnet calculation Network diagnostics
Webserv	Objective: Build an HTTP/1.1 compliant web server from scratch
	Implementation: HTTP protocol implementation Socket programming and I/O multiplexing Request/Response handling CGI execution and configuration
	Technical Stack:
	Key Learnings: Web server architecture HTTP protocol internals Non-blocking I/O Team collaboration

Object-Oriented Programming

Modern C++ Development
Project	Details
CPP Modules (00-04)	Objective: Master fundamental C++ concepts and OOP principles
	Implementation: Classes and objects implementation Inheritance and polymorphism Memory management in C++ Operator overloading
	Technical Stack:
	Key Learnings: Object-oriented design principles Class implementation techniques C++ memory management SOLID principles
CPP Modules (05-09)	Objective: Advanced C++ concepts and Standard Template Library utilization
	Implementation: Template programming STL containers and algorithms Exception handling Design patterns
	Technical Stack:
	Key Learnings: Advanced template techniques STL container usage Error handling strategies Generic programming concepts

DevOps & Cloud

Container Orchestration & Deployment
Project	Details
Inception	Objective: Set up a complete containerized web infrastructure using Docker
	Implementation: Multi-container application setup Docker network and volume configuration Service orchestration (NGINX, WordPress, MariaDB) Custom Docker image creation
	Technical Stack:
	Key Learnings: Container orchestration Service configuration management Network security implementation Infrastructure as Code principles

Full-Stack Development

Web Development & Real-Time Applications
Project	Details
ft_transcendence	Objective: Create a full-stack web application featuring real-time multiplayer game and social features
	Implementation: Single-page application development Real-time game and chat system OAuth 2.0 authentication RESTful API design Tournament and matchmaking system
	Technical Stack:
	Key Learnings: Full-stack application architecture Real-time communication protocols User authentication and security Database design and management

Achievement Summary

Project Statistics

Exam Achievements

Project Progression Map

Skills

🔧 Programming & Development

• Languages: C, C++, Bash, HTML/CSS, JavaScript
• Core Skills: Memory management, data structures, algorithms, OOP
• Tools: Git, Make, Docker, GDB, Valgrind
• Environments: VSCode, Vim, Emacs, Linux, macOS

💻 System & Network

• System Programming: Process management, IPC, threading, memory optimization
• Network: Socket programming, HTTP/TCP/IP, web server development
• Security: System hardening, SSH, firewall configuration, authentication

🎮 Graphics & Mathematics

• Graphics: Raycasting, 3D rendering, game physics, collision detection
• Mathematical: Fractal computation, complex number operations, optimization

🐳 DevOps & Web

• Containerization: Docker, service configuration, container orchestration
• Web Development: Full-stack applications, REST APIs, WebSockets
• Databases: PostgreSQL, MariaDB, data modeling

🛠️ Professional Practice

• Development: Code review, documentation, debugging, testing
• Collaboration: Team projects, pair programming, project management
• Problem Solving: Algorithm design, optimization, architectural planning

Stats

42 Stats

GitHub Stats

Blogs and Articles

These are some of the blogs and articles I've written about my experiences at 42 and other topics related to computer science and programming.

• Building the 42-School Minitalk Project: A Guide to UNIX Signal-Based Communication in C

Contact

Feel free to reach out to me if you have any questions, suggestions, or just want to chat!

---