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.

This project started as a question on Claude. I was struggling to understand an article about Alias XOR mutability. I asked Claude if writing an async runtime would help me understand this concept. Apparently, it does not.

I asked what could be a better project. As a teacher, I know that we cannot learn something if we don't have the prerequisites. I kept asking until I filled the gap between my current knowledge and what I aimed for. I ended up with a complete plan toward Rust mastery. It's composed of projects and book references.

This is a generative AI plan. One could think this is not reliable. Here comes the best part. It is my job to check if the plan is good or not and to improve it. This work of analyzing what the plan is with regard to my experience is the most beneficial aspect of this project. In the end, I learned Rust in a way that will last.

Goals

I created this project to learn six skills: * Iterator in Rust * Parsing * Memory allocation * Smart Pointers * Asynchronous programming in Rust * Concurrency in Rust

Spotlights

For what I have done so far, the JSON parser was very interesting. It's not my first time doing a JSON parser, but this time I managed to do it with a simple and easy to use interface.

Current Status

The iterator part is done. The JSON parser is almost done. I still have to write the serialization logic.

It's on pause while I am working on Advent of Code 2025 in Rust.

Lessons Learned

Writing the iterator struct, I learned about lifetime management. The collect-like logic taught me about generics, lifetimes and associated types.

This was my first Rust project. I first emulated the CPU, then the clock, the interrupt and finally the Pixel Processing Unit (PPU). I've learned so much about the interaction of the machine and low-level programs that handle interruptions.

Goals

I created this project to learn three skills: * Rust programming fundamentals including ownership, borrowing, and the type system * Computer architecture and low-level programming concepts through hardware emulation

Spotlights

I am particularly proud of getting Tetris to run fully playable. Achieving this milestone required implementing accurate CPU instruction execution, proper timing cycles, correct PPU behavior for tile-based graphics, and synchronized screen refresh rates. Seeing the iconic Tetris pieces fall smoothly on the screen for the first time was incredibly rewarding and confirmed that all the core systems were working together correctly.

Current State

The emulator is only able to render Tetris correctly. Other games do not work. I need to rework the PPU emulation to allow other games to work. The sound is not working either.

Lessons Learned

This project was a deep dive into low-level programming. I learned about memory representation, machine architecture, assembly and clocks. I also learned a lot about reading others' code. There isn't much documentation about how the GameBoy works. Most of the emulator authors are electronics geeks who reverse-engineered the chips and wrote the emulator. The documentation is in their code. It was insightful.

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.