• About 42
• Curriculum Structure
• The 42 Method
• Projects by Circle
• Skills Acquired
• Statistics
• Learning Approach
• Key Takeaways

42 is a global network of peer-to-peer coding schools that revolutionizes traditional education through project-based learning. Founded in Paris in 2013, 42 has expanded to 50+ campuses worldwide, training over 25,000 students without teachers, lectures, or tuition fees.

Peer-to-Peer Learning: No teachers, no classes. Students learn from each other through collaboration and code reviews.

Project-Based Curriculum: Over 150 practical projects organized in concentric circles, from basic C programming to specialized tracks.

24/7 Access: Campus open around the clock, allowing students to learn at their own pace and schedule.

Gamification: The curriculum is structured like a galaxy of interconnected projects, with levels, experience points, and achievements.

Learn to Learn: Focus on developing problem-solving skills and adaptability rather than memorizing syntax.

The Common Core is the mandatory first phase of 42's curriculum, designed to build foundational skills in:

• C Programming: Low-level programming, memory management, algorithms
• UNIX/Linux: Shell scripting, system administration, process management
• Networking: TCP/IP, client-server architecture, HTTP protocol
• Graphics: 2D/3D rendering, raycasting, mathematical projections
• Concurrency: Multithreading, synchronization, inter-process communication
• DevOps: Docker, containerization, orchestration
• Web Development: Full-stack development, databases, real-time communication

Duration: 12-18 months (average)
Objective: Reach level 7+ to unlock specializations and internships

The 42 curriculum is organized in concentric circles (ranks), with each circle representing increasing complexity and specialization.

                               ┌──────────────────┐
                               │    Circle 06     │
                               │ ft_transcendence │
                               └────────┬─────────┘
                                        │
                         ┌──────────────▼────────┐
                         │        Circle 05      │
                         │  Inception • Webserv  │
                         │  CPP Modules 05-09    │
                         └──────────┬────────────┘
                                    │
                     ┌──────────────▼────────┐
                     │       Circle 04       │
                     │  Cub3D • NetPractice  | 
                     │  CPP Modules 05-09    |
                     └──────────┬────────────┘
                                │
                 ┌──────────────▼─────────────┐
                 │       Circle 03            │
                 │  Philosophers • Minishell  │
                 └──────────┬─────────────────┘
                            │
         ┌──────────────────▼────────────┐
         │           Circle 02           │
         │  Push_swap • Minitalk • FdF   │
         └──────────┬────────────────────┘
                    │
     ┌──────────────▼──────────────┐
     │         Circle 01           │
     │  ft_printf • get_next_line  │
     │       Born2beRoot           │
     └──────────┬──────────────────┘
                │
         ┌──────▼──────┐
         │  Circle 00  │
         │    Libft    │
         └─────────────┘

Circle 00 (Foundation)
→ C fundamentals, memory management, string manipulation

Circle 01 (Basics)
→ Variadic functions, file descriptors, system administration

Circle 02 (Algorithms & Systems)
→ Sorting algorithms, IPC, graphics, virtual machines

Circle 03 (Concurrency & OOP)
→ Multithreading, shell implementation, C++ fundamentals

Circle 04 (3D & Networking)
→ Raycasting, TCP/IP, network configuration

Circle 05 (DevOps & Backend)
→ Docker infrastructure, HTTP servers, advanced C++

Circle 06 (Full-Stack)
→ Web applications, real-time communication, databases

Students evaluate each other's work through peer evaluations. This process:

• Encourages knowledge sharing and teaching
• Develops communication and code review skills
• Builds a collaborative community
• Provides multiple perspectives on solutions

Every project solves real-world problems:

• Practical application of concepts
• Immediate feedback through testing
• No theoretical exams or lectures
• Learning by doing, not memorizing

The curriculum uses game mechanics:

• Levels: Progress from 0 to 7+ (and beyond)
• Experience Points: Gain XP by completing projects
• Achievements: Unlock badges and milestones
• Holy Graph: Visual representation of the curriculum galaxy

Students are self-directed:

• Choose when to start projects (with prerequisites met)
• Select from multiple project options at certain ranks
• Decide their own schedule (campus open 24/7)
• Learn to manage time and prioritize tasks

• Version Control: Git workflows, branching strategies, code reviews
• Collaboration: Pair programming, team projects, peer evaluation
• Testing: Unit testing, integration testing, stress testing
• Debugging: GDB, Valgrind, lldb, systematic debugging
• Documentation: Technical writing, README files, code comments
• Project Management: Task prioritization, deadline management, Agile basics

Total Projects: 16 completed
Average Score: 106/100
Bonus Projects: 8/16 (50%)
Team Projects: 5/16 (31%)
Individual Projects: 11/16 (69%)

Common Core Duration: ~18 months
Total Hours: ~2,000+ hours
Projects Evaluated: 100+ peer evaluations
Code Written: 50,000+ lines of code

C/C++:      45% (~22,500 lines)
Shell:       15% (~7,500 lines)
Python:      10% (~5,000 lines)
Config:      10% (~5,000 lines)
JavaScript:  10% (~5,000 lines)
Other:       10% (~5,000 lines)

• Individual: Libft, ft_printf, get_next_line, Born2beRoot, Push_swap, Minitalk, FdF, Philosophers, CPP Modules, NetPractice, Inception
• Team (2): Minishell, Cub3D
• Team (3): Webserv, ft_transcendence

Documentation: Official docs, RFCs, man pages, standards
Resources: Books, online tutorials, GitHub repos, Stack Overflow
Experimentation: Trial and error, testing hypotheses, iterative improvement

Peer Learning: Discussions, whiteboard sessions, code reviews
Pair Programming: Real-time collaboration on complex problems
Knowledge Sharing: Teaching concepts to solidify understanding

1. Understand: Read project requirements, identify constraints
2. Research: Study relevant concepts, algorithms, APIs
3. Plan: Design architecture, break down into subtasks
4. Implement: Write code incrementally, test frequently
5. Debug: Use tools (GDB, Valgrind), systematic troubleshooting
6. Optimize: Refactor, improve performance, clean up
7. Document: Write README, comment code, explain design choices
8. Evaluate: Peer evaluation, receive feedback, iterate

1. Low-Level Understanding: Deep knowledge of memory management, pointers, and system architecture
2. Algorithmic Thinking: Ability to design efficient algorithms and analyze complexity
3. System Design: Experience building complex systems from scratch (shells, servers, games)
4. Full-Stack Capability: Skills spanning from low-level C to high-level web frameworks
5. Tool Mastery: Proficiency with GDB, Valgrind, Git, Docker, and development tools

1. Autonomy: Self-directed learning, resourcefulness, initiative
2. Collaboration: Teamwork, communication, conflict resolution
3. Adaptability: Learning new technologies quickly, embracing challenges
4. Persistence: Debugging for hours, overcoming obstacles, never giving up
5. Peer Evaluation: Giving and receiving constructive feedback

1. Code Quality: Writing clean, maintainable, well-documented code
2. Testing: Comprehensive testing, edge cases, error handling
3. Security: Awareness of vulnerabilities, defensive programming
4. Performance: Optimization techniques, profiling, benchmarking
5. Continuous Learning: Staying updated, exploring new technologies

• 42 Network - Official 42 network website
• 42 Pedagogy - Understanding the 42 method
• Intra 42 - Student platform and project resources

C Programming:

• "The C Programming Language" by Kernighan & Ritchie
• "Expert C Programming: Deep C Secrets" by Peter van der Linden
• "C Interfaces and Implementations" by David R. Hanson

UNIX/Linux:

• "Advanced Programming in the UNIX Environment" by W. Richard Stevens
• "The Linux Programming Interface" by Michael Kerrisk
• "UNIX Network Programming" by W. Richard Stevens

Algorithms:

• "Introduction to Algorithms" by CLRS
• "Algorithms" by Robert Sedgewick and Kevin Wayne
• "The Algorithm Design Manual" by Steven Skiena

System Design:

• "Operating Systems: Three Easy Pieces" by Remzi H. Arpaci-Dusseau
• "Computer Systems: A Programmer's Perspective" by Bryant & O'Hallaron
• "Designing Data-Intensive Applications" by Martin Kleppmann

• 42 Students Slack - Global community
• GitHub 42 Network - Student repositories
• Stack Overflow - Q&A