Emmanuel Guefif

This platform allows an amateur astronomer to register, get email notifications when a Gamma-Ray Burst is detected by the Fermi satellite and post observations.

The backend is written with FastAPI/Postgres and the Frontend is in Vue.js.

The application is hosted on Scaleway. I use Docker Swarm to manage three services: Frontend serving, FastAPI backend and AlertSys. AlertSys is a Python service that monitors NASA GCN Kafka event bus. When a message is received, AlertSys sends an HTTP request to the backend. The backend registers the alert and notifies users. Postgres is hosted on its own instances. Everything is behind an Nginx.

The server's ip address is protected by Cloudflare which is used as a reverse proxy.

Goals

I created this project to learn three skills: * a simple but complete FastAPI app with: authentication, background job, dependency injection and SqlModel. * an automated CI/CD with Github Actions, Docker Swarm and Scaleway Cloud. * Domain name handling and protection with CloudFlare.

Spotlights

I am particularly proud of the automated CI/CD. I spent quite some time to make it work. Everything is pretty simple but I had trouble with Cloudflare bot filtering. When the CI passes and the docker images are built, there is a Github Action that sends a deploy request to the server where a simple FastAPI app will launch processes to update Docker Swarm services. Anytime I merge a branch on master, the new version gets automatically deployed on my server.

Lessons Learned

Thanks to this project, I have a better understanding of my current professional project infrastructure that uses Kubernetes and Google Cloud. I now know what tasks, instances, and pods represent.

I learned how to implement a secret-based authentication between the backend and AlertSys. They share a common secret and use timestamp encoding to verify authentication.

Last but not least, I learned about FastAPI. This was a great experience. The simplicity and efficiency of the framework are beautiful. It's easy to add background tasks and dependencies. My project was pretty simple. I chose to organize my app by area (users, alerts, observations). In the book I was reading about FastAPI, they organize by models, services, and controllers. Rails organizes apps by models/controllers/views. Django organizes by areas (Apps). I feel that keeping models/controllers and services in one app is what makes more sense. These three components are coupled and I find it easier to have them in one place. I don't have the experience on a big project to know what architecture design is better. This will be my next experimentation.

A basic clone of nmap written in Rust. The goal is to understand how TCP works at the packet level by crafting and sending raw packets using libpnet.

The scanner performs an ICMP pre-scan to check if the host is up, then scans the requested ports using one of five TCP scan types. Results are displayed with port state, service name, and timing — similar to nmap's output format.

Goals

• Understand the TCP three-way handshake
• Learn how raw sockets work
• Implement multiple TCP scan techniques (SYN, FIN, XMAS, NULL, ACK)
• Learn how network interfaces work at a low level in Rust
• Learn how to use Wireshark to check raw packets

Spotlights

For this project, I had to use a low-level library and craft my own packet buffers and send them via raw socket. I used Wireshark to debug what was going on when it was not working as expected. I really enjoy working low-level. I've worked on HTTP servers and this project gave me an understanding of layers 3 and 4 of the OSI model. Wireshark gave me a taste of what the Ethernet protocol looks like.

Current Status

The five scan types are implemented and working. The project is complete.

Lessons Learned

• I've learned how to craft IP/TCP/ICMP packets.
• I've learned to debug using Wireshark.
• I've deepened my understanding of Rust: ownership and enums

Goals

Build an overview understanding of Go — goroutines, channels, error handling, and basic data structures — while reviewing how DNS works and what the different record types are.

Spotlights

Concurrent domain scanning using a pipeline pattern: one goroutine distributes jobs across workers, another gathers the results. Channels are buffered to twice the size of the worker pool to avoid congestion and keep the pipeline flowing without unnecessary blocking.

Lessons Learned

Go's standard library is powerful enough to build network tools without third-party dependencies. Goroutines make concurrent request handling straightforward, and that combination explains why Go is so widely used for web services.

This was the last C project in 42 Common Core. I worked with Maxime to make this one work. We created a Ray Tracer capable of drawing sphere, cylinder, plane and triangle.

Goals

This project goals were: * Implement in C a Ray Tracer with all the maths and physics behind rendering * Use multi-threading to optimize. * Implement texture mapping on objects.

Spotlights

This RayTracer is able to draw triangles. Therefore, it can draw all figures composed of triangles. This was not the most difficult thing to do. There is plenty of literature on how to know if a ray is crossing a triangle but the end view is impressive.

Lessons Learned

The teamwork was interesting on this one. At this point in the curriculum, I was used to working with Maxime. We had already worked on a couple of projects and we knew how to do this. We were pair programming a lot and used TDD whenever we could. On this project though, pair programming didn't work. As we were understanding the maths behind that at different paces, we only figured out together how to draw a plane. When we both understood the concept behind Ray tracing, we decided to split the work. He was much better than me at understanding the maths behind. Working this way gave me some time to familiarize with the concept.