Skip to content

Latest commit

 

History

History
executable file
·
1230 lines (1084 loc) · 39.1 KB

README.md

File metadata and controls

executable file
·
1230 lines (1084 loc) · 39.1 KB

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

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.

42 Holy Graph

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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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

My Skills

Stats

42 Stats

zelhajou's 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.

Contact

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

Gmail Linkedin Twitter Discord Telegram Instagram

8rtdcmuc8jk51