John Jr

The Reflection on My First Year at Meta

blog@johnjr.dev (John Jr) — Fri, 05 Jun 2026 13:09:41 -0400

Disclaimer: Everything here is just my personal opinion, and this text does not reflect any opinion of my employer. Also, feel free to disagree with me on anything here; again, this is just my personal opinion and reflects my experience.

Before I talk about my first year at Meta, I think it is worth first discussing how I arrived here. I haven’t applied for any job at Meta. Since around 2019, I have received many emails from recruiters about positions there. At the beginning of 2024, I aced the interviews, but I didn’t join the company. At that moment, your interview’s results were valid for 1 year, and I took the entire year to make my decision. Then, I decided to join in January 2025 and started in May 2025.

Binary Search

blog@johnjr.dev (John Jr) — Thu, 11 Dec 2025 13:11:25 -0500

One of the most fundamental algorithms that appears in interviews at big tech companies is Binary Search. Of course, nobody will ask you to implement binary search directly. However, as Jon Bentley cited in his famous book Programming Pearls, only a small percentage of people he asked—10% to be precise—were able to code this algorithm without any errors.

Here, I will show you a correct implementation of binary search, its variants that appear in interviews, and LeetCode problems that you can solve using these techniques.

Builder Design Pattern and Cyclomatic Complexity Reduction

blog@johnjr.dev (John Jr) — Mon, 10 Nov 2025 10:00:00 -0500

In this post, I will explain in detail how I used the builder design pattern together with the bit mask field technique to reduce complexity. As a result, I decreased the cyclomatic complexity from 24 to 0 and reduced development time from hours to minutes.

The rest of this post is organized as follows sections:

The problem explains the problem I was solving.
Creating the bit mask field presents a solution to the problem.
Cyclomatic Complexity discusses cyclomatic complexity and calculates this metric for the solution presented in the section above.
Builder design pattern explains the builder design pattern and describes the refactoring process that removed complexity.
Conclusion summarizes this post.
References provides references related to the topics discussed here.

All the examples shown here are in C++.

Composition, Inheritance, and Liskov Substitution Principle

blog@johnjr.dev (John Jr) — Tue, 22 Apr 2025 11:27:45 -0400

In software development, organizing our codebase in a way that is easy to maintain is always a good practice, and this idea is not new. Actually, I think this started in 1968 when the term software crisis was coined. Since then, we have developed many principles to help us achieve this goal. One person who has made many contributions to this field is Barbara Liskov. She is very famous for the Liskov Substitution Principle (LSP), but she also invented the Abstract Data Type(ADT), which is the core concept of classes and object-oriented programming. Here, I want to discuss composition compared to inheritance and how understanding the Liskov Substitution Principle can help you develop better software.

Improving legacy code: Using Task Queue to Speed Up a Crawler in an ETL Process

blog@johnjr.dev (John Jr) — Mon, 10 Feb 2025 14:07:06 -0500

In this post, I will present how I improved an ETL process to be more than 4x faster using the same resources. While the old architecture used Python threads, the new one used task queue architecture to be more reliable and scalable. So, I will explain how we can improve a legacy code and speed it up by only modifying the architecture to run the code.

Almost 10 years ago, I was hired to improve a system and train a team of engineers in Python and scalable systems. The company had an ETL process to provide financial information for the finance team. The ETL was composed of the crawler, the parser, and the normalizer. The crawler’s primary responsibility was crawling finance data on our partners’ websites, which were protected by a username and password. The parser converted CSV, HTML, and JSON data and saved the result in our intermediate database. The last step, the normalizer, summarized the data using some keys and sent it to the system where the finance team could access it.

Is CPython Faster Without the Global Interpreter Lock(GIL)?

blog@johnjr.dev (John Jr) — Wed, 17 Jul 2024 12:40:06 -0400

The Global interpreter lock(GIL) is a mechanism in CPython implementation to ensure only one thread is running at a time. This means that even if we use threads to try to speed up our programs’ runtime, this will not work because, in the end, the interpreter will block that two or more threads will be executed in parallel.

As the name suggests, the GIL is a locker that a thread gets when it starts and releases at some moment. There is only one locker, so two threads cannot get it simultaneously. As a result, our program with threads will be slower than the same program without threads because of the time to create threads and not take advantage of them. However, this is true only for CPU bound problems, which requires a large amount of CPU time to process, like inverse matrix. For I/O bound problems, CPython releases the locker as soon as an I/O call happens. We still have only one thread running at once on the CPU, but now, a thread does not block other threads while waiting for the I/O result.

Lua Scripts Are Not Atomic in Redis

blog@johnjr.dev (John Jr) — Mon, 08 Apr 2024 14:15:00 +0000

Redis is an in-memory data structure store, very powerful, with an excellent abstraction via its API to manipulate its data structure. What makes Redis very powerful, in my opinion, is the variety of data structures it provides and the performance of its operations. This last feature is an effect of being an in-memory store.

As with every software, Redis also has technical decisions and limitations that we need to be aware of and consider when choosing it. In this post, I will not describe a technical limitation but a poor documentation description of one feature.

Improving the check if an object is in a Set/HashMap data structure in Ruby by using better comparisons, memoization, and object orientation practices

blog@johnjr.dev (John Jr) — Mon, 13 Mar 2023 14:04:03 -0400

I was verifying the performance of an endpoint in an API using framegraph when I noticed that checking if an object is in a set or a hash data structure was consuming a lot of time. This post explains the problem and the solution to it.

First of all, checking if an object is in a Set or HashMap is O(1) when we don’t consider collisions. Even in the presence of collisions, it should be much less than O(n), where n is the number of items in the set. Otherwise, we are operating as a linked list.

Peopleware: Productive Projects and Teams

blog@johnjr.dev (John Jr) — Mon, 07 Nov 2022 22:51:26 -0500

First things first, this is a classic book by Tom DeMarco and Timothy Lister that everyone working in the software industry must read.

The third edition divides this book into 6 parts with 39 chapters and 249 pages. It is an easy book to read and follow. However, it is necessary to stop constantly to reflect on the facts and ideas presented. Also, the reading would be like a map of the industry if you had a lot of experience in the software development industry. By this, I would like to say that many, maybe all, of the ideas presented in the book are implemented in all software-based companies I have seen.

Why Is Atomicity Not Enough?

blog@johnjr.dev (John Jr) — Wed, 11 May 2022 10:29:19 -0400

When we study transactions in relational databases, one of the first things we learn are the guarantees that a transaction must provide. ACID(Atomicity, Consistency, Isolation, Durability) are the properties that we desire. Here, I will discuss the Isolation level in more detail and show that atomicity alone is not enough when handling concurrency.

One classic example of the importance of atomicity is moving money between accounts. So, imagine that we have two accounts and we would like to transfer the total amount from one account to another one. In a relational database, what we need to do is three steps:

Quicksort

blog@johnjr.dev (John Jr) — Thu, 22 Jul 2021 15:54:55 -0400

The Quicksort algorithm was created by Tony Hoare in 1961 and it is a very powerful algorithm to sort an array in memory until today. Here, I will describe the Quicksort algorithm, show an implementation in Python, and analyze the time complexity of this algorithm in the worst and best scenarios.

The idea behind the Quicksort is so simple: to sort an array \(V\) of \(n\) elements, it is easier to sort smaller sub-arrays of \(V\). We can think of this approach as divide-and-conquer, where we break a problem into smaller sub-problems and combine their solutions to form the solution to the original problem.

Designing Data-Intensive Applications: Review

blog@johnjr.dev (John Jr) — Tue, 20 Jul 2021 10:02:04 -0400

Disclaimer: Don’t read this review, go ahead and read the book, it will be much better for you. The only reason that I wrote this is for my future reference.

First of all, I love to read books and I do not believe that a review should influence someone to read or not a book. However, as a researcher, one of the most important things that I learned during my years at the university was the importance to write a review of papers. After reading a paper, we should write a review. Not to publish, but to describe in our words what we read and also to future references. So, do not expect here a complete resume of the book or the concepts present in it. Also, do not think that this is a replacement or a complement of the book, it is not. This book is fantastic and you should read it if you like this subject.

Chrome with selenium, python and docker

blog@johnjr.dev (John Jr) — Mon, 16 Sep 2019 09:15:55 -0400

Sometimes, when I execute the Chrome inside a docker container I receive the error below:

selenium.common.exceptions.WebDriverException: Message: unknown error: Chrome failed to start: crashed

It is caused because Chrome uses the /dev/shm to share memory and the docker, by default, set 64MB for this partition.

Here, I will describe how to reproduce this error and how to resolve it.

How to reproduce

To reproduce this error, we need to create a docker image with chrome and python. Then, I created this Dockerfile which uses a multi-stage build to install the chrome and the python.

Identifying Paragraphs

blog@johnjr.dev (John Jr) — Wed, 29 Mar 2017 17:00:19 -0500

I’m learning computer vision and I’m using the Opencv and Python to write algorithms in this field of computer science. This field is very interesting because it involves computer science and math and also, it is necessary to have good ideas to solve problems.

Here, I will show my first algorithm in computer vision. It is to identifies paragraphs in a text image. It consider that the image have a white background and that the characters have a black color.

Resources in Operational Research

blog@johnjr.dev (John Jr) — Sun, 26 Feb 2017 09:42:04 -0400

I wrote a list of operational research resource which contains many name of books, events, groups, solvers and teachers. I publish this list here. It is a github’s repository and you can help to update :-)

I wrote it based on the list, wrote by Avelino, about resources for go programming language.

Callbacks in Cplex

blog@johnjr.dev (John Jr) — Sun, 08 Jan 2017 16:48:25 -0500

Callbacks in Cplex

I used LazyConstraintCallback to implement a Branch and Cut algorithm with CPLEX, but when I implemented and run this algorithm, it was very slow if I compare it with its version that doesn’t use callbacks in Cplex. The reason is because ControlCallback(LazyConstraintCallback is a ControlCallback) switch Cplex to sequential mode by default and turn off dynamic search. I wrote this post, because I didn’t find this information in Cplex’s documentation, I only found it in this technical forum.

About me

blog@johnjr.dev (John Jr) — Mon, 01 Jan 0001 00:00:00 +0000

I’m John Jr, an Applied Mathematics and Software engineer with many years of experience.

I hold a Master’s Degree (M.Sc.) in Computer Science, specializing in Operations Research, with a focus on Combinatorial Optimization and Optimization under uncertainty. I also hold a Bachelor’s Degree (B.Sc.) in Applied Mathematics, where I explored the fundamentals of Math and Computer Science.

In academia, I conducted research on Network Design problems, including Robust Shortest Path and Tree Hub Location problems.

MCS

blog@johnjr.dev (John Jr) — Mon, 01 Jan 0001 00:00:00 +0000

I have a Master Degree in Computer Science (MCS) at Departamento de Ciência da Computação (DCC), Universidade Federal de Minas Gerais (UFMG). During my MCS, I have worked with two interesting NP-Hard optimization problems. I studied, the Robust Shortest Path Problem (RSP) and the Tree Hub Location problem (THLP). The former relies on a Shortest Path problem where uncertainties are considered over the arc costs. The latter is a network design problem where one looks to locate hubs in a tree backbone in order to reduce the routing total costs.