Detailed resumé

This page contains a more detailed resumé, not only listing my experiences and skills but also describing them, how they are important and giving examples.

Personal Info

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

Academic overview

Formerly, I started other courses that I didn’t finished:

Professional overview

  • Loggi: a Brazilian logistics unicorn
    • 2020: Software Engineer Trainee
    • 2020-2021: Junior Software Engineer
    • 2021-2022: Software Engineer
  • IME-USP: Institute of Mathematics and Statistics of University of São Paulo
    • 2023-2024: Teaching assistant
    • 2024: Lecturer
  • FAPESP: The São Paulo Research Foundation
  • Google Summer of Code: Mentoring program sponsored by Google for introducing new contributors to open-source projects

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

Please note that in this section I’m covering the languages themselves, but not their ecosystems and tooling, which are covered in the stacks section.

  • 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):

  • 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):

  • 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):

  • Haskell (Competent): my favorite language, even though I’m not a specialist in it. I only used it for 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;

  • 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.

Stacks

  • Python

  • JVM

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):

  • 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 analisys

  • 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):

  • SQL (Competent):

  • TensorFlow (Novice):

Testing

  • JUnit:

  • PyTest

  • Git test suite

  • ns-3 test suite

General knowledge

  • Functional programming (Competent):

  • Algorithms and Data Structures (Competent):

  • 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):

  • 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):

Soft skills

  • Technical writing:

  • Teaching:

Languages

  • Portuguese
  • English

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.