Software Engineer (follow-up)

Teads, Montpellier, France

Sept. 2024 - today

Stack: Scala, Typescript, Git, GitHub Actions, Terraform, Jenkins, AWS, Grafana & Loki, Kibana

• Finished the encoding service migration
• Finishing the cleanup
• Decommissioned unused services
• Migrated the CI/CD pipeline from Jenkins to GitHub Actions & adapted it to better match our needs
  • Allows more than one CI at the same time
  • Cached & reuse as much as possible to save CI time
  • Implemented an auto-retry / queue mechanism to cope with a GitHub Actions limitation

Assistant Software Engineer

Teads, Montpellier, France

Mar. 2024 - Aug.2024

Stack: Scala, Typescript, Git, Terraform, Jenkins, AWS, Kibana

• Migration of the service we use to encode ads from a legacy, discontinued API to a newer one. Refactored the flow, optimized SQL transactions (batch writes), and parallelized what could be. The goal was to have no downtime during the migration.
  • Double run between the old and new implementation to find discrepancies
• Began cleaning up some "legacy" parts to reduce accidental complexity and improve development speed
• A/B test-driven development

End of studies project

Conecs.io, Montpellier, France

Dec. 2023 - Feb. 2024

Stack: Rust, Advanced Encryption Methods

• POC on a privacy-preserving storage for clinical data with special encryption methods. The goal is to allow re-using & sharing data easily across multiple actors, only if the patient allows it.
• Reviewed several research papers to understand how these methods work, their use cases, limitations, risks, etc.
• Implemented a small POC with Rust:
  • Extremely CPU-efficient
  • A POC isn't used in production, so it was a nice opportunity :)

Software Engineer Intern

Scala Center, Lausane, Switzerland

Apri. 2023 - Aug. 2023

Tech: Scala, JVM, Scala-Java interop, Reflection

Improved the Scala debugger in VS Code with a new evaluation mode, using runtime reflection. It is limited to expressions that can be correctly evaluated at runtime (e.g., in the case of an overridden method, using reflection we could pick a method different from what the compiler would have chosen).

The evaluation is performed in 2 phases:

1. Validate the expression: correct syntax, evaluable using reflection. Transform the expression AST into a custom ADT representing the expression, that can later be evaluated.
2. Evaluate the expression.

This evaluation includes a pre-evaluation mode. Instead of using the compile-time type of a value, if possible we evaluate it and use its runtime type. It eases the access to runtime information during debugging.

I particularly enjoyed the compiler-related part of the project: ASTs, type checking, overload resolution, etc.

As a secondary project, I helped with the implementation of Hot Code Replacement (HCR). This means that we can now launch a debug session, change the code, and just reload the session (so we keep the "progress" made +/-) instead of restarting from the beginning.

Assistant Software Engineer

Teads, Montpellier, France

Jun. 2022 - Aug. 2022

Stack: Scala, Typescript, gRPC, React, Git, GitHub, Cypress, Jenkins

2-month internship where I worked on the V2 of their demo application. I did some backend development with Scala & the Typelevel ecosystem (Cats-effect, doobie...) followed by a more front-end part (in the end I worked on both backend & frontend at the same time).

For each feature I developed, I was responsible for the whole lifecycle: code, test, deploy, refactor, fix bugs...