Mouad Kimdil

// About

I started at the systems level — building a Unix shell from scratch in C, writing an HTTP/1.1 web server in C++ without networking libraries, implementing thread-safe concurrency simulations. That foundation taught me how operating systems, processes, memory, and networking actually work beneath the abstractions.

Today I build backend applications with Java, Spring Boot, Hibernate, and PostgreSQL. I focus on clean architecture, database performance, and writing code that scales. I still approach every problem the same way: understand the layer beneath.

// Projects

• Order Management API JavaSpring BootHibernatePostgreSQL

  GitHub ↗ Details

  Production-style backend REST API built with Java and PostgreSQL. Focus on clean architecture, scalability, and database performance.

  Overview

  RESTful API for managing products and categories. Built with Spring Boot 3 and PostgreSQL. Implements full CRUD operations with pagination, validation, and centralized error handling.

  Architecture

  Standard layered architecture: Controller, Service, Repository. DTOs decouple the API contract from the persistence model. Manual entity-to-DTO mapping keeps the service layer in control of what gets exposed.

  Key Features

  Product CRUD with SKU and name uniqueness enforcement. Category management with cascade validation. Pagination with configurable page sizes. Request validation using Jakarta Bean Validation. Global exception handling via @RestControllerAdvice.

  Technical Highlights

  DTO Projection via JPQL constructor expressions to avoid fetching full entities for list views. JOIN FETCH to prevent N+1 queries when loading products with categories. @BatchSize for collection batching. Time-ordered UUIDs for index-friendly primary keys. @Transactional(readOnly = true) on all query operations.

  Performance

  Generated and queried 100,000+ PostgreSQL records. Used EXPLAIN ANALYZE to study query plans. Optimized with DTO projections to reduce column fetching and JOIN FETCH to eliminate N+1 queries.

• Webserv C++

  GitHub ↗ Details

  HTTP/1.1 compliant web server built from scratch. No external networking libraries. Raw sockets, manual HTTP parsing, custom I/O multiplexing.

  Architecture

  Single-threaded event-driven architecture. Cross-platform I/O multiplexing via epoll (Linux) and kqueue (macOS). NGINX-style configuration with virtual host support.

  HTTP Parsing

  Manual parsing of request lines, headers, and bodies. State-machine-based chunked transfer encoding handling. URL decoding for percent-encoded characters.

  Sockets & I/O

  Raw socket programming with getaddrinfo, bind, listen, accept. All sockets set to O_NONBLOCK. Connection state machine tracks each client through read, process, write, and keep-alive phases. Partial writes tracked and retried.

  Virtual Hosts & Routing

  Multiple server blocks on the same port resolved by Host header. Longest-prefix location matching for route resolution. Custom error pages per server block.

  Key Challenges

  Building a correct HTTP parser from scratch, handling partial reads and writes in non-blocking mode, implementing keep-alive with proper connection lifecycle management.

• Minishell C

  GitHub ↗ Details

  Unix shell implementing pipelines, redirections, heredocs, and logical operators. Everything built on fork, execve, pipe, and dup2. No system() or popen().

  Parsing

  Quote-aware tokenization using character masking — bytes inside quotes are negated, making operators invisible to the splitter. Operator precedence encoded through split order: | binds tighter than &&, which binds tighter than ||.

  Execution

  Pipeline execution via fork and pipe. Each command gets its own process with stdin/stdout wired through dup2. Built-ins run in the parent when alone, in forked children when part of a pipeline.

  Redirections & Heredocs

  >, >>, < handled via open() and dup2(). Heredocs collected into temp files (immediately unlinked after open), with optional $VAR and $? expansion. Ambiguous redirect detection for unset or multi-word variables.

  Signals

  Custom SIGINT and SIGQUIT handlers. Ctrl+C at prompt redisplays the line (exit status 130). During execution, SIGINT terminates the child. Ctrl+\ ignored at prompt, kills child during execution (status 131).

  Built-ins

  echo with -n flag, cd with PWD/OLDPWD tracking, env, export with += append support, unset, exit with numeric status validation.

• Philosopher C

  GitHub ↗ Details

  Concurrency simulation of the Dining Philosophers problem. Implements thread synchronization, mutexes, and deadlock prevention.

  Overview

  Classic concurrency problem simulation where philosophers alternate between thinking, eating, and sleeping while sharing forks. Two implementations: multithreading with mutexes and multiprocessing with semaphores.

  Threading Model

  Mandatory part uses pthreads with one thread per philosopher plus a dedicated monitor thread for death detection. Each fork protected by a separate mutex. Three additional mutexes guard the death flag, print serialization, and meal state.

  Deadlock Prevention

  Even-numbered philosophers lock the right fork first, odd-numbered lock left first — breaking circular wait. Single philosopher edge case handled separately. Even IDs get a staggered start to prevent immediate contention.

  Synchronization

  Real-time death detection via gettimeofday with millisecond precision. Monitor thread continuously checks last meal time against time_to_die. All state transitions logged with timestamps under mutex protection.

  Bonus — Multiprocessing

  Uses fork() with named semaphores (sem_open) and C11 atomics. Each philosopher is a separate process with its own monitor thread. Custom exit codes used as IPC mechanism to signal death or completion back to the parent.

// Stack

// Interested In

• Backend APIs
• Software Architecture
• Distributed Systems
• Framework Internals
• Performance Engineering
• Database Optimization

// Journey

My learning path started with C, building a Unix shell and a concurrent simulation from scratch. That led into operating systems — processes, threads, signals, forks, pipes, and memory management. From there I moved into networking, then built an HTTP server in C++ to understand the protocol at the wire level.

That foundation made the transition to Java and Spring Boot natural. I understood what the framework was abstracting. From there I went deeper into Hibernate and database performance, learning how ORMs translate to SQL, how persistence contexts work, and how to optimize queries.

Today I focus on software architecture, designing clean, testable, and maintainable backend systems — while continuing to study the internals of the tools I use.

// Contact

Let's build something together.

Open to Backend Software Engineering internships and graduate opportunities.

• mouad.kimdil7@gmail.com
• LinkedIn
• GitHub