zelhajou/ft_cursus

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
• Personal Projects
• Skills
• Stats
• Blogs and Articles
• Bookshelf
• 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-09)	Objective: Master fundamental and advanced C++ concepts, OOP principles, and Standard Template Library utilization
	Implementation: Classes and objects implementation Inheritance and polymorphism Memory management in C++ Operator overloading Template programming STL containers and algorithms Exception handling Design patterns
	Technical Stack:
	Key Learnings: Object-oriented design principles Class implementation techniques C++ memory management SOLID principles 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 Progression Map

Personal Projects

42 Community Tools & Educational Resources
Project	Details
pmerge-me-visualizer	Objective: A web application that visualizes the Ford-Johnson (merge-insert) sorting algorithm
	Implementation: Step-by-step algorithm visualization Interactive controls for algorithm speed and data input Educational explanations for each phase Comparison with other sorting algorithms
	Technical Stack:
	Key Learnings: Algorithm visualization techniques Interactive data presentations Advanced sorting algorithm implementation Educational content development
42Recall	Objective: A spaced repetition flashcard application designed specifically for 42 School students to enhance their learning journey
	Implementation: Spaced repetition algorithm optimized for programming concepts 42-specific content covering the core curriculum Progress tracking and retention metrics Mobile-friendly interface for on-the-go learning
	Technical Stack:
	Key Learnings: Educational application design principles OAuth integration with 42's API Memory retention algorithms User experience optimization for learning
42term	Objective: Generate beautiful terminal-style widgets to showcase 42 school achievements on GitHub and other platforms
	Implementation: Dynamic widget generation API Custom styling options with terminal aesthetics Integration with 42 API for real-time data Multiple widget types (projects, stats, skills)
	Technical Stack:
	Key Learnings: API development and service architecture Dynamic SVG generation

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

Bookshelf

These are some of the books I've read or plan to read to deepen my knowledge in computer science, programming, and other subjects.

Name	Description	Category	Image
The Linux Programming Interface-Michael Kerrisk	A comprehensive guide to system programming on the Linux platform by Michael Kerrisk. Covers system calls, libraries, and more.	Computer System-level Programming
Advanced Programming in the Linux Environment	Explores advanced topics in Linux programming, offering insights into system calls, libraries, and techniques for efficient software development.	Computer System-level Programming
Operating System Concepts	A classic textbook on operating system principles and concepts, providing a foundational understanding of OS design and functionality.	Computer System-level Programming
Networking Essentials - A CompTIA Network+ N10-008 Textbook	Provides comprehensive coverage of essential networking concepts and technologies required for CompTIA Network+ certification exam N10-008. Authored by Jeffrey S. Beasley and Piyasat Nilkaew, this textbook offers detailed explanations and practical examples to help readers understand networking fundamentals.	Computer Networking
Computer Networks - A Tanenbaum - 5th edition	A comprehensive textbook on computer networking, authored by Andrew S. Tanenbaum, covering a wide range of networking topics including protocols, architectures, and applications.	Computer Networking
UNIX Network Programming Volume 1, Third Edition: The Sockets Networking API	A classic reference on UNIX network programming, authored by W. Richard Stevens, offering in-depth coverage of the Sockets API and various networking concepts on UNIX-based systems	Computer System-level Programming

Contact

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

---

---

© 2025 zelhajou. All rights reserved. This portfolio documentation may not be reproduced or used as a template for personal portfolios.