DEV Community: Gustavo Camargo

Planes and Code

Gustavo Camargo — Wed, 02 Sep 2026 17:57:59 +0000

The original Portuguese version is available at: https://gustavocamargo.com/articles/avioes-e-codigo

"Sit down, because here comes a story!"
― Lito Sousa

During elementary school, when computers to me were basically DDTank, Habbo Hotel, and Animes Online, I had a dream very different from what I do today: I wanted to become an airplane pilot.

I even went with my mother to an aviation school in Jundiaí called Academia das Águias to get an estimate and understand what the training was like, how long it would take, and how much it would cost. I left there with a plan: when I turned 18, I would start studying for the ANAC theoretical exam.

In the meantime, I found a book about the C programming language in the library that would change my perspective on what I actually wanted to do for a living.

Now, more than 15 years later, I've been reflecting on how aviation is actually a great analogy for what we're going through...

What was flying like in the 1920s and 1930s?

In Wind, Sand and Stars, an autobiographical and memoir-style book written by Antoine de Saint-Exupéry, author of The Little Prince, he tells stories about what it was like to be an aviator in the 1920s and 1930s.

A good aviator was someone who had already crossed and mapped extremely dangerous routes, someone who understood weather and wind, and who connected with the aircraft as if they were one, because they had to make every micro-decision involved in flying an aircraft.

But above all, the book presents this as an identity. You weren't just a pilot; you were an aviator.

To this day, being an aviator is still an identity. People go to flying clubs to practice, study the subject, and improve their skills, without necessarily having a career in mind or expecting financial gains from it.

But if you want to transport 300 people to another continent, the training needs to be different.

But aviators and programmers will always exist.

What does it take to become an airplane pilot? (The big airport)

The journey to becoming a commercial pilot is divided into a few stages. First, you pass the ANAC theoretical exam and medical examinations, and then you can start taking lessons at flying clubs with an instructor. It takes around 10 to 20 hours before you can make your first solo flight.

But even then, you still can't perform paid flights.

To work professionally, you need to obtain a Commercial Pilot License and meet the required flight experience requirements.

And to reach airline aviation, the training and experience required are even greater, reaching 1,500 flight hours for an Airline Transport Pilot License.

A lot of studying and a lot of training.

What is flying like today?

In commercial aviation, pilots work alongside highly automated systems. Their role is no longer to continuously control every movement of the aircraft, but instead involves much more monitoring, automation management, and decision-making.

It is commonly said that the pilot only takes control during takeoff, landing, and when something stops working.

And when something stops working, that's when training, practice, studying, and experience come into play.

Because a pilot is capable of flying an airplane even when equipment fails, even when the autopilot stops working, and even if an engine fails.

Why doesn't a commercial pilot forget procedures after years of experience, or have a "Brain Freeze" because of the autopilot?

For this reason, airlines regularly adopt:

Recurrent training: periodic simulator sessions covering systems, procedures, emergencies, and CRM.
Emergency simulations: engine failures, fires, depressurization, windshear, automation failures, etc.
Proficiency evaluations: pilots must demonstrate that they can execute procedures and make decisions correctly.
Automation: pilots are trained to use automation, but also to take over manually and deal with failures.
Recent experience: if a pilot spends too much time without flying, they need to regain proficiency before returning to normal operations.

In other words, even with autopilot, it is important for companies to provide time for professionals to step out of autopilot mode, revisit the fundamentals, and not forget how to take control if something stops working.

At this point, I want to be even more explicit: It is very, very important that companies provide professionals with the means to prevent cognitive atrophy from constantly using a tool that can do everything with just one or two words.

What does all of this have to do with code/development?

You still need many hours of practice and experience to become a developer (especially at large companies).

Even if 90% of the work is done by an AI, that doesn't mean anyone can do the other 10%. It doesn't even mean that anyone can simply watch those 90% being done. If something goes wrong — and it will (Murphy's Law) — the person watching must be capable of directing things toward the correct path.

It is very important for companies to create mechanisms to prevent the degradation of proficiency caused by excessive use of automation.

In other words: we need moments when the autopilot is turned off.

“Maybe every 30 days we could have a few days where the use of AI was deliberately reduced.”

We love Opus, Fable, Sonnet, Sol, GLM, KIMI...

But this cannot be pushed in exchange for absolute productivity to the point where it creates the feeling that we are losing our ability — and the time — to analyze, build durable solutions, and deal with problems.

Productivity will always prevail, which is why companies need to help balance this equation.

And finally, programmers will always exist.

Everything I know about aviation comes from channels such as *Aviões e Músicas.

Lito, you are in my prayers.

Por que deixei a “empresa dos sonhos” para voltar ao ritmo de startup

Gustavo Camargo — Thu, 14 Aug 2025 17:43:42 +0000

Sim, eu saí daquele banco roxinho para voltar a trabalhar em ritmo de startup.

Nada contra ele — foi, disparadamente, a melhor empresa em que já trabalhei. Tinha um pacote de benefícios incrível e uma excelente compensation. Eu estava voando, amando programar em Clojure e entregar features para milhões de pessoas. Mas, ainda assim, faltava algo, sabe? No fundo, eu não me sentia protagonista. Sentia como se fosse apenas mais uma peça em meio a tantas outras. Sei que, para a grande maioria das pessoas, isso está tudo bem, mas eu não me sentia realizado.

Foi então que conversei com um amigo de longa data, o Rodrigo Mendes, atualmente CTO da benup, uma HRTech. E, por mais que o nicho não me atraísse tanto — afinal, eu sempre priorizei o mercado financeiro —, a filosofia e a cultura que ele estava desenhando fizeram total sentido para o que eu estava buscando.

Essa filosofia é baseada em alguns pilares:

Times enxutos: poucas pessoas no time, com autonomia para construir serviços e fluxos completamente do zero, desde o desenho até o deploy.

Simplicidade: nosso código é simples; não temos, e nem queremos ter, várias camadas para inserir um dado no banco de dados.

Modelo ShapeUp: aqui não temos backlog; temos uma mesa de apostas e um ciclo bem definido do que queremos entregar.

Tudo isso fez total sentido para o que eu procurava. Se tem algo que me irrita no desenvolvimento é board e microtarefas. Em um time sênior, todos sabem o que precisa ser feito e como será feito. É uma cultura de alta responsabilidade que eu valorizo muito. Em apenas dois meses, já entreguei muito mais do que em um ano, e isso não por excesso de trabalho, mas pela realização no que faço e pela estrutura enxuta, que elimina caminhos e ritos desnecessários e foca na entrega.

Não estamos fazendo nada inédito aqui: o WhatsApp processa 50 bilhões de mensagens por dia e possui apenas 32 engenheiros.

Se você quer saber mais sobre a benup, pode conferir o nosso blog e fique à vontade para se inscrever na nossa posição em aberto.

Calling Clojure from Java using a real example (Clojure + Quarkus)

Gustavo Camargo — Tue, 01 Oct 2024 17:52:02 +0000

The challenge

Last weekend, I decided to explore more about how Clojure can interact with the existent Java ecosystem, the challenge was simple:

Create a simple web framework in Clojure using the Quarkus framework as a base.

Premises:

The Quarkus does not know what will be executed by route, even not how many routes exist.
I should be able to create routes and handlers using Clojure as simply as possible:

(defn send-hello-world [] "Hello World")

(defn routes [] [{:method "GET"
                  :path "/hello" 
                  :handler send-hello-world}])

Some definitions:

Quarkus: Quarkus is a full-stack, Kubernetes-native Java framework made for Java virtual machines (JVMs) and native compilation, optimizing Java specifically for containers.
Clojure: Is a dynamic, general-purpose programming language

Step 1: Creating a Quarkus app

It is very easy to start an app in Quarkus you can follow this tutorial, as you can see your last command will be quarkus create && cd code-with-quarkus after that you can open the folder code-with-quarkus with your favorite IDE, the command created the basic structure of a Quarkus app, and you can run with quarkus dev

Step 2: Enable the project to recognize clj files

You need to configure Quarkus to include .clj files in target folder (The folder with your compiled app), and you can do it by adding this configuration in pom.xml inside <project>

<resources>
        <resource>
            <directory>/</directory>
            <includes>
                <include>*.clj</include>
            </includes>
        </resource>
    </resources>

Step 3: Create Clojure file

As I mentioned earlier, I defined one structure to declare my routes, in the same location of the folder main. Then I created a folder named quarkus_clj with a file called core with the code below:

(ns quarkus-clj.core)

(defn send-hello-world [] "Hello World")

(defn routes [] [{:method "GET"
                  :path "/hello" 
                  :handler send-hello-world}])

Step 4: Enabling Quarkus to handle my Clojure program

Here is where the magic happens 🎩🪄!

First of all, you should install the Clojure inside your Quarkus app; you can do it by adding a dependency in pom.xml

<dependency>
      <groupId>org.clojure</groupId>
        <artifactId>clojure</artifactId>
        <version>1.11.1</version> 
</dependency>

Now, you can delete the file GreetingResource.java and its tests. In the same place, create a file Starting.java

I write some comments explaining how it works

@ApplicationScoped
public class Starting {
    //Setup app routes
    public void setupRouter(@Observes Router router) {
        // Load Clojure core;
        IFn require = Clojure.var("clojure.core", "require");
        // Load quarkus-clj.core namespace
        require.invoke(Clojure.read("quarkus-clj.core")); 

        // Load the route list function
        IFn routesFn = Clojure.var("quarkus-clj.core", "routes");

        // Invoke the function with no parameters
        PersistentVector routesVector = (PersistentVector) routesFn.invoke();

        //For each route in routes vector 
        for (Object route : routesVector) {
            /**Get the route map, example
            {:method "GET"
             :path "/hello" 
             :handler send-hello-world}
             */
            PersistentArrayMap routeMap = (PersistentArrayMap) route;

            //Get :path value
            String path = (String) routeMap.valAt(Clojure.read(":path"));
            //Get :handler function
            IFn handlerRoute = (IFn) routeMap.valAt(Clojure.read(":handler"));
            //Get :method value
            String method = (String) routeMap.valAt(Clojure.read(":method"));
            //Create a handler to exec handler function
            Handler<RoutingContext> handlerFn = (RoutingContext context) -> {
            String result = (String) handlerRoute.invoke();  
            context.response().end(result);
        };
            //Config the route in quarkus
            router.route(HttpMethod.valueOf(method), path).handler(handlerFn);
        }
    }
}

Now you can just run: quarkus dev open your declared route and see the result!

Conclusion

This was a quick example of how to use Clojure inside a Quarkus app to create dynamic routes. With just a few steps, we connected the two ecosystems and set up a basic routing system. Feel free to expand on this foundation and explore other possibilities with Clojure and Quarkus!