Monthly Recap - 2025-12 December

December was a very nice wrap up for the year, in which I could get a lot more done than in previous months. Big changes, lots of catching up, and an overall bump in productivity. While not everything is yet perfect, it certainly helped to improve morale.

Achievements

Back to personal studies

First off, after a long stretch (almost half an year!) without being able to focus on personal studies, I was finally able to get back to it. While I am not entirely back to my normal pace, I made a lot of progress in both books I am working through, and put some time into it most weeks. I am almost finishing Rich Dad, Poor Dad now.

Blog posts

I was also able to set aside some time during the holidays to write several blog posts I had been planning to. These were all based on projects I undertook in the last three months of the year, but that I was too busy to document.

Here they are:

• Projects Curriculum For Learning Programming Languages
• Learning Golang
• Project: Catcher Server

Attending TDC

December is usually the month in which The Developers' Conference (TDC) has its Porto Alegre edition. This year was no different, and fortunately I was once again able to attend it in person. This is the third year in a row that I do this, and it is always one of my favorite times of the year.

Just like last year, this edition was smaller than the normal version of the event. While last year it followed the "AI Summit" format (which I highly dislike), this time it used the "TDC Experience" format, which I found better than the AI one, but still not as good as the full version. The event took place in a different venue from the classic Uniritter campus - while I liked the space (inside the Barra Shopping), I felt it had a less distinct atmosphere. Nevertheless, this time I was able to attend it together with other colleagues from my company and even my team, so it was overall a great and pleasurable experience.

The talks themselves focused more on seeing AI through a more mature and seasoned perspective, keeping the high expectations while starting to recognize and analyse several of the possible pitfalls it offers. I think this shows the "growing up" of the software development ecosystem with regards to this technology, and I only wished my company was at this stage as well - unfortunately, we are only now getting into the "starry-eyed adolescent" phase, a good 3 years behind the whole world.

Downpoints

While there were no major negative points this month, I do feel I am not yet fully back to speed, after all the chaos of changing jobs and moving to a new place. There are several days in which I still get stuck with some minor problem to solve and can do no useful work. Thankfully, these have been getting rarer lately.

Plans for next month

January is usually a month to plan things and set up new routines. The only thing I am mostly convinced I will be focusing on for next year is improving AI skills, so I expect to already get started with some of that. But mostly it will be coming up with a solid plan for 2026.

Monthly Recap - 2025-11 November

After several chaotic months, in November things finally started to settle down a little. While it was still far from my normal, I was able to put some time working on things I wanted to do, and had some nice achievements. Here's a quick summary.

Achievements

Programming language learning projects

For a long time I wanted to create a personal curriculum of projects to develop in order to become proficient in any new programming language. Having gone through the process of learning Go during the second half of this year led me to finally do this. I created a list of ten projects which get progressively more complex and cover most of the essential programming concepts. I have made this personal curriculum open source on Github, and wrote a blog post about it.

Go learning projects started

I immediately started applying the previously mentioned curriculum to my learning of Go. I am slowly working through it, and so far the experience has been really great. I can already feel the benefits, as I feel way more confident developing software in Go now than when I started. I am keeping the projects in private repositories on Github, as for now I do not see the value in making them public - this might change in the future.

Catcher server project

This month I also published another new open source project, catcher-server. It is a simple Python web server that logs to the console information about any request it receives, useful for debugging and validating applications that make outbound requests. The need for something like this came when I was working with microservices and a very new platform which does not have full observability capabilities yet - while I could look for existing alternatives, I thought the scope was perfect to have some fun and vibe code plus open source a simple project. The combination worked pretty well! I have also written a blog post about it.

Downpoints

Personal studies blocked again

While November allowed me to dedicate some time to work on personal projects, it was not yet enough to fully get back with personal studies. It has been a rough year, and I have been blocked on this front for several months already.

Plans for next month

Get back to personal studies

I expect December to continue the trend of things getting less chaotic, and with that to have more time to focus. One of the main things I expect to get back on track is my personal studies habit, as it has suffered tremendously already this year.

Project: Catcher Server

Every now and then, while building and gluing together different pieces of a system, I run into the need for exactly one thing: a tool that will tell me, in the most direct way possible, what a given service is sending out as an HTTP request. No frills, no mystery, no surprises... just give me everything, and don't ask questions.

This is precisely the itch that catcher-server was built to scratch. It's a minimal open source HTTP server designed with only one job in mind: to receive any HTTP request, on any endpoint, and log clearly to the console its method, endpoint, and payload. You throw requests at it, it logs them. That's all there is to it.

Why did I build it?

The motivation came from real needs in my day-to-day work. I was working with a new platform at my job, dealing with limited deployment and observability capabilities. When you are working in such an environment, the quickest way to validate and debug what is happening is often to set things up locally. So, rather than guessing at what my services were really sending, or trying to wade through partial logging and indirect clues, I wanted something that would display the complete truth about outgoing requests, with zero ceremony.

You might reasonably ask why not look into one of the many alternatives out there. The answer is simple: I wanted something I could run locally, that would be mine, with zero licensing or learning curve to think about. Just something I could launch instantly, trust, and forget.

Vibe Coding

There's another reason why I consider this project relevant. It is a great example of a good use for vibe coding. Catcher-server is not a polished product for broad public consumption, but rather a practical and friendly tool, spun up to fulfill a personal/internal need. Projects like these are perfect for a more relaxed, collaborative coding session, especially when working with AI tools to speed up the boring parts. I see vibe coding as an ally for prototypes, utilities, and experiments - fast, fun, and effective in their scope, even if not suited for rigorous software that needs to last forever.

Under The Hood

True to its spirit, catcher-server is built on Python with Flask. That's it: no frameworks or engines beyond what is needed. The idea was to keep everything as simple as possible. No clever tricks or fancy abstractions, just a straight line from incoming HTTP requests to the console log.

Use Cases

While I personally used catcher-server for a microservices project, the intention is broader: it's meant for debugging, testing or observing outgoing HTTP requests from any project. If you want to get the real payload, headers, or query params from your code, without distractions, catcher-server is here for you. It isn't opinionated, and it isn't limited to any domain. Point your requests at it, and it will always catch them!

Conclusion

Catcher-server is the kind of tool I like to have at hand: minimal setup, instant feedback, and the freedom to use and adapt it however I want. It's not going to change the world, but it just might prevent some early gray hairs!

Links

Source code: Github

Learning Golang

This year marked a significant shift in my professional journey as I transitioned to a new team, where Go stands as the primary programming language. As someone who hadn't previously engaged with Go, these past months have been a deeply immersive learning experience. In this post I will briefly share some of my thoughts about this process.

It's particularly pertinent to consider this journey amidst the current, somewhat chaotic, integration of AI into every facet of software development. It offers a valuable opportunity to pause and reflect on what it truly means to acquire new skills in an era where some people claim AI makes all skills obsolete.

My Learning Trajectory 

My approach to learning any new subject, especially a programming language, typically involves a structured path. While often a single video course suffices, I added a few more steps in this case. I began with the official language tutorial, followed by a full video course, and, finally, embarked on a series of personal projects to solidify my understanding.

Official Tutorial 

The initial step involved working through the tutorials on the official Go programming language website. This proved effective for environment setup and familiarizing myself with the core code-build-run cycle. My exploration here was primarily foundational, extending only slightly beyond the "Hello World" scope.

Udemy Course 

After gaining a basic grasp of project bootstrapping, I sought a more in-depth, structured resource. For years, Udemy has been my go-to platform for professional development in software. Thankfully, I found out that Maximilian Schwarzmüller offered a "The Complete Guide" course covering the language. Having completed several of his courses previously, I had high confidence in the quality, and I wasn't disappointed. Though perhaps less comprehensive than some of his other offerings, it provided a robust foundation in the language's fundamental concepts and constructs.

Projects 

While a thorough video course usually equips me sufficiently, in this instance, I felt the need for more. This followed from a confluence of factors: Go not being my immediate choice for personal applications, its less-than-intuitive aspects, and the workplace emphasis on AI-generated code over manual development. All of this motivated me to deepen my learning through practical application.

That is when I created a list of 10 application projects to develop in the language, which would progressively make me exercise more and more complex concepts. I have wanted to create such a "curriculum" for a long time now, so this was the perfect opportunity to do so. I tried to frame the projects in a way that could be used for almost any language, and put the list in a public Github repository. I also wrote a blog post about it.

Challenges 

AI

Artificial Intelligence undeniably offers substantial productivity gains in our field. However, the prevailing directive from upper management to uncritically deploy AI-generated code introduces significant challenges, particularly concerning knowledge acquisition and retention.

When your only incentive is to push out as much code as possible, as quickly as possible, it is easy to not put the effort (and time) into learning new things. If it seems to mostly work most of the times for the things you already know, you end up assuming it will also work when you do not know enough to make a judgement on what it is producing. But the catch here is in the "most" and "mostly" part: there are very significant and problematic cases in which you need to use your judgement to override something the AI made. If you are using AI to ship something in a language you do not know, you are not able to do that.

My approach has been to use AI as dictated while at work, and while creating things for personal use that I already know deeply how they work. But to avoid as much as possible relying on it while I am learning something new - I try to write all new code by myself, researching when I do not know how to do something, and only resorting to generated code when I am at an absolute loss. I then use generative AI models to analyse and evaluate my final implementation, asking it to give tips about best practices and where I could improve. I believe this approach not only preserves the learning benefits of a pre-AI era but also augments them, maximizing the value derived from this new technology. It is a shame that it is so hard to communicate this to the highest level of management at companies, these days.

Overlapping 

Another challenge I found is the fact that I do not see myself using Go for my personal projects. The language seems to overlap a lot with other languages (mostly Java, also some Python and JavaScript) that I already master and that work perfectly fine for me. I feel like I have to put conscious effort to choose Go as the main language for any new project I might start, and I am not sure how sustainable this is in the long run.

Thoughts So Far 

Overall, I find Go a pleasant language to work with and considerably simpler to learn than I anticipated. While it is definitely not my favorite language (not by a long shot), and I don't foresee continued investment in it beyond my current professional requirements, it effectively serves its purpose, generating optimized executables with minimal overhead.

Error Handling Code Everywhere

One aspect of the language that I find slightly weird is how much error handling code it needs. I do not know if this is just a skill/experience issue, but having seen code for fairly seasoned Go developers I am inclined to conclude that it really is intrinsic to the language. It feels like half of every Go source code file I read consists of "if err != nil".

While I do appreciate the safety that this might bring to programs, it still makes the code feel slightly uglier than in other languages, to me.

Dependency management

The only other point that I find disconcerting is Go's dependency management mechanism. Coming from a Java and JavaScript background, I am used to having solid, unambiguous and strict manners of declaring and managing your dependencies. Go's approach feels very idiosyncratic and flaky, and at least once per month I have very experienced Go developers telling me to run some arcane command to "just fix your vendoring" without being able to explain what the command is actually doing.

Projects Curriculum For Learning Programming Languages

While learning the Go programming language, I did something I have been wanting to do for a long time and created a short "curriculum" of projects to develop when learning a new language. The idea of this curriculum is to progressively expand one's understanding of how to do several common programming tasks in the desired language, and should be agnostic enough to work for almost any language.

I made this list public in a Github repository, and in this post I will briefly describe the reasoning behind it and introduce the initial set of projects.

Reasoning 

For many developers, embracing new programming languages is an intrinsic part of the professional journey. While some may comfortably settle into a familiar stack, the evolving technological landscape often rewards those who frequently broaden their linguistic horizons.

While it is possible to become reasonably proficient by fumbling your way around, especially if you already know a very similar language, the results are better when you apply deliberate effort to the learning journey. A mixture of understanding the concepts and getting your hands dirty creating something with the language works the best. This curriculum covers only the second part, you should first have taken a short course or read the basic tutorials of the language to get the concepts and theory.

My initial list has 10 projects, starting from the simplest behavior possible (logging some text to the console) and ending with an application to fully manage a resource. Along the way, it exercises programming constructs, interaction with the filesystem and exposing a service through HTTP requests.

By following this sequence and implementing each project, one can acquire a robust intuition for tackling the vast majority of tasks encountered in any language. This gives the confidence to then use the new language effectively for any project requirement.

A Note On Perspective 

This list is heavily shaped by my own experience, as someone who has mostly developed for the cloud and desktop, and with a backend focus. It might not cover several things that are important for frontend, mobile and AI/ML development.

The Projects

I created a public Github repository with the list of projects, and I intend to enrich their descriptions and refine the list as insights emerge from using it.

Here is the initial list, with a short description of what each project contributes:

1. Hello World

Classic first program in any language, just print out the message "Hello World" to the console. This makes you understand how to set up, build and run a project in this language.

2. Current day and time greeting

Print to the console a short greeting informing the current day and time. This allows you to learn how to use the standard library of the language, move away from hardcoded values to start using variables, and string formatting.

3. Guess the number game (CLI)

Simple game in which the application chooses a number between 1 and 100 and the user has to guess it in 7 or less attempts. This introduces handling user input, conditionals and loops.

4. Note taking (CLI, local filesystem)

Start a CLI that reads user input until a certain pattern is entered (such as /exit or similar), then saves all the text entered to a file named with the current date and time to a standard folder - optionally, offer a "view" mode in which the notes already saved are displayed. Focus here is learning how to interact with the filesystem and an initial mode of persistence.

5. To-do app (CLI, database/sqlite)

Application that allows users to create tasks and mark them as done from the terminal. Learn how to interact with databases in the language, a good first option usually being sqlite.

6. Hello World (GUI)

Same as the first project, but now displaying "Hello World" in a graphical interface. This project makes you learn the very basics of creating an UI in the language. Depending on the language, this (and the next two projects) might not be relevant, or be redundant - in a language usually applied in a stack that is graphical by nature, the CLI version of these projects will already teach how to create graphical interfaces.

7. Guess the number game (GUI)

Same as the third project, but now with a graphical interface. Most important learnings here being how to receiver user input in a GUI and how your custom logic interacts with the UI rendering loop (often requires basic multithreading understanding). Depending on the language, might not be relevant or be redundant.

8. To-do app (GUI)

Same as the fifth project, but now with a more sophisticated user experience to edit tasks. The main benefit I see for this project is to give a holistic understanding of a complex end-to-end scenario, going from an user interface all the way to a database and back - after finishing this project it should feel like you can comfortably use this language to solve real-world problems in a user-friendly way.

9. Quotes app (REST)

Web application that returns famous quotes from certain people (can be hardcoded) through HTTP requests, preferably applying the read-only parts of REST. This project allows you to learn how to run a web server in this language, and use your custom logic to respond to requests. I do not see the need to also implement the client part for this project, but frontend-focused developers might see the benefit.

10. Album manager app (REST)

Web application that fully manage an "album" resource - allowing the creation, edition, listing and viewing of musical albums. The challenge with this project is implementing the full management of a resource, including its nested entities (an Album has an Artist, a list of Musics, etc.) and database persistence. It serves as a capstone - if you are able to do this, you should feel confident to say you are proficient in the language. Most entry-level jobs would have very similar (if not lesser) expectations, and if you reached this stage it should be very easy for you to go after any subsequent knowledge as the need arises.

Monthly Recap - 2025-10 October

Another short one for October. Things have been crazy busy with the logistics of moving out to the new apartment, and with the bootstrapping of the new team at work. I've had very little time to work on learning and personal projects.

The main highlight of the month was finishing a course on the Go programming language, which I have never worked with before but is part of the core stack in my new team. I usually learn better with video courses than with any other material, so I chose this approach again and it worked as expected. But it turns out that it is not very easy to learn something new in this age in which AI is just right there ready to do everything for you at the distance of a single prompt... I plan to write a few posts specifically about this and how the process of learning the language has been so far.

I have also been involved very deeply in how AI is changing the software development process at our team, but this is a huge topic that deserves attention by itself. Hopefully I will be able to write a few pieces on this, but it might take several months yet. We'll see!

I expect to be able to write more in this last stretch of the year, and continue doing so next year. But the pace might still be a little erratic, due to all the changes in my personal life. For the remainder of the year I will probably be still working on getting comfortable with Go and more writing, leaving any new major projects to next year.

Monthly Recap - 2025-09 September

Short update this time.

September continued the trend of major changes, both professionally and in personal life.

Professionally: still onboarding into the new team and area. Worked with several different agentic frameworks for Python (Google's ADK, CrewAI, LangChain), mostly investigating and building small PoCs. Very unhappy with current methodology directions at work.

Personal life: Bought new apartment, started all the chaos of moving out - unlikely to end soon. Got into investing as well, which has been incredibly insightful.

October should still be hectic and with very little to add for technical discussions. Hoping that things will calm down around late November, early December - but not fully convinced they will!