A comprehensive collection of projects completed as part of the 42 School curriculum, showcasing progression from basic C programming to advanced system programming and software architecture.
This repository contains all my completed projects from the 42 programming curriculum. Each project builds upon concepts learned in previous projects, creating a structured learning path through fundamental computer science and software engineering concepts.
The projects are organized by difficulty level and learning objectives:
| Project | Description | Key Concepts |
|---|---|---|
| 0-libft | Custom C standard library implementation | Memory management, string manipulation, linked lists |
| 1-get_next_line | Line-by-line file reading function | Static variables, file descriptors, buffer management |
| 1-printf | Custom printf function implementation | Variadic functions, format parsing, type conversion |
| Project | Description | Key Concepts |
|---|---|---|
| 2-fractol | Interactive fractal explorer | Computer graphics, complex mathematics, event handling |
| 2-pipex | Unix pipe simulation program | Process management, inter-process communication, file descriptors |
| 2-push_swap | Efficient stack sorting algorithm | Algorithm optimization, data structures, performance analysis |
| Project | Description | Key Concepts |
|---|---|---|
| 3-minishell | Simplified bash shell implementation | Shell programming, parsing, signal handling, process orchestration |
- Memory Management: Understanding pointers, malloc/free, and memory safety
- String Processing: Implementing string manipulation functions from scratch
- File I/O: Working with file descriptors and system calls
- Function Design: Creating modular, reusable code with proper interfaces
- Algorithm Implementation: Designing efficient sorting and mathematical algorithms
- System Programming: Process creation, pipes, and inter-process communication
- Computer Graphics: Rendering mathematical visualizations in real-time
- Performance Optimization: Minimizing operations and optimizing for speed
- Parser Implementation: Building lexical analyzers and command parsers
- Shell Architecture: Creating a complete command-line interface
- Signal Handling: Managing system signals and process control
- Software Architecture: Designing maintainable, modular systems
- C Programming: Advanced C with strict coding standards (42 Norm)
- Makefiles: Build automation and dependency management
- Git: Version control and repository management
- Unix/Linux: System programming and command-line proficiency
- Data Structures: Arrays, linked lists, stacks, trees
- Algorithms: Sorting, searching, recursive algorithms, optimization
- Memory Management: Dynamic allocation, leak prevention, pointer arithmetic
- System Programming: Process management, file operations, signal handling
- Computer Graphics: Pixel manipulation, mathematical visualization, event-driven programming
- Modular Design: Clean separation of concerns and reusable components
- Error Handling: Robust error checking and graceful failure handling
- Code Organization: Well-structured projects with clear hierarchies
- Documentation: Comprehensive README files and code comments
- Testing: Thorough testing strategies and edge case handling
The shell implementation required integrating all previously learned concepts into a cohesive, complex system with:
- Multi-stage parsing pipeline
- Process orchestration and signal handling
- Memory management across multiple modules
- Unix shell compatibility
The fractal explorer combined mathematics and graphics programming to create:
- Real-time mathematical visualizations
- Interactive user controls and smooth animations
- Multiple fractal algorithms (Mandelbrot, Julia, Burning Ship)
- Color palette systems and visual effects
The sorting algorithm project focused on efficiency and optimization:
- Minimizing operations through algorithmic analysis
- Multiple sorting strategies for different input sizes
- Performance benchmarking and optimization techniques
- Custom algorithm design and implementation
- Total Projects: 7
- Lines of Code: ~10,000+ (estimated)
- Languages Used: C (primary), Makefiles
- External Libraries: MLX42 (graphics), custom libft implementations
- Coding Standard: 42 Norm (strict C coding standards)
Each project directory contains its own README with specific compilation and usage instructions. To explore a project:
- Navigate to the project directory
- Read the project-specific README.md
- Compile using the provided Makefile
- Follow the usage examples
cd [project-directory]
make
./[executable] [arguments]- � No memory leaks: All projects pass valgrind checks
- � Error handling: Robust error checking and recovery
- � 42 Norm compliance: Follows strict coding standards
- � Modular design: Clean, organized code structure
- � Full feature implementation: All mandatory requirements met
- � Bonus features: Additional functionality where applicable
- � Edge case handling: Comprehensive testing and validation
- � Performance optimization: Efficient algorithms and resource usage
This collection of projects demonstrates proficiency in:
- Low-level Programming: Direct memory management and system calls
- Algorithm Design: Custom implementations of fundamental algorithms
- System Architecture: Designing complex, multi-component systems
- Unix Programming: Process management, signals, and file operations
- Graphics Programming: Real-time rendering and interactive applications
- Software Engineering: Clean code, documentation, and testing practices
The 42 School curriculum emphasizes:
- Peer Learning: Collaborative problem-solving and code review
- Project-Based Learning: Practical application of theoretical concepts
- Self-Directed Study: Independent research and problem-solving
- Industry Standards: Real-world programming practices and tools
Each project was completed following the 42 methodology:
- No external libraries (except where specified)
- Strict coding norms and standards
- Comprehensive error handling
- Peer evaluation and code review
This repository serves as a portfolio of my 42 School journey and demonstrates the progression from basic programming concepts to advanced system design. Each project represents significant learning milestones and practical application of computer science fundamentals.
This repository represents my personal journey through the 42 curriculum and showcases the practical application of computer science concepts through hands-on project development.