Detailed resumé

This page contains is a detailed resumé. My intention here is to provide a deeper description of my experiences and skills, without the restrictions of a 2-page resumé, LinkedIn, GitHub, ORCID and so on. Here, I’m not only listing also describing them, how important they are and providing examples.

Personal Info

  • Birth: 1996
  • Location: São Paulo, Brazil
  • Citizenship: Brazilian and Portuguese
  • Gender: Male

Academic overview

Studying for a master’s degree in Computer Science

Research highlights

  • Developed GridGooseSV, a ns-3 module for simulating the protocols SV and GOOSE
  • Wrote a survey paper about Smart Grids communication simulators
  • Wrote a paper describing GridGooseSV

Selected subjects and tasks

  • Database systems: focused on DB foundations: storage, indexing, query processing and optimization, concurrency control, crash recovery
  • Network programming: focused on learning each layer of the TCP/IP model; wrote a RabbitMQ-like message broker by implementing AMQP from scratch
  • Languages and automata: focused on language theory, automata, Turing machines, regular expressions and context-free grammars

Extra activities

  • Hardware Livre: extension group focused on open-source hardware
  • LIFT: extension group focused on functional programming languages

Bachelor in Computer Science

Selected subjects and tasks

  • Network programming: focused on learning each layer of the TCP/IP model; wrote an e-mail server by implementing IMAP from scratch
  • Database laboratory: focused on SQL/NoSQL practices; developed a platform for restaurant queues
  • Agile methods laboratory: focused on Agile practices; integrated a vote analysis tool with the Brazilian chamber of deputies API
  • Algorithm analysis: time and space complexity, algorithm design paradigms, dynamic programming, greedy algorithms
  • Graph algorithms: connectivity, strongly connected graphs, vertex coloring and other concepts about graphs and their main algorithms

Extra activities

  • FLUSP: extension group focused on contributions to open-source projects
  • Hardware Livre: extension group focused on open-source hardware

Technologist in Systems Analysis and Development

Professional overview

Google Summer of Code

Google Summer of Code (aka GSoC) is a Mentoring program sponsored by Google for introducing new contributors to open-source projects

2025: Contributor to the Git source code

  • Wrote the new built-in Git command git repo
  • Worked with the Git development community, especially the GitLab Git team
  • More information in my GSoC blog

FAPESP

The São Paulo Research Foundation

2024-2025: TT-IV Technical Researcher

  • Developed a module (called GridGooseSV) for the network simulator ns-3 for implementing the protocols SV and GOOSE.
  • Wrote two papers on simulating communications in Smart Grids

IME-USP

Institute of Mathematics and Statistics of University of São Paulo

2024: Lecturer

  • Gave a 12h course about OpenSCAD, a functional programming language targeted for modelling objects for 3D printing

2023-2024: Teaching assistant

  • Programming Techniques I: evaluated tasks and helped students with Assembly language, shell scripts and build tools

  • Operating Systems: evaluated tasks and helped students with OS-related content, such as parallel and concurrent programming, memory management, process scheduling and file storage

Loggi

Loggi is a Brazilian logistics unicorn

2020-2021: Software Engineer I / II

  • Increased the coverage of the tests of the API endpoints
  • Maintained the geocoding microservice (Kotlin/Micronaut)
  • Developed internal tools for inspecting geocoded addresses using the Google Maps API, a PostgreSQL database, a Redshift data warehouse and logs indexed by Elasticsearch
  • Integrated several internal micro-services (based on Kotlin/Micronaut, Kotlin/Camel and Python/Django) with the geocoding service
  • Added special strategies for resolving addresses with different address formats
  • Added charset detection for incoming data in the EDI service
  • Presented lectures about Git, Jupyter and Pandas
  • Wrote design docs for new features

2020: Software Engineer Trainee

  • Improved the stability of the Python/Django back-end

Technical Skills

Here I classify my technical skills freely following the Dreyfus model:

  • Novice: I already worked with that skill, but I still don’t have independence and need help from other people, from documentation, from online resources and so on;

  • Advanced beginner: I have some independence and can perform simpler tasks without help, but I still need help (asking other people or trying to study by myself) to do more complex tasks;

  • Competent: I am mostly independent, I can troubleshoot, I can solve problems, I can make technical decisions and I can plan tasks that depend on that skill. However, I still need guidance on special situations and I’m still mostly guided some patterns and recipes;

  • Proficient: I’m independent on performing tasks that involves that skill and I don’t need to follow patterns or guidance. If there’s no expert in my team, probably I will be one of the people that my colleagues will ask for help;

  • Expert: I deeply understand that skill, I’m was a reference in that skill in places that I worked and, sometimes, outside them.

Here I’m not only listing thoses skills, but explaning when and how I used them, sometimes with examples.

Programming languages

  • Python (Proficient): my swiss-knife language.

  • C (Proficient): the language that I used the most during my undergratuation;

  • OpenSCAD (Proficient): OpenSCAD is my main tool for modeling objects for 3D printing, for example, this Braille generator. I gave a course divided in 6 classes, probably the first one on this subject in Portuguese;

  • Kotlin (Competent): my main language when working at Loggi, where I was in the team responsible for the geocoding microservice;

  • Java (Competent): I used Java mainly for studying Algorithms and Data Structures through the Sedgewick book;

  • Ruby (Competent): language that I use for automating tasks when the limitations of Bash become a limitation. I described its adavantages for that purpose in this blogpost, that was disseminated by the creator of the language;

  • Bash (Competent): At Loggi, I used Bash for writing Git hooks, at GSoCC I used it for writing unit tests (Git uses its own test suite written in Bash). I also use Bash scripts for automating simple tasks in Linux or Bash;

  • C++ (Competent): During my master’s research I needed to deal with the ns-3 network simulator codebase and write an external module for it. I also contributed to Marlin, a 3D printer firmware written in C++. My contributions for Marlin are listed here.

  • Lua (Competent): I learned Lua for a subject at my University where we needed to develop a game for Android. I and my team developed a brick breaker using Lua and Löve2D. I also used Lua for implementing the algorithms from the CLRS book, since Lua is 1-indexed.

  • Haskell (Competent): my favorite programming language, even though I’m not a specialist in it. I only used it in side projects, such my own rewrite of Git;

  • x86-64 assembly (Advanced beginner): I was a teaching assistant in a subject which covered x86-64 assembly using NASM syntax. I needed then to learn the basics of the languages to help the students;

  • JavaScript (Advanced beginner): a language that I know only learn the subset that I need for what I’m working on;

  • LISP family (Advanced beginner): most used for my Emacs configuration in Elisp, even though I played with Hy and Scheme. I understand the idea of this familiy of languages and I have experience with functional programming, so I’ll probably learn quickly another language of this family, such as Clojure or Common Lisp, if I need;

Code management

  • Git (Expert): Git is the tool that I most deeply understand. I contributed to its source code, wrote some blog posts about it, like this, this and this, translated to Portuguese the chapter about its internals from the official book and also rewrote a subset of Git in Haskell compatible with the official implementation. I also developed part of Git’s source code in GSoC, where I added a new subcommand to it;

  • GitHub actions (Advanced beginner): Even though I worked with projects that used other CI tools (e.g. Travis CI and CircleCI), GitHub actions is the only one that configured from scratch. One example of code base that I used GH actions was the ns-3 module that I developed during my master’s research, using multiplatform tests.

Infrastructure

  • Linux (Proficient): I’m a daily user of Linux since 2014, and it is one of my main interests as a tech professional. In 2019 I was part of FLUSP, a group of students who contributed to the Linux kernel, where I could sent some patches (listed here). I also attended two conferences on Linux: DebConf19 and LinuxDev-BR 2019;

  • Docker (Proficient): I’ve been using Docker since 2017, for reproducibility purposes (for University tasks), for running microservices locally (mainly at Loggi).

  • Kubernetes (Novice): At Loggi, our microservices were orchestrated by Kubernetes, which I started to learn.

  • AWS (Novice): At Loggi we used AWS as one of our clouds and I needed to deal directly with S3. I also completed the AWS Cloud Foundations course (badge here).

Frameworks

  • Django (Competent): I worked with Django during my undergration and while I was working at Loggi. At Loggi, I wasn’t in a team that was directly responsible of a Django-based application, however, given the horizontality of my team I needed to deal with Django-based apps from several other teams at that company;

  • Micronaut (Competent): At Loggi, our JVM-based microservices were mainly written using the Micronaut framework using gRPC/Protocol Buffers as protocols.

  • ns-3 (Competent): During my master’s research, I needed to simulate IEC61850 protocols for Smart Grids, however, there wasn’t any network simulator for that, which made me write a module for the network simulator ns-3. The source code of this module is available here.

  • Löve2D (Advanced beginner): I used Löve 2D at the university for developing an Android game;

  • Rails (Advanced beginner): During my CS course I needed to write a SaaS for controlling the attendance of grad students in seminars. I also attended a Hackathon in 2017 (HackathonUSP 2017) where my team developed a SaaS in Rails for connecting students and professors interested in scholarships.

  • Native Android (Advanced beginner): During by CS course I attended a mobile development subject, where I needed to write an Android app using Java and the Android SDK. I also wrote an Android app that gets the user’s geolocation and displays it as coordinates of a street atlas of São Paulo (source availabe here, description here)

  • React (Novice): I only learned the basics of React when I was working at Loggi.

Data science and analysis

  • Pandas (Proficient): My swiss knife tool for data analisys. At Loggi I used it to join data from databases (PostgreSQL and Amazon Redshift), Elasticsearch and external APIs for analisys and internal tools. I also used Pandas for general data analisys in academical purposes.

  • Jupyter (Proficient): Jupyter Notebook is an essential tool for data analysis. Since I use Pandas intensively, I also use Jupyter as the environment for usint it. I also have contributed to Jupyter Notebook.

  • SQL (Competent): At Loggi, I needed to use SQL for retrieving data from PostgreSQL and from Redshift. At the University, I had three subjects focused on databases, which, of course, needed SQL

  • TensorFlow (Novice): During my master’s I attended to Deep Learning classes. We were free to choose the tools, and I chose TensorFlow.

Testing

  • JUnit: I used JUnit at Loggi, for testing the Kotlin/JVM microservices;

  • PyTest: I used PyTest at Loggi, for testing the Python microservices;

  • Git test suite: Git uses its own test suite, written in shell scripts. I needed to use it when contributing to its source code;

  • ns-3 test suite: ns-3 uses its own test suite, written in C++. I used it in my master’s when developing GridGooseSV;

General knowledge

  • Functional programming (Competent): I have experience with functional programming in personal projects, but it is a subject that I’m really interested. I learned Haskell, a little bit of some Lisp flavours, and I understand a little about Category Theory and Lambda Calculus;

  • Algorithms and Data Structures (Competent): I had several classes about Algorithms and Data Structures at the university

  • Electronics (Advanced beginner): I never oficially studied electronics, but I’m interested in this topic. I assembled my own 3D printer at home and sometimes I like to fix old equipments, even if I need to spend time learning more about this subject;

  • Language and automata theory (Advanced beginner): I attended to classes on the subject during my master’s, following the Sipser book. I also have contributed to a Python library of context-free grammars;

  • Category Theory (Novice): this is a more abstract topic on Math, that I started to be interested after learning Haskell, which is a language based on its principles. Learning its basics allowed me to have a more abstract and higher-level perspective on programming;

  • Lambda calculus (Novice): another abstract Math topic that I started to be interested after learning functional programming. I wrote a quicksort using only lambda calculus.

  • Optimization (Novice): I have attended classes about Linear Optimization at the university;

Soft skills

  • Technical writing:

  • Teaching:

  • Resiliency:

  • Problem solving:

  • Ownership:

Languages

  • Portuguese: Native

  • English: Comprehends well, speaks well, reads well, writes well. All my writings in my master’s were in English, and I attended to weekly 1:1 meetings during GSoC

  • Spanish: Comprehends reasonably, speaks little, reads reasonably, writes little. I had Spanish classes in middle school, but I haven’t practiced it since them. However, I can read and understand it due to its high simlarity with Portuguese

Academic writings

Awards

  • Honorable mention in Simpósio Brasileiro de Redes de Computadores 2019 for the paper “Análise Preliminar da Detecção de Ataques Ofuscados e do Uso de Hardware de Baixo Custo em um Sistema para Detecção de Ameaças”

  • Honorable mention in HackathonUSP 2017.1: A platform that gives statistics about USP alumni

  • 3rd place in HackathonUSP 2017.1: Proton, a platform for finding students and professors interested in undergraduate research.