Noghartt's garden

2025 in Review

Tue, 30 Dec 2025 14:08:29 GMT

Here we go, following the tradition once again. Here I am again, writing my yearly review. As I said in the 2024 in Review:

The next year, for me, will be a year of consistency, reconstruction, maintenance and improvement.

I’d say that if I were writing this today, I’d need to rewrite it as: “The next year, for me, will be a year of discovering, understanding, and frustration.”

This year had some unexpected turns, and it was very different from previous years. I didn’t do well in some parts of my life that I consider important, but on the other hand, I had new opportunities and lived more this year, with more travel and more experiences.

And also, as a tradition once again, this year I definitely do have things that I need to improve.

On health

On the health side, it was a year of ups and downs. On the one hand, I started taking a bit more control of my health: starting my ADHD treatment, fixing some issues with my body, and going to the doctor to solve them (something I had procrastinated on a lot).

In 2025, I was a bit more consistent with some aspects of my health: going to the gym turned out to be a fun thing to do. I started loving working out. It was the time of the day when I could just drop any thought and start focusing only on pushing (or pulling) weights. Something I noticed is that working out really helped keep my anxiety levels more stable. I still have some issues with anxiety, but it’s more moderate now.

Another thing I would like to be more consistent with during the year, and which will be one of my health focuses for next year, is climbing. It was an insanely good hobby I discovered. Although bouldering is a bit frustrating sometimes, the feeling of accomplishment when you finish a project is really good. I want to have at least one climbing session per week, lasting 2–3 hours, mostly bouldering.

But there are some things that didn’t go as well as I expected. Specifically, my sleep: I believe I could be more consistent. Based on my Oura Ring data, I had some discoveries and insights around my sleep that will help me better optimize the way I sleep.

One of the core insights I had about sleep was:

Having 210 mcg of melatonin 2 hours before bed helps me a lot with having better, more consistent sleep (especially REM and deep sleep).
Loud noises have a big impact on my sleep quality. I bought earplugs, and they were one of the best purchases I made to improve my sleep.
Bedroom temperature. Living in Brazil is really hard, especially during the summer, since it gets very hot. Having ways to better control room temperature is a great investment for sleep quality.

Something I noticed from my sleep-quality rollercoaster is that on days when I don’t sleep well, my mind becomes completely numb, I’m angrier, and more anxious. How do I know this? Because this year I had a lot of days with poor sleep.

That will be one of my main focuses for next year: being more consistent with my sleep. From my point of view, sleep is the fundamental thing that creates momentum for everything else. If I’m not doing well with sleep, as a side effect, everything else also suffers. As a note for next year’s review, the first thing I need to fix is solving my sleep anxiety. I don’t struggle with sleep itself, but I struggle to go to bed.

The last thing I want to mention here is that I started meditating. It isn’t a habit yet, but it’s something I’m working on. I believe that making meditation one of my core improvements in 2026 will bring a lot of fulfillment.

On reading

This year was kind of disappointing for my reading habits. I set a goal of reading at least 12 books by the end of the year, and I finished a total of ZERO books.

I started a lot of new books or continued some older ones, but my reading consistency dropped to its lowest level in the last five years. For most of the year, I was reading Gödel, Escher, Bach, but it was harder than expected, since I had to read and reread many pages to clearly understand what the author was trying to say.

I’m not good at managing multiple books in parallel; it’s really hard for me to be consistent when reading several books at the same time. I also read parts of other books, like:

The Origins of Efficiency
Structure and Interpretation of Computer Programs
Nicomachean Ethics
Database Design and Implementation
The Elements of Computing Systems
The Mind Illuminated
Crafting Interpreters

Those are the other books currently in my reading queue for next year.

Blog posts and bookmarks

On the other hand, I read a lot of blog posts this year. You can check all of them in my bookmarks.

I wrote a small script to extract metrics from my bookmarks for this year, and I’ll share some insights below.

All bookmarks from 2025, grouped by month:

My most active month was December, with 193 bookmarks. To be honest, I think this is mostly related to a habit I developed of tagging everything as #for-later before actually reading it. This is also reflected in the next metrics.

Here’s a heatmap of my bookmarks in a GitHub-like view, which gives a clearer picture of how my bookmarking behavior is distributed:

And the last useful metric shows the number of bookmarks per tag:

As mentioned above, there’s some deviation due to the #for-later habit. Ignoring that tag, the most used ones are #cs and its subtags, with a total of 343 bookmarks this year.

On career and work

This year was more like a year of consistent focus on my work itself. I had the opportunity to work on many different projects at my job, which gave me valuable insights into handling systems used by more than a million users.

Projects like building a durable workflow engine to manage long-running tasks for LLM agents, or setting up simulations and benchmarks to maintain output quality, are good examples of what I worked on.

For next year, there are a lot of exciting things coming, and I’ll be involved in many of them.

Regarding my broader career, I’m still struggling to manage my side projects. I have some plans to better structure how I approach their development, so I can work on them alongside everything else.

On life

One area where I achieved a lot this year was life in general. I reached milestones that my younger self wouldn’t believe were possible.

Europe trip

This year, I had the opportunity to go on a trip to Europe with my girlfriend and her family. It was my first international trip, which made it especially meaningful to me.

I procrastinated a lot on writing a blog post about this trip, but it’s on my list for next year (I promise).

Between late June and early August 2025, I traveled between Rome and Madrid, and it was one of the best experiences I’ve had. I’m not someone who enjoys traveling that much in general — I’m more of a homebody — but experiencing two different cultures and so much history was incredible.

Rome is beautiful. Everything there tells a story, and as a history nerd, I was amazed by what the city had to offer. Every alley and street revealed something new. Visiting the Vatican, the Colosseum, and the Roman Forum opens your mind in ways you can’t fully appreciate without being there. I hope I can visit Rome again someday.

We also stayed in Madrid for seven days. What a great city — bright and full of life. We visited the Museo Nacional del Prado, where I saw incredible works by amazing artists. I also ate some of the best sushi of my life (until now — I suspect Japan will change that someday).

Toledo is a city close to Madrid with its own magic. It’s a medieval city that preserves much of its original structure. Sadly, I wasn’t able to visit the Toledo Cathedral because the line was too long, and we only had the morning and afternoon there.

In the end, I can say that I truly loved this trip. Being there with my girlfriend gave the whole adventure a special meaning. I really hope to return someday, ideally with her.

Next steps for 2026

That was my year in review. Overall, it was a year of ups and downs. I discovered and learned many things, and I started understanding myself better — especially how my mind works. Looking back at what I wrote last year:

I have a strong feeling that, given my 2024, it will be a better year in all aspects. I have a lot of plans for the next year and I’ll commit to all of them.

I’d say that 2025 had many good moments, but also areas where I completely failed and need to improve next year. In the end, what matters most is identifying those gaps and setting clear goals for the year ahead.

One thing I want to change is how much I read blog posts. I don’t want to consume them at the same volume as this year. Why? Because much of it was driven by FOMO, not by genuine interest. I can clearly identify which articles actually changed my mental models. Going forward, I want better criteria for choosing what I read.

Along the same lines, I want to revisit old articles and start creating flashcards. Building a stronger flashcard habit could be very useful, especially since my memory isn’t always great.

On the health side, the three things I want to maintain are: improving my sleep habits and routines, controlling light exposure better, starting a meditation habit, and continuing with workouts (gym and climbing).

As I mentioned last year but didn’t accomplish, I want to start tracking specific life metrics. Measuring what matters gives clarity, and I strongly believe in the idea that “what gets measured gets improved.” If I want to commit to habits, I need to measure them.

Overall, this was a year of gaining maturity. Even though I didn’t accomplish all my goals, and life felt chaotic at times, things turned out well. That’s part of the process of dealing with the chaos we call life.

If this were me last year, I would have said it was a bad year. But looking back at the past months, I see real progress. I feel more mature, happier, and more excited about what’s coming. That’s the mindset I want to carry into next year.

I also have many plans and ideas for this blog. Writing is one of the things I want to keep improving.

Happy New Year, reader! I hope the winds of 2026 bring you success and everything you seek to achieve your goals!

Notes on my Linux system

Sun, 14 Dec 2025 14:26:54 GMT

Recently, I became again a daily Linux user. Using Arch Linux, btw. I was a macOS user for about 3 years, which was a good OS by the way, but I missed a lot of features which was so much easier to do on the new environment, like tiling window managers, easier workflow setup for autostart programs and a better way to manage my config using declarativeness.

This blog post here, we'll be more about things which was useful for me somehow, and I need to record to myself for the future, if I want to come back here, in case of a distrohopping or something else. I hope it can be useful for you too.

Autorunning xinit and applying DBUS autostart

I'm using X11 (yes, not using Wayland, yet).So I did the most simple setup I could to start my i3 on a given display. For that, I added on my .zprofile:

if [ -z "$DISPLAY" ] && [ "$XDG_VTNR" = 1 ]; then
  exec startx
fi

Then, every time I logged and my shell starts, the .zprofile will be triggered, which will run the exec startx, since both variables conditionals are true.

And, on my ~/.xinitrc, I had to start the D-Bus manually, which is required to have some things working, like the PAM/gnome-keyring and the dunst (for libnotify/notification-daemon).

For that, what I did was:

source /etc/X11/xinit/xinitrc.d/50-systemd-user.sh

exec dbus-launch --sh-syntax --exit-with-session i3

Autostart with Desktop Entries

Right now, I'm using the ~/.config/autostart from X11 with desktop entries to handle the autostart of some of my programs, like Redshift, for example. For example:

[Desktop Entry]
Version=1.0
Name=Redshift
_GenericName=Color temperature adjustment
_Comment=Color temperature adjustment tool
Exec=redshift
Icon=redshift
Terminal=false
Type=Application
Categories=Utility;

Adding this desktop entry, every time you start your X11 workflow, these programs will be executed. If I want to test it before, I can run this command below:

dex --autostart

Creating Autostart Systemd Services on User Land

I do have some docker containers which I'm running on my PC while on autostart. Kind of self-hosted, while I'm fixing some issues with my homelab. TIL, I can create a service on user land with systemd on the folder: ~/.config/systemd/user.

That was what I did, I'm running miniflux when I log in into my user. That's the service file as an example:

[Unit]
Description=Miniflux docker compose flow
After=network-online.target docker.service
Wants=network-online.target

[Service]
Type=oneshot
RemainAfterExit=yes
WorkingDirectory=/path/to/my/miniflux/folder
ExecStart=/usr/bin/docker compose up -d
ExecStop=/usr/bin/docker compose down
TimeoutStartSec=0

[Install]
WantedBy=default.target

Automatically appending i3 layout + opening programs

I'd like to have some programs opening automatically when I log in into my user. And I'd like to specifically route it to a given workspace + with a specific layout.

I learned that i3 provides something for that: the i3-save-tree + append_layout config. Then, on my ~/.config/i3/config file, I did this:

assign [class="obsidian"] workspace 10
assign [class="Todoist"]  workspace 10
assign [class="Anki"]     workspace 10

exec --no-startup-id ~/.config/i3/start-ws10.sh

I'm assigning a rule to enforce that all windows with the class being obsidian, Todoist or Anki, will be routed directly into the workspace 10. After that, I'll be running the script for start the programs on that workspace:

#!/bin/sh
i3-msg "workspace 10; append_layout ~/.config/i3/layouts/saved-tree.json" # that was saved by i3-save-tree
sleep 1
gtk-launch anki
gtk-launch obsidian
gtk-launch todoist

i3-msg "workspace 1";
i3-msg "exec ghostty";
i3-msg "exec firefox";

Fixing issues with Realtek 8852AE, my 802.11AX device

I had some issues with my Wi-Fi, we're it sometimes started disconnecting while I was on a meeting, it was specifically happening while on meetings or video-calls, so basically looking a bit into Arch Linux forum, I saw that it could be some issue with an inconsistency with Wi-Fi 7. So what I found is that I could disable the power save mode on the device and it would work as expected.

Then, I created a file called /etc/modprobe.d/70-rtw89.conf, with the following content:

options rtw89_pci disable_aspm_l1=y disable_aspm_l1ss=y
options rtw89pci disable_aspm_l1=y disable_aspm_l1ss=y
options rtw89_core disable_ps_mode=y
options rtw89core disable_ps_mode=y

After that, I just need to reboot my PC. No more issues with my Wi-Fi networking.

On Declarativeness Config

Something which isn't good on my config right now, it's the way I'm doing the store of it. I really miss the fact that with Nix specifically, I do have some way to easily reproduce the same environment, and do not lose mostly of the configurations of all binaries and stuffs which I do have on my computer, like rofi, i3, my Desktop Entries, systemd services, etc.

I'm not happy with the way I'm handling it right now (without Nix), so I'll be changing it in the next days or when I stop procrastinating it.

On sidenotes implementation

Tue, 04 Nov 2025 01:10:45 GMT

This week, I finally implemented my sidenotes on this blog. It was a work in progress for about 1 year, from the first attempt at implementation until reaching a decent solution.

All the implementation was based on a "philosophy" of what I believe is the best way to present a blog to the reader and organize how it can be read. It was mainly inspired by Sidenotes in Web Design, by Gwern[^1].

I think that, specifically for blog posts, sidenotes can be more useful than footnotes/endnotes, which, at least for me, bring a bad user experience, where you need to go back and forth between the anchored sections of your text to have the full context of something that has been written.

On the other hand, sidenotes help give an easy stream of text with the full context of a given scope, considering that all sidenotes are close to their paragraphs. It's easier to follow a text with your eye when you have all the sections together, without the overhead of the navigation.

Core philosophies

Focus on being web-friendly. As one of the core points of my implementation, I approached it as much as possible, following some web-friendly concepts. What does that mean? Ideally, the entire implementation should be JavaScript-free.

In my current implementation, sadly, this isn't 100% true (maybe it never will be), because I had to make some trade-offs to improve the user experience for sidenote usage. But all the core implementation is based on Tufte CSS.

Also, following it, I added some approaches most inspired by the way Gwern did their sidenotes: anchoring each sidenote. Then you can easily click on any sidenote and use it as the anchor for that page. I really like anchoring.

And for mobile devices, it shows, close to the text that each sidenote refers to, whether it can be readily displayed or not. Try accessing these on a mobile device and check this behavior. It's really cool.

Avoid introducing new stuff. I want to be as compatible as possible with the current footnote implementation in markdown, without adding any new syntax or a different approach to managing text. In the end, this should be just markdown, and I intend to keep it that way going forward, so I wouldn't like to use MDX, for example.

With that in mind, I narrowed my options on how to approach it. But the main reason for this decision is to ensure that all my notes can be easily ported between platforms and that I can write them wherever I am. Because, as I said, it's just a bunch of simple markdown notes.

Implementation

Specifically, the implementation is split into two parts: the markdown plugins and the styles and UX improvements.

The markdown plugins are being added to override the expected behavior of the known footnotes approach and replace it with our own sidenotes implementation. They are composed of these two plugins: remarkPluginSidenotes.ts and rehypePluginSidenotes.ts.

Talking about them, the first one handles all the boring jobs: traversing the AST, extracting the footnote, removing unnecessary nodes, and injecting new nodes.

The second one retrieves the HTML result and applies specific replacements to manage it. It ensures the expected attributes are added to the <label> and <span> tags. These will be needed to guarantee that the anchoring of the elements works as expected.

Now, the rest of the implementation is available here. It's doing a lot of things here, but explaining in a high-level way:

Inject all needed styles for the sidenotes[^2].
Add some stylizations, just to be cute. Similar to how Gwern did on their blog. A bidirectional hover linking both the sidenote number and the sidenote container, per se. When you hover or click on each sidenote, it will have a different style.
Add the logic to ensure the page loads to the correct anchor element, if it exists.

That's where all the JavaScript I mentioned before appears. Sadly, some of the things I'd like to do with my sidenotes aren't achievable only using CSS, so I had to use JS in part of the implementation.

Next steps

There's a lot of cool stuff that I could do using sidenotes. Definitely, there are some improvements and better experiences that can be done in future iterations, which will be what I'll be looking to.

For example, a friend of mine suggested that, on a mobile device, instead of showing the sidenote in the middle of the following line, right after the original reference, it could be a pop-up. It's something interesting that I'll be working on for future improvement.

Also, I'd like to render richer Markdown and other content within the sidenotes. It's limited in what I can do, mainly because of how it's being parsed, but that's another improvement I'll be working on.

This is a bit about how I did the first implementation of my blog's sidenote. I hope it brings some cool ideas and flourishes creative ideas you can use on your own blog.

[^1]: As a showcase, this is how it will look with the new implementation. [^2]: As mentioned before, all this stylization is based on Tufte CSS. Yes, I'm using a sidenote just because it's cool.

Changelog 25#41

Sun, 12 Oct 2025 22:20:47 GMT

Okay, I'll be starting a new kind of blog post here. The idea is bringing some insights and things I watched, read or did in the week.

What I'm doing

Studied a bit about how exactly DNA/RNA works. Understand a bit about RNA polymerase and how exactly RNA transcript into mRNA.
Read a bit about Game Theory. Learned more about Zero-sum games, Nash equilibrum, Minimax and the Prisoner's Dilemma.
I'm still working in my Viewstamped Replication Protocol implementation. Finishing the implementation of my Deterministic Simulation Testing runner, which is missing some specific parts for test: adding the randomness workflow + seed to insert random actions during the tests, etc.
Finished reading Akira, volume 1.
Started reading Nicomachean Ethics, by Aristotle.
Based on the release of Hashcards, I started doing some new experiments with Spaced Repetition. I'll be coming back here in the next weeks with some report on that.
Started a new run in Factorio + playing Terraria with a friend of mine.

What I read

This will be mostly based on the things I read based on my bookmarks. Just compiling some of the most interesting/cool things, the other ones, feel free to check by yourself in the other page, there's more than I could reference here.

The most cool ones I read this week, I think are the above. Maybe I'm forgetting something I read which is on my bookmarks, but if that's the case, it's wasn't too much relevant to link here anyway.

Falling Into the Perfectionism Trap

Sat, 27 Sep 2025 07:51:52 GMT

Every time I open my Obsidian to start writing a new blog post, I remember the other 15 drafts sitting there. Will those ever see the light of day? I don't know. And that's a concern for me.

It's easy to take ideas and put them into two or three phrases. But being able to write for a long time (I'm Gen Z—two hours is a long time for me, don't judge) is just hard to do if I'm not in the mood. And in the last few months, the one thing I haven’t found is the mood.

I'd like to write about a lot of different things: my trip to Europe (the first one, by the way), my studies on DST (jokes aside for Brazilians, I mean Deterministic Simulation Testing), my studies on Distributed Systems. But I'm just not in the mood to write. Why? I don't know.

I do believe I’ve really fallen into the perfectionism trap for writers. I can’t count on one hand the number of drafts I was genuinely proud of last year. There's always something missing—a phrase, a section, a requirement. That’s what I call the perfectionism trap: when you look at the work you did, and all you can see are the gaps and how far you are from the final result.

But what is the final result? Sometimes I don’t even know. It’s just the feedback loop of never feeling satisfied with what I wrote. It took me a while to understand it. Even now, I don’t fully know where it comes from. Maybe I’m comparing myself with other authors and trying to be like them? Yes, maybe. Maybe I’m too focused on how the text is structured and not on whether the quality of what I’m producing is good enough to be read? Maybe that too.

My blog never was, and never will be, a platform just for the public. It never was. My blog is about having a place where I can share all my things—from cooking recipes and board game reviews to a 4,000-word wall-of-text book review or a report on my learnings from building a compiler from scratch.

It was never about being shorter or longer, but about whether, in essence, it represents my thoughts and my spirit at that moment. But I’m not sure when I lost that idea.

In the end, to escape the perfectionism trap, it requires understanding that perfection isn’t about a single piece of writing (or anything else) but the composition of the whole body of work (and in this case, I’m not talking only about writing).

What matters now is that I’ve found myself again and rediscovered the road I missed a long time ago. There’s a lot of work to do here.

Using nginx as a load balancer for my ngrok exposed local services

Sun, 24 Aug 2025 23:18:18 GMT

Just a small post sharing something I learned last week. This is the kind of post that could be a tweet, but instead, I want to put it here, on my blog. This was useful for me, I know it can be again in the future, hope it will be useful for you too at some point.

Last week, I had to do some tests given a specific scenario: having a load balancer which should redirect to the same application running in 3 different ports in parallel. After thinking a bit about how could I have the best setup to test it, I found a super easy way to handle this: nginx.

I found this documentation here, which explains to me exactly how I could achieve this: specifially using a keyword called upstream. Using it with the proxy_pass, will let me to put my reverse proxy to target this set of servers, where I can select how I want to route of each of the exposed servers there (by default, it's routed as round robin).

The nginx configuration would be like this:

worker_threads auto;

http {
    upstream backend {
        server 127.0.0.1:8001;
        server 127.0.0.1:8002;
        server 127.0.0.1:8003;
    }

    server {
        listen 8888;

        location / {
            proxy_pass http://backend;
        }
    }
}

On the documentation I shared before, it also shows some other options and other use cases you can achieve using this upstream keyword.

After that, I just need to expose my ngrok service to expose its reverse proxy to listen into the port 8888, as I said in my nginx.conf:

ngrok http --url=example.ngrok-free.app 8888

Now, all the requests that comes in https://example.ngrok-free.app will be redirect automatically to my local reverse proxy which will be automatically handled by its load balancer.

Writing Your First Nix Overlay

Sat, 04 Jan 2025 18:58:22 GMT

Introduction

After about 1 year, I came back to Nix as one of my main tools for my workflow. In case, you can see my entire macOS configuration, written in Nix, here.

After having to change MacBook devices twice during the end of the last year, I really missed Nix on my daily usage, where I need to setup my config every time, instead of just running a command. That's why I'm using Nix again after some period without it.

Now, I reached a specific scenario last week, where I need to write a specific overlay for a tool. In my case, beanprice. I'm using beancount, as my daily-driven tool to track my finances, and I'd like to track the value of my stocks in an easier way, instead of having to manually adding it everytime.

Doing some search, I discovered that the beancount's brewfile didn't install this binary for me. After trying the nixpkgs version of this binary, I discovered another thing: with that version, it comes with the bean-price binary, but it comes with an old version, where it didn't contain a specific module to fetch some of the stock prices that I'd like to fetch (more specifically, the alphavantage source). For that reason, it seems to be a good argument to have an overlay for that. That's what I did, and was my first time writing an overlay from scratch.

Writing the Module File

The overlays on Nix are a kind of function, it gives for us the ability to provide some overriding some specific configurations for a given module, package or anything else that your creativity let you think about.

In my case, what should I be doing? Writing a new overlay that would add a new package called bean-price into all Python packages modules. For that, I used this Python section as my reference to do that.

That's the output of what I did:

{
  lib,
  buildPythonPackage,
  python3Packages,
  fetchPypi,
  isPy3k,
}:

buildPythonPackage rec {
  version = "1.2.1";
  format = "setuptools";
  pname = "beanprice";

  disabled = !isPy3k;

  src = fetchPypi {
    inherit pname version;
    hash = "sha256-0/W1q25z6xNjhb7mZFpJUZ6TVNNA1BK341gOxlpOGVc=";
  };

  # Tests require files not included in the PyPI archive.
  doCheck = false;

  propagatedBuildInputs = with python3Packages; [
    python
    python-dateutil
    beancount
  ];

  meta = with lib; {
    homepage = "https://github.com/beancount/beanprice";
    description = "Daily price quotes fetching library for plain-text accounting ";
    longDescription = ''
      A script to fetch market data prices from various sources on the internet and render them for plain text accounting price syntax (and Beancount).

      This used to be located within Beancount itself (at v2) under beancount.prices. This repo will contain all future updates to that script and to those price sources.
    '';
    license = licenses.gpl2Only;
    maintainers = [ ];
  };
}

What we're doing here? We're calling the buildPythonPackage function accordingly to the Python interpreter. And will run four steps, accordingly to this documentation here: buildPhase, installPhase, postFixup and installCheck.

With that, we will be able to build and have our own binary of a given package, that, in case, we're fetching all those informations based on the src with the fetchPypi function.

Finally, we had this overlay done, now, we need to let both nixpkgs and home-manager know about that.

Consuming the Overlays

In my opinion, as a good pattern for that, I like to have the overlay being "exported" on a main file. For my config, I wrote a overlays/default.nix that does it for me:

# /overlays/default.nix

final: prev:

let
  pythonPackageExtensionsOverrides = self: super: {
    bean-price = prev.callPackage ./bean-price {
      inherit (super) buildPythonPackage isPy3k;
    };
  };
in
{
  pythonPackagesExtensions = prev.pythonPackagesExtensions ++ [pythonPackageExtensionsOverrides];
}

Now, what I'm doing is: getting all my overrides related to python and overriding it on pythonPackagesExtensions. Which basically override it for every Python extension (python3, python, python39, python312, etc).

Now, we just need to add it on the imported nixpkgs and on home-manager, to guarantee that everything is good.

From another post that I wrote last year, where I teach how to install Nix + nix-darwin + home-manager on macOS. My flake.nix config was like that:

<summary> <code>flake.nix</code> config without overlays</summary>

{
  inputs = {
    nix-homebrew.url = "...";
    home-manager.url = "...";
  };

  outputs = inputs @ { self, nix-homebrew, home-manager ... }: let
    nixpkgsConfig = {
      config.allowUnfree = true;
    };
  in {
    darwinConfigurations = let
      inherit (inputs.nix-darwin.lib) darwinSystem;
    in {
      machine = darwinSystem {
        system = "aarch64-darwin";

        specialArgs = { inherit inputs; };

        modules = [
          ./hosts/mbp/configuration.nix
          inputs.home-manager.darwinModules.home-manager
          {
            nixpkgs = nixpkgsConfig;

            home-manager.useGlobalPkgs = true;
            home-manager.useUserPackages = true;
            home-manager.users.noghartt = import ./home/home.nix;
          }
        ];
      };
    };
  }
}

</details>

Now, we will need to adjust it in two parts to guarantee that everything is good:

{
  inputs = {
    nix-homebrew.url = "...";
    home-manager.url = "...";
+   nixpkgs.url = "github:NixOS/nixpkgs";
  };

- outputs = inputs @ { self, nix-homebrew, home-manager, ... }: let
+ outputs = inputs @ { self, nix-homebrew, home-manager, nixpkgs, ... }: let
+   overlays = [ (import ./overlays) ];
+
+   system = "aarch64-darwin";
+
+   pkgs = import nixpkgs { inherit system overlays; };
+
    nixpkgsConfig = {
+     inherit overlays;
+
      config.allowUnfree = true;
    };
  in {
+   packages = pkgs;
+
    darwinConfigurations = let
      inherit (inputs.nix-darwin.lib) darwinSystem;
    in {
      machine = darwinSystem {
        system = "aarch64-darwin";

        specialArgs = { inherit inputs; };

        modules = [
          ./hosts/mbp/configuration.nix
          inputs.home-manager.darwinModules.home-manager
          {
            nixpkgs = nixpkgsConfig;

            home-manager.useGlobalPkgs = true;
            home-manager.useUserPackages = true;
            home-manager.users.noghartt = import ./home/home.nix;
          }
        ];
      };
    };
  }
}

With that, you will be able to add both overlays to nixpkgs side, so you can add the overlays at a system-level, for NixOS, nix-darwin, or any place you're using it. And, inheriting overlays at the nixpkgsConfig at L16, will let you use the overlay in home-manager level.

Now, in your home-manager config, you can do something like that:

{ pkgs, config, lib, ... }:

{
  home.stateVersion = "25.05";

  home.packages = with pkgs; [
    fava
    python3Packages.beancount
    python3Packages.bean-price
  ];
}

Solving Conflicts on Overlays

One issue that I had on this bean-price overlay is, as I said, the nixpkgs version of the beancount adds the bean-price binary. So, both packages are conflicting to decide which of the binaries should be chosen.

The first solution that I saw, was adding a meta.priority = 10; on the overlay. But haven't success, it still getting the outdated version of the bean-price binary. In that case, I did a different approach:

# /overlays/default.nix

final: prev:

let
  pythonPackageExtensionsOverrides = self: super: {
    bean-price = prev.callPackage ./bean-price {
      inherit (super) buildPythonPackage isPy3k;
    };
+
+   beancount = super.beancount.overrideAttrs (oldAttrs: {
+     postInstall = ''
+       ${oldAttrs.postInstall or ""}
+       rm $out/bin/bean-price
+     '';
+   });
  };
in
{
  pythonPackagesExtensions = prev.pythonPackagesExtensions ++ [pythonPackageExtensionsOverrides];
}

I added an overlay to beancount package too, where add a step on postInstall that just remove the binary related to /bin/bean-price. With that, everything works as expected.

DISCLAIMER!

I didn't find any other way to solve this issue. Everyone that knows a better, elegant approach to do it, feel free to reach me out. I would really like to have a better way to solve this.

Also, if I find something, I come back to this post and update it accordingly to what I find.

Conclusion

This is just a brief tour around how you can approach to write your first overlay. And a good introduction to understand how useful is Nix at all, you can do a lot of things or extend things that you already had as you want. It's a powerful tool in the right hands.

2024 in Review

Mon, 30 Dec 2024 23:58:32 GMT

Following the tradition, writing my annual review. This year, being from ups and downs, a lot of things happened. I can consider 2024 a good year looking from the macro perspective, but far from what I would like. I was able to conclude my biggest objective for this year, but looking from the personal side, I wasn't good as I expected.

Reflecting on what happened in this year, gave us some insights about what are the things that is going well and which things we will need to fix on the next year. And, in my case, I have a lot of things to fix.

Similar to last year, the structure of the post will be following like this: we will have some core points like "health", "reading", "habits", "coding", "career", etc. And, for this year, I'll be doing a kind of comparison to see how much we improved on those ones or if we was able to maintain it.

Health

In the opposition from what I said in the expectations for 2024, I didn't take too much care from my health this year. I was a lot below the average on the three critical points on health that I believe that would help me: sleep, gym and nutrition.

Specifically about those three points, I didn't dedicate myself enough to fit what I expected from those ones, and all those threes are interconnected, which had side-effects in other aspects of my life, like, for example, feeling tired during the days. In this year, I could see how much having an unhealth life impacts in our life and, in my case, mostly having psychological effects about it.

From my experience, it was pretty hard to have a good night of sleep, staying focused for long times or even not being too stressful during the day. Also, it seems that it impacts a lot on "ADHD crisis", where, in some days, it was just impossible to work without my medicines.

Also, from sleep routine, I think that this year was a bit difficult to stay focused on that too. Even because my new apartment is on the downtown, there's more noise and chaos, then being more disciplined on that was very hard. My sleep time average was about 6 hours, but knowing myself, I know that this isn't enough to be 100% functional on the next day. Also, I completely lost my habit of waking up between 6AM and 7AM.

I'm not fully commited on gym too, it's a pretty hard habit to maintain, I need to commit hard on that and being focused on the long term objectives. But, not just from bad things, my year in health is going on, this year I discovered a new sport that I really loved: climbing. I really love it. It's one of the things that I really want to maintain in the next year.

Reading

This year, I started the year maintaining the goal of 12 books until the end of the year, but I reached out only about 6 or 7 of them, to be honest, some of them are so useless in their concepts that is completely insignificant for myself. During the year, I noted this bad behavior, I wasn't reading because I'd like to read more about the theme, I just read because of the quantity. After that, I decided to slow down my reading and coming back with better books that I'd like to read. Some of the books that I can mentioned that I read was:

Database Internals, by Alex Petrov
Antifragile, by Nassim N. Taleb
Fooled by Randomness, by Nassim N. Taleb

Also, I started a lot of books that I dropped after some time, because I was feeling that the reading wasn't productive as I expected, like: "Noise: A Flaw in Human Judgement" and "Thinking Fast and Slow", both from Daniel Kahneman, are two of those books that I dropped after some time.

In the moment I'm writing this, I'm reading what I believed that will be my first readings from 2025: "Godel, Escher, Bach: an Eternal Golden Braid", by Douglas R. Hofstadter, and "The Mind Illuminated", by John Yates, the last one as a recommendation from a friend, because I'm really interested in investigate some long term effects from meditation in my life. Further that, for the next year, I have a lot of good books to read, most of them focused on technical aspects, but I want to reread some of the old books that I read too.

Career and Work

I think that, from the career perspective, this year was awesome. I was able to complete the most import objective from my year in this aspect. Now, I have the great opportunity of working with awesome guys at Fireflies.ai, and it's being awesome in every sense. I'm working with a lot of good engineers and having the opportunity to bring innovation for millions of users, further the aspect of learning a lot of new skills and technologies around it.

From my career perspective, I could be better on that, I believe I could dedicate myself more during the year and investing more time on side projects and learning in general. I have some advances on the distributed systems topics, but below my expectations. For the next year, one of my goals is bringing a more actively approach on this topic.

Writing

From the writing side, I'd say that was an year in average. I have a feeling that I could do it better, but I have some great works this year, like: Increasing Your Friction Area, Implementing Simple Paxos Consensus Algorithms With Rust and RSS and why I love it.

Not considering the drafted posts and this one, it was 10 posts during the entire year. It was in average, better than zero. For the next year, I will be more consistent on that. I think that one of the greatest issues with writing is not trying to writing the perfect article, I need to write, just it. That will be my mantra for the next year.

Next steps for 2025

This as a summary review from my year, for sure there's a lot of other things that I didn't mentioned, either because I wouldn't like to do or because I forgot. And, for 2025, I have a strong feeling that, given my 2024, it will be a better year in all aspects. I have a lot of plans for the next year and I'll commit in all of them.

From the same thing I said last year, this next year I need to focus on my health. It's not only about being a healthier person, but, if I want to be a high-performance person, I need to have a healthier body and a healthier mind. That's why I'll be doing some checkups and working intensively to improve in this aspect of my life. From the psychological side, I'll be leaving my social medias for a time and trying to reduce my screentime. As said before, I'm really interested in meditation, I want to see how my mind, that is agitated by nature, will perform after gym and meditation, if I can think better, improve my sleep, and other related things.

Being more organized is other aspect of my life for 2025 that I will being focused on. Having a better scheduled time, will bring to me some improvements on my routine, which implies in having a consistent performance accordingly to the tasks I need to work on. And, looking from the long term perspectivee too, being more organized can give me some useful insights around the things that I worked on during the week, month, quarter, semester or year. Then, I can review and change the direction of something when necessary.

From the point I mentioned above, with that in mind, writing will be one of the core habits I'll maintain and improve on the next year. Not writing blog posts, but writing my thoughts. Documenting what I did, documenting things that I'm looking on, documenting how I'm doing things, because, in the future, those resources will be the reference for the next annual review, for example. I want to have more quantitative date from my life too, following the idea from Stephen Wolfram here, I want to track my life in quantitative perspective to bring some useful insights about the correlation of data.

My focus for the next year will be more on increasing consistency on good habits, that is, guarantee that the things that I'm doing is coming from a good feedback loop and tha it will have a good return in the long term.

It wasn't the best year of my life, but I'd say that one of the most importants. I'd like to thanks my girlfriend for this incredible year at her side, I love you so much, I learn a lot from you. Also, thanks for each of my friens that gave me the opportunity to share this year with them, it was incredible.

The next year, for me, will be a year of consistency, reconstruction, maintenance and improvement.

Happy New Year, reader! Hope that, in 2025, I bring a better version of me here.

On Bookmarks, Lists and the Habit of Reading Later

Wed, 25 Sep 2024 22:24:04 GMT

Bookmarks are underrated features. It's a good way to help you keep track of not only what you need to read but also what you need to do. Further, your bookmarks can be a way to structure your reading and your knowledge, for future reference, as Josh Leeb talked about here.

About the organization of my bookmarks

Inspired by a friend of mine, in January 2024 I started having a "reading list" of my bookmarks. As commented on RSS and why I love it, I have an RSS feed that I use to read a lot of things during the day. But, one thing that I missed was the ability to have a list of things that shall store: what I already read and what I need to read (in the future, that kind of list always increases).

So, as you can see on my bookmarks page, I have a list containing all the content that I have consumed since January 2024, not just articles, but also videos, podcasts, etc. I have another page to see them grouped by their tags, so I can easily find a specific bookmark given the tag I want.

How do I store my bookmarks?

The tool that I use to manage my bookmarks is Omnivore, an open-source bookmark manager and "read-it-later" app. For my use case, it's a great tool, I have their extension for the browser installed that I use to store the tab that I'm seeing.

Also, I'm using their mobile app, which lets me read all bookmarks that I have. In that case, I'm using it mostly to read my "read-it-later" articles while in the gym, for example.

About the list of my bookmarks

As mentioned before, further the list on Omnivore, I have a list of my bookmarks inside this blog. I have two specific ways to organize them: grouped by month and grouped by tags.

Most of the time, I'm using it based on tags because I think that it's how my brain works, so it's faster to remember what I exactly want. For example, if I want to read something that I didn't read yet, I can just go to the tag #for-later. If If I want to recover something related to a computer science topic, I can go to the tag #cs or one of their specific subtags like #cs/distsys.

Specifically about tags, mentioning again Josh Leeb, who wrote a post about Scopped Tagging Bookmarks. where he tries some approaches explains some of the problems and presents some approaches for it.

In my case, I have a kind of implementation of what he mentioned as HNT (Hierarchical Namespaced Tagging), so on Omnivore and, you can see here at my blog, I did a hierarchical structure for my tags. But, I think that it's a process that can be error-prone sometimes, like when you need to be a more specific tag or a less specific one, or when You didn't find a specific tag that matches your need for some bookmarks.

About the habit of reading later

Then, as mentioned before, one of my specific tags that I use (and I believe that is one of the most used by myself), is #for-later. Specifically this tag, I use to store every bookmark that I didn't read yet but I think that it's interesting.

I don't like the idea of storing "read-it-later" articles at all seems to be more a product of a FOMO rather than a real interest, but it's something that I am still maintaining just as a "habit".

Also, I think that it's a trade-off that you need to deal with, your list of read-it later articles will be growing over time, and you will need to choose and validate if that content really will be interesting for you in the future.

Do not trust on yourself, trust on checklists

Thu, 25 Jul 2024 01:24:19 GMT

Introduction

Recently, I saw a specific project from Lukeberry called "Como Debugar Frontend", in English, it would be called "How to Debug Frontend".

The UI behind this project is very simple, it's just a list of checkboxes that you can follow to match your situation and validate that you are following the right steps to debug any issue that you could have through your front-end code. But, the idea behind this project is powerful: we are susceptible to failure, and we shouldn't trust ourselves, instead, we should have a fault-tolerant system that can help us to trust in the process.

Why do checklists matter?

A checklist is a specific kind of list that we can use to validate if we are following the expected steps to do something. You can see through the entire internet a range of cases of usage of checklists, like those being applied to the aviation or medical fields.

In a scenario of stress or fatigue, you will be compromised by a decrease in your ability or cognitive functioning. The usage of a checklist will give you a way to "metavalidate" your capabilities and will let you reason about the the current state of the situation you are facing.

On "The checklist — a tool for error management and performance improvement", the authors of the paper bring some interesting data related to the usage of checklists in some fields like aviation, medicine, and product manufacturing.

We even have a book called "The Checklist Manifesto", that clarifies some ideas about the usage of checklists and the spread of the concept. I suggest you read it, also read the review from Murat Demirbas, it's a great review that explains some ideas of the book too.

How can I create my checklist?

Now that you already know the importance of checklists to bring a better experience to your work, you, being an engineer (I suppose that you are one), do you agree that you should have a checklist for your daily work?

It will give you a documented, structured way to validate if some aspect or scope of your work is being followed as expected. It will help to bring clarification to your work in the future for yourself and for the team that will need to work with you.

So, which things from my work should have a checklist?

A checklist for the feature that you are working on.
A checklist with the step-by-step process to test a new feature.
A checklist with the step-by-step process to release a new version of your product.
A checklist with the step-by-step process to debug a feature, like the "Como Debugar Frontend".
A checklist with the playbook when you're talking with a customer.
A checklist with the presentation of your product for an internal team.

Those are just some examples of the things that you can have a checklist for. With that, you can validate the reality and check if it matches the expectations of the situation.

Conclusion

With that in mind, I hope that you can see how much valuable is to have a checklist for your daily work. You can apply this concept to everything that you do, even outside your work, like the way you talk with your customers.

I want to find some papers and articles that bring some data related to the usage of checklists and their reduction in incidents and errors. But, clearly is a good idea to have a checklist with yourself to guarantee a pragmatic approach to how you do your work, also it's a way to reduce the noise from outside and focus on the important things.

Software Engineering is More Than Just Coding

Tue, 09 Jul 2024 02:05:24 GMT

I have a strong belief that most of the time, there is a clear separation between two concerns: software engineering and coding. Both look similar, both work together, but they aren't the same.

Software engineering is more than coding in the aspect that it involves more about your work than just your pull request on GitHub. It's more about the processes and patterns that you apply through your workflow that impact what I mean by engineering here, in this blog post.

Software engineering is about the guarantee that, from the macro perspective, the product and the code that you are working on will correspond to the expectations that they have, both from the product and technical sides.

About the product side, it follows the expectations around the culture and what your company, product or anything else you're working on has, like:

If it is what the customer wants;
If it will bring some quality of life improvement for your customer;
If it will be a building block for a greater feature,
And anything else that gives a clear objective for the final customer. Assuming that your "customer" here could be anything in that scenario that will consume the product that you are working on.

About the technical side, the core properties that should be followed in my vision are:

The guarantee that everything related to your code will follow the expectations around the patterns, the code guidelines that have been discussed in your company, project, etc.
Ensure that your feature has been tested, by yourself, by systematic tests, here being any kind of test (integration, unit, property, end-to-end, anything).
Ensure that the documentations are available and up-to-date according to the expectations that you and your coworkers have around the feature/code that you are working on.
Ensure that the code won't break the existing codebase.

About my thoughts around what I believe are responsibilities of software engineers that are more than coding, I will write some of my thoughts below:

Documentation as a Resource for the Future

Documentation is one of the most important parts of a project, in my opinion. It's about the guarantee that the decisions and the resources that you have at the moment you wrote a code have been saved in a way that can be validated in the future, by yourself or any other developer that will need to maintain your code.

Having a powerful context of the past decisions brings to the table the ability to review it and understand why some options have been taken or not. Some projects have been written by people that aren't in the company anymore and you can't contact them, so think how much easier it would be for you when you try to run that old project if they had at least one documentation about "How to run Project X".

Documentation brings to you a safe guarantee that, in the future, yourself from the past prepared all the place answering some of the future doubts that could exists.

Documentation should be an atemporal feature for anyone that wants to build a resilient, scalable, and maintainable software.

Tests as The Reinforcement Guarantee

If your code isn't supported by tests, your code isn't production-ready. I would say that for the majority of scenarios, you should have at least 1 test that guarantees the behavior of a given scope.

Recently, I read a great piece of blog posts from Matklad: How to Test, it brings some great material around how you could exactly test your software. And I believe that a strong software should be test oriented, in a perspective where you have the guarantee that, even if you inserted some specific new thing into your system, the feedback loop of the tests that you have will ensure that, if something has been broken, it will be caught up.

Tests are the proof of the axioms of your systems, the rules and the guarantee that your system will be working in a specific way. They aren't about what exactly users shouldn't do, but it's the guarantee that, based on what users really can do, you won't have a breaking change.

Tests also let you move fast, with the security that if there is any breaking change, it will be easily caught by those ones.

In any other kind of engineering, you have tests, redundancy, and tools that provide safety through their work, like a civil engineer building a bridge. Tests, for software engineers, follow the same idea.

Migrations and Refactors as Engineers

As Linus said some time ago:

WE DO NOT BREAK USERSPACE!

At the moment that your code goes to production, you have more concerns than just the usability of your code. How many people will be using it? How will a breaking change impact them if you inserted a new one? What are the implications? The second and third order effects of those changes? Can you think of the entire chain of consequences of this action?

You, as an engineer, should be carefully thoughtful about the decisions in your code. The implications of a specific change can impact a lot of customers in a harmful way that even you can't imagine.

Backward compatibility is a term that I like a lot. Being the guarantee of the interoperability of an older system (as said by Wikipedia), on the software side, it's the guarantee that we will ensure the same behavior of our APIs even for old clients.

Even for internal tooling or between shared modules across your codebase, you should carefully think about backwards compatibility. You will always have a consumer of an API and, in that scenario, your API is the interface that has been exported by your functions and is being consumed on the other side of your codebase. The guarantee that it won't break, or that it will change in every place, is a guarantee of less entropy throughout your entire codebase.

Conclusion

This is what I believe are some specific parts of a job of a software engineer, coding is one of the easier parts of the job. You have a lot more concerns to think about regarding your product, your code and other related aspects of the company.

And I believe that we should be more engineers and not just developers.

My Arch Linux Installation: systemd-boot, LUKS, Btrfs, swapfile and xmonad

Sun, 07 Jul 2024 07:07:03 GMT

Before the installation

Save things that you need to be saved

The public and private GPG keys:

gpg --export --armor > public.key
gpg --export-secret-key --armor > private.key

Your shared GPG and SSH files.

Your data.

REMEMBER: if you have some dotfiles or other projects in your PC, make sure that you have pushed your changes.

Make sure the drive security is not frozen

If you are running a pre-installed system, you can cleaning all the storage (in my case, a SSD NVMe), you can wipe your storage to clean all things inside it. To do it on a SSD NVMe, you can do these things:

Run the following command:

nvme id-ctrl /dev/nvme0 -H |grep "Format \|Crypto Erase\|Sanitize"

Erase all data from your storage (SSD NVMe)

You can run the 'nvme sanitize` command to erase all data from the storage. You can see an example of the command here:

nvme sanitize <device> -a <action>

The possible actions that you can use is:

-a <action>
--sanact=<action>
    Sanitize Action
    000b - Reserved
    001b - Exit Failure Mode
    010b - Start a Block Erase sanitize operation
    011b - Start an Overwrite sanitize operation
    100b - Start a Crypto Erase sanitize operation

ATTENTION: When you running the sanitize command, you should replace your binary value by their decimal part, e.g. 000b = 0, 001b = 1, 010b = 2, etc...

References

Wipe on an Empty Disk

Create a temporary encrypted container on the complete device to be encrypted

cryptsetup open --type plain -d /dev/urandom /dev/nvme0n1 to_be_wiped

Wipe the container with zeros

dd if=/dev/zero of=/dev/mapper/to_be_wiped bs=4096 status=progress

Installation

Disk partitioning (UEFI)

The partiotining that follows the concerns the UEFI installation.

Introduction

First of all, I have differente names for the partitions, but don't be lost for so little:

Mount point	Partition name	Partition type	Bootable flags	Size
/boot	/dev/nvme0n1p1	EFI System	Yes	1 Gb
/	/dev/nvme0n1p2	Linux LVM	No	Remainder of the device

Where / will be a LVM-encrypted partition having a group volume containing a physical volume and rootas a logical volume.

Finally, as mentioned in the introduction, we will format the / volume as Btrfs and create two sub-volume:

/root

swap

/home

Creation of the File System

In order to know the name of your disk, it is necessary to list the partition tables for the specified device:

fdisk -l

Let's select our disk to build the table:

cfdisk /dev/nvme0n1

Then create a new empty GPTpartition table.

And now, you can setup all the partiions in a "visual" way.

Setup the Disk Encryption

In order to enable disk encryption, we will first create a root LUKS volume, open it and then format it.

In a brief explaination, LUKS is a container format that will be used to encrypt containers, where our encryption key will be stored.

Creation of a root LUKS volume

To encrypt our / partition, we will use the cryptsetup tool:

cryptsetup --hash sha512 --use-random --verify-passhphrase luksFormat /dev/nvme0n1p2
Are you sure? YES
Enter passhphrase (twice)

Opening the root LUKS volume as block device

The / partition being encrypted, we will open the LUKS container on /dev/nvme0n1p2 disk and name it cryptlvm:

cryptsetup open /dev/nvme0n1p2 cryptlvm
Enter passhphrase

The decrypted container is now available at /dev/mapper/cryptlvm.

Setup the LVM

LVM is a logical volume manager for the Linux kernel. It is thank to to it that we can easily resize our partitions if necessary.

Create a physical volume on top of the opened LUKS container

pvcreate /dev/mapper/cryptlvm

Add the previously created physical volume to a volume group

vgcreate vg /dev/mapper/cryptlvm

Create the swap logical volume on the volume group

Create the root logical volume on the volume group

lvcreate -l 100%FREE vg -n root

Formatting the filesystem

mkfs.fat -F32 /dev/nvme0n1p1
mkfs.btrfs -L btrfs /dev/mapper/vg-root

Btrfs subvolumes

Subvolumes are part of the filesystem with its own and independnet file/directory hierarchy, where each subvolume can share file extents.

Create Btrfs subvolumes

mount /dev/mapper/vg-root /mnt
btrfs subvolume create /mnt/root
btrfs subvolume create /mnt/home
umount /mnt

Mounting Btrfs subvolumes

SSD_MOUNTS="autodefrag,compress=lzo,discard,noatime,nodev,rw,space_cache,ssd"
mount -o subvol=root,$SSD_MOUNTS /dev/mapper/vg-root /mnt

mkdir -p /mnt/{boot,home}

mount -o discard,noatime,nodev,noexec,nosuid,rw /dev/nvme0n1p1 /mnt/boot
mount -o $SSD_MOUNTS,nosuid,subvol=home

<summary>Some details about the option on <code>-o</code> flag:</summary>

autodefrag: enable automatic file defragmentation for small random writes in files with a maximum file size of 64K;
compress=lzo: compresses files with the lzo type which is a lossless data compression algorithm that is focused on decompression speed;
discard: enable discarding of freed file blocks using TRIM operation (useful for SSD devices);
noatime: allows measurable performance gains by eliminating the need for the system to write to the file system for files that are simply read;
nodev: disallows creating and accessing device nodes (used in particular for special files in /dev);
noexec: does not allow the execution of executable binaries in the mounted file system;
nosuid: specifies that the filesystem cannot contain set userid files;
rw: allows reading and writing;
space_cache: control the free space cache. This greatly improves performance when reading block group free space into memory;
ssd: by default, Btrfs will enable or disable SSD allocation heuristics depending on whether a rotational or non-rotational device is in use.

</details>

Base system

Update the mirrors

pacman -S reflector
reflector --threads 8 --protocol http --protocol https --verbose --sort rate --country Brazil --save /etc/pacman.d/mirrorlist

Installation of the packages onto a given root file system

pacstrap /mnt base linux-firmware linux-zen lvm2 sudo man-db base-devel linux-tools git hdsentinel fwupd sudo

Configuration of the system

We will configure the system base in order to have a decent environment.

Generate a fstab file

genfstab -U /mnt >> /mnt/etc/fstab

Change root into the new system

arch-chroot /mnt

Create the swap file

To create the swap file, we will create a zero length file, set the No_COW attribute and make sure compression is disabled:

truncate -s 0 /swapfile
chattr +C /swapfile
btrfs property set /swapfile compression none

Is recommended to set the size of swap file being 4-8GB if you don't intend to use hibernation (suspend-to-disk):

dd if=/dev/zero of=/swapfile bs=1M count=16384 status=progress && sync

Set the permission for the file (a world-readable swap file is a huge local vulnerability):

chmod 600 /swapfile

Format the /swapfile file to swap and activate it:

mkswap /swapfile
swapon /swapfile

Finally, add an entry for the swap file in the fstab:

echo "/swapfile none swap defaults 0 0" >> /etc/fstab

Set the timezone

Install the Network Time Protocol and enable it as daemon:

pacman -S ntp
systemctl enable ntpd

Create a symlink of the timezone:

ln -sf /usr/share/zoneinfo/America/Sao_Paulo /etc/localtime

Generate /etc/adjtime:

hwclock --systohc

Network configuration

Install and enable network management daemon:

pacman -S networkmanager
systemctl enable NetworkManager

So add a hostname to the machine:

echo ThinkPad > /etc/hostname

NOTE: Remember that you can replace ThinkPad with whatever you like.

Add matching entries to /etc/hosts:

127.0.0.1  localhost
::1     localhost
127.0.1.1  ThinkPad.localdomain ThinkPad

Set the root passsword

passwd

Create the main user

useradd -mG storage,wheel -s /bin/bash someone
passwd someone

Finally, change the /etc/sudoers file according to the config that you want to deal with sudo command.

Create a initial ramdisk environment

nano /etc/mkinitcpio.conf

You should the HOOKS field with these things:

...
HOOKS=(base systemd autodetect keyboard sd-vconsole modconf block sd-encrypt lvm2 filesystems btrfs)
...

Finally, recreate the initramfsimage:

mkinitcpio -p linux-zen

Setup the boot manager

Install `systemd-boot` into the EFI system partition

bootctl install

Configuring the loader

On /boot/loader/loader.confinsert this:

default arch
timeout 10
console-mode max
editor no

<details> <summary>Some details about the parameters:</summary>

default: default entry to select;
timeout: menu timeout in second, useful to allow people who have multiple operating systems;
console-mode: changes UEFI console mode;
editor: whether to enable the kernel parameters editor or not. Strongly recommended to set this option to no to avoid bypass root password and gain root access.

</details>

Adding the loader

First install the microcode:

pacman -S amd-ucode

After it, insert on /boot/loader/entries/arch.conf this:

title Arch Linux
linux /vmlinuz-linux
initrd /intel-ucode.img
initrd /initramfs-linux.img
options rd.luks.name=$(blkid /dev/nvme0n1p2 -s UUID -o value)=cryptlvm rd.luks.options=discard root=/dev/mapper/vg-root resume=/dev/mapper/vg-root rootfstype=btrfs resume_offset=$(filefrag -v /swapfile | sed '4q;d' | awk '{print $4}' | cut -d'.' -f1) quiet nowatchdog splash rw

Graphical environment

Install the window manager

First of all, install xorg:

pacman -S xorg-server

Finally, install the xmonad:

pacman -S xmonad xmonad-contrib

Install a display manager

pacman -S lightdm
systemctl enable lightdm

Install a AUR helper

git clone https://aur.archlinux.org/yay.git
cd yay
makepkg -sri
cd .. && rm -r yay

Keyring

pacman -S gnome-keyring seahorse

Terminal

pacman -S alacritty tmux

Shell

pacman -S fish

Image manipulations

pacman -S gimp inkscape

NTFS

pacman -S ntfs-3g

Sound system

pacman -S pulseaudio alsa-utils pavucontrol alsamixer

Other

In order to save the read and write cycles of the SSD and thus extend the lifetime of the SSD, the browser profile can be moved in RAM with profile-sync-daemon:

pacman -S profile-sync-daemon

Finally, enable and activate the service:

systemctl --user enable psd --now

After installation

Enable fstrim

First enable and start fstrim timer. On Arch-based system you can do it running this commands:

sudo systemctl enable fstrim.timer
sudo systemctl start fstrim.timer

After this, if you running with LUKS encryption, you should add some things on the Arch entry from systemd-boot, inside /boot/loader/entries/arch.conf, add it:

...
options rd.luks.name=<UUID>=cryptlvm ... rd.luks.options=discard
...

Reboot the system. And now, you can check if it's running correctly executing this command: lsblk --discard. If has no-zero entries on DISC-GRAN and DISC-MAX columns means TRIM is enabled.

References

Disable `watchdog`

Append on your boot parameters (probably /boot/loader/entries/arch.conf) the following option:

...
options rd.luks.name=<UUID>=cryptlvm ... nowatchdog
...

After it, you can optionally disable the loading of the module responsible of the hardware watchdog, too. Do it blacklisting the related module.

Creating a .conf inside /etc/modprobe.d/ and append a line for the module you want to blacklist with blacklist keyword. Here an example:

# /etc/modprobe.d/nowatchdog.conf
blacklist iTCO_wdt

References

Arch Linux: Improving performance - Watchdogs

Troubleshooting

Thinkpad T14 Gen 1 Brazillian keyboard layout

If you are using this installation on a Thinkpad T14 Gen 1 with a Brazillian keyboard layout (ABNT2) like me, you should use this rule to turns the keyboard usable. You should run this command:

setxkbmap -model thinkpad60 -layout br -variant anbt2

Or just paste the "text" below on the following path: /etc/X11/xorg.conf.d:

Section "InputClass"
 Identifier "system-keyboard"
 MatchIsKeyboard "on"
 Option "XkbLayout" "br"
 Option "XkbModel" "thinkpad60"
 Option "XkbVariant" "abnt2"
EndSection

My first impressions with Neovim

Tue, 18 Jun 2024 00:11:26 GMT

I consider myself a kind of heavy Emacs user. During some time, about 3 years, I was using Emacs as my daily driven tool for literally everything.

I even used it as my desktop manager for some time. And to be honest, I loved it. It's cool to have everything in one place, and seeing all the pieces of the system interconnected, it's cool.

But, I suffered some skill issues when talking about a piece of software that, for me, is important: LSPs. I spend too much time trying to debug performance issues related to Emacs and LSP, and I was not able to find a solution to it, for large codebases it triggers some I/O blocking issues that freeze the entire editor, this wasn't the ideal kind of experience that I wanted. For that reason, I decided to switch to Neovim.

The first attempt

I'm a real fan of editors who bring the ability to have my config and let me do it in a "declarative" way. Neovim is a great example of that. Just put some code into your init.vim (or init.lua) and take some motions. I appreciate it a lot.

Then, I decided that on a weekend I would try to have a minimal configuration for Neovim and let it be my daily driver for the rest of the next week. The idea was just a simple config to bring what I consider essentials to my daily workflow:

Some keybindings to navigate between files, buffers, windows, and tabs.
Some keybindings that improve my quality of life during the usage of Neovim.
An LSP client to have the ability to use the language server of my choice, given all the languages that I try to use.
A cool theme, because I want to be cute.
Some kind of plugin manager, because I think that it's a great improvement to have it.
A plugin that lets me easily know the keybindings of the editor, because I can't remember them all.

The selection of plugins

It was just like 10 plugins, being them:

lazy.nvim, to manage the plugins.
LSP support using lsp-config, mason.nvim, and nvim-cmp.
A theme based on Gruvbox.
which-key.nvim, similar to the Emacs one, to have a list of all the keybindings that have been defined through the configuration.
oil.nvim, to have a better experience navigating through files.
I remapped by myself some keybindings to have a better motion experience using them, mainly for editor/window/file navigation.

It was everything that I wanted, and I think that was the right decision because it gave me some great experience trying to learn more about the native features of Neovim, mainly related to the Vim motions.

Setting up Neovim and documentation

I think that one great feature of Neovim is Lua. Seems to be a great, simple, but powerful language to write code. It has a familiar syntax that can be easily learned if you have a background and don't need any tricks (that was one of my concerns with EmacsLisp, even though I like EL and Lisp in general).

After you have done the right setup and installed at least the plugins related to Lua and their LSP, you can easily code all the configurations to Neovim. For that, I suggest you use the neodev.nvim plugin, which will help you to have a better experience with the configuration of Neovim.

One aspect of Neovim that I missed a lot was the documentation. I don't know if is something related to my mental model, but the :help command from Neovim isn't great compared to the similar one from Emacs. Isn't easier to iterate through the documentation or even iterate through a Lua code to understand if some piece of code is doing what I want, like executing a piece of the buffer or putting a function into a REPL that can be easily used.

Just in case, I know the existence of the :lua command, but seems to be a bit limited through the developer experience to use it, I think that is the most similar feature that we can have in Neovim to compare through the Emacs part. I need to test more the iron.nvim to validate if it gives some kind of good developer experience at all.

But, the thing that I was most during the first days was: documentation and some tooling to easily iterate to understand something on Neovim.

By the way, after I discovered the Telescope help_tags command, turn made it easier to go through the documentation, it helped me a lot to understand some of the concepts and read them. However, I'm still a bit confused about some aspects of the navigation in the documentation.

Daily workflow and motions

In general, my experience using it as my daily editor was surprisingly good. I think that most of the time, it's more related to how easily is to navigate through the files and have some kind of ergonomics to do it. For the first days, I was struggling and being a little upset because the learning curve was a bit steep for motions, I was using the Neovim with a cheat sheet to get at least the basic motions, so I don't look like a gorilla using keyboards and, after a while, I was able to easily use all the simple motions that I needed to do, like those to navigate, to move around the editor, to move to the next/previous line, to move to the next/previous word, etc.

I think that I miss some specific micro-features that I found in other editors, like the ability to move to the previous/next line when hitting the j or k key at the start or end of the line, or the ability to move the line up or down following my cursor, etc. I already saw some custom implementations of all these features, so I think that isn't a big problem, I'll just need to implement it by myself.

But, I still struggle with some aspects of the editor, like the substitutions, the search and replace, the undo/redo, etc. I'll need to better learn how they work to understand it and apply it in the right way easily.

Final thoughts

In general, it was a great experience to use Neovim as my daily driver. It was easier than I expected, and I think that I'm going to stick with it. Although I'm still hitting some issues, I think that all the pros of Neovim are worth it, having a better experience with the editor pay by itself.

If you want to see the configuration of Neovim that I used, you can check it out here. Feel free to use it as a base for your configuration, and if you have any questions, feel free to ask me on Twitter or send me an email.

RSS and why I love it

Wed, 15 May 2024 01:45:37 GMT

Inspired by some discussions through Twitter/X over the last few days, I decided to write about RSS and why I love them. I think it's a great technology that few people know about and I think it's worth learning more about it.

One of the greatest things that the Internet could bring to us is data consumption. Do you already ask yourself how much data we consume compared with the past? How easy is it to just type something into a search engine and get a lot of information about it? Is just awesome.

But, with great power comes great responsibility. And with a lot of information comes a lot of noise. I'm a person who likes to read blogs and learn new things, it's a great hobby and it's cool to see other people sharing their thoughts about something, being tech or not. And by that fact, I, being a lazy person, was thinking so hard about how to keep up with all the blogs that I like to read.

And then, I found RSS feeds. I would say a cool invention from the 2000s that is still more useful for us nowadays than it was in the past. What a great idea would be just to aggregate every blog that you like to read into one place and just read it from there. Simple, but you can see how amazing is it?

The ability to have all those blogs in one place, ensuring that every new update will be there for easy access, being notified about it and also being able to read it offline is just amazing. And that's why I love RSS feeds. It's a simple technology that is still useful for us nowadays and I hope it will be for a long time.

This is my RSS feed reader, NetNewsWire. On that, I have all the things I like to follow: blogs, podcasts, YouTube channels, newsletters, etc. I have more than 100 feeds there and I can't imagine my life without it. All links that you can find on bookmarks come from that feed reader.

Being an ADHD person, I think that having this kind of tool is helpful for me. I let my NetNewsWire open all the time and just read the things that I like when I have time. It's a great way to keep up with the things that I like to read and also a great way to keep my mind busy with something that I like.

I hope you enjoyed this post and I hope you can give a try to RSS feeds. It's a great technology that is still useful for us.

If you would like to follow my blog, you can use my RSS feed that I have here. I am sharing my OPML file (the same one you saw in the image above), if you want some suggestions of cool blogs to follow, you can get them here.

Set up Nix on macOS using flakes, nix-darwin and home-manager

Sun, 03 Mar 2024 19:37:49 GMT

About three years ago, I started using NixOS on my personal laptop. In those days, I needed a config that would allow me to have a stable system, that could be reproducible over all my machines, and that would allow me to have a development environment that would be easy to maintain and to share with others. NixOS comes to fit all these requirements.

But, since I started using a MacBook Pro (2022), I do not feel the necessity of using the Nix package manager, since I can use Homebrew to install all the packages that I need and have some kind of reproducibility with shell scripts. But, for some needs, I would like to use Nix again on my macOS now, and this blog post will be about how to set up Nix on macOS like me.

Installing Nix on macOS

Installing Nix on macOS is easy. You can use the following command to install Nix on your machine:

curl --proto '=https' --tlsv1.2 -sSf -L https://install.determinate.systems/nix | sh -s -- install

This command installs the Nix package manager based on the DeterminateSystem/nix-installer, based on the explanation by the Zero to Nix, it gives better error messages, an installation plan (like Terraform), and other cool features that bring a better installation experience for you.

Just follow the step by step of the installation flow and everything will be fine.

Creating the flake file

After installing Nix, you can create a flake.nix file that will be the entry point for your entire Nix configuration on your machine. This file will be used to define the packages that you want to install, the system configuration, and the home-manager configuration.

{
  description = "Nix configuration";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs";

    nix-darwin.url = "github:lnl7/nix-darwin/master";
    nix-darwin.inputs.nixpkgs.follows = "nixpkgs";

    home-manager.url = "github:nix-community/home-manager";
    home-manager.inputs.nixpkgs.follows = "nixpkgs";
  };

  outputs = inputs @ { self, ... }: let
    nixpkgsConfig = {
      config.allowUnfree = true;
    };
  in {

  };
}

This is the basic structure of my flake.nix, it defines all the inputs that I will need to use in my configuration, they are:

nixpkgs: The main NixOS/Nixpkgs repository, that will be used to define the packages that I want to install on my machine.
nix-darwin: The nix-darwin repository. It brings all modules to configure your macOS system using a declarative way.
home-manager: The home-manager repository. It brings all modules to configure your user environment using a declarative way.

Configuring nix-darwin

After creating the flake.nix file, you can configure the nix-darwin module. You will need to create a darwinConfigurations field on the outputs of your flake.nix file, and add the hostname of your machine with the darwinSystem function.

{
  # ...

  outputs = inputs @ { self, nix-homebrew, home-manager ... }: let
    nixpkgsConfig = {
      config.allowUnfree = true;
    };
  in {
    darwinConfigurations = let
      inherit (inputs.nix-darwin.lib) darwinSystem;
    in {
      machine = darwinSystem {
        system = "aarch64-darwin";

        specialArgs = { inherit inputs; };

        modules = [
          ./hosts/mbp/configuration.nix
          inputs.home-manager.darwinModules.home-manager
          {
            nixpkgs = nixpkgsConfig;

            home-manager.useGlobalPkgs = true;
            home-manager.useUserPackages = true;
            home-manager.users.noghartt = import ./home/home.nix;
          }
        ];
      };
    };
  };
}

In that case, what I'm doing is: creating a new configuration called machine on the darwinConfigurations systems, and declaring some specific properties of that given system, they are:

The system of that machine is aarch64-darwin, which is the system of the new Apple Silicon Macs (MacBook Pro M1).
The specialArgs field is used to pass the inputs to the darwinSystem function. All modules are functions that accept some arguments, the specialArgs field lets you pass new arguments for all these imported modules.
The modules field is used to define the modules that will be used to configure the system. In that case, I'm using the configuration.nix file to define my system configuration, the home-manager module to configure the user environment, the homebrew.nix file to install all the packages that I want to install using Homebrew, and the home.nix file to configure my user environment using home-manager.

Configuring my system

The configuration.nix file is used to define some system configurations related to my MacBook Pro, like user home dir, some extra options related to Nix binaries, and other system-related configurations that you want to declare. In my case, I wrote the following configuration.nix:

_:

{
  services.nix-daemon.enable = true;

  users.users.noghartt = {
    home = "/Users/noghartt";
  };

  nix.extraOptions = ''
    auto-optimise-store = true
    experimental-features = nix-command flakes
    extra-platforms = x86_64-darwin aarch64-darwin
  '';

  homebrew = {
    enable = true;

    casks = [
      "discord"
      "visual-studio-code"
    ];
  };
}

Configuring the home-manager

The home.nix file is used to define the user environment configurations using the home-manager. In my case, I wrote just a simple home.nix file that installs some packages for me. It is like a configuration.nix file but for the user environment.

{ pkgs, ... }:

{
  home.stateVersion = "23.11";

  home.packages = with pkgs; [
    htop
    curl
    coreutils
    jq
  ];

  programs.zsh = {
    enable = true;

    shellAliases = {
      ls = "ls --color";
    };
  };
}

With that configuration, I can install the initial packages that I want to use on my machine using Nix, and gives me the powerful ability of reproducibility in a declarative way.

Building and activating the configuration

After creating all the files, you can build and activate the configuration using the following. You just need to run two specific commands to build and activate the configuration on your machine:

1. Building the configuration

nix build .#darwinConfigurations.machine.config.system

It will build the configuration of your machine targeting the darwinConfigurations.machine outputs. Do not forget of changing the machine of the given name of your system configuration.

2. Activating the configuration

./result/sw/bin/darwin-rebuild switch --flake .

It will activate the configuration of your machine using the darwin-rebuild command. It will switch the configuration of your machine to the new configuration that you have built.

Conclusion

In this blog post, I showed how to set up Nix on macOS using flakes, nix-darwin, and home-manager like I do. I hope that this blog post can help you set up your configuration and let you use Nix on your machine too.

I really love how the Nix package manager works, and I think that it is a great tool to use on your machine since it gives you a lot of power to manage your system and your user environment. You really should give it a try.

If you want to see my configuration, you can check it out on my repository, it's all open source, feel free to use it as a base for your configuration if you want.

If you have any questions, feel free to ask me on Twitter or send me an email. I will be glad to help you with your doubts.

Resources

Implementing Simple Paxos Consensus Algorithm With Rust

Mon, 12 Feb 2024 11:55:28 GMT

What Is Consensus?

I would say that one of the core properties of a system is the agreement on which data are right at a given moment.

At that moment, one of the more important aspects of a distributed system shows up: the consensus. Where every participant agrees on a single state, even if some actor fails.

Some use cases where consensus brings a strong advantage are network agreement in a server cluster, database replicati ons, and even in blockchain networks.

The Simple Paxos

The Simple Paxos algorithm is the most simple implementation of the Paxos Protocol family. As presented by Leslie Lamport on the The Part-Time Parliament and Paxos Made Simple, the idea of the Simple Paxos is simple:

Your node can assume 3 different roles: proposers, acceptors and learners.

Your node can be all these roles at the same time.

An acceptor will accept the first value that is received as a proposal.

A proposer will receive a promise from every acceptor, that promise let the proposer knows that the node will accept the proposed value.

A proposer reach the quorum, that is, the majority, when receive a promise of $N/2 + 1$ where $N$ is the number of nodes in the system.

After reach the quorum, the learners will receive the accepted value from the acceptors. The learners will put the accepted value into their state machines.

(This is a simple sequence diagram coming from Wikipedia, but it's a good representation)

Preparing the proposal for a new value

A proposer is the node that will propose a new value to reach the consensus around their system. In this case, each proposal follows this pattern: (id, v), where the id is an incrementally natural number, and v is the proposed value, for our implementation, we will assume v as a string.

First things first. We need to start our server. In this case, using Rust, I will use Axum to do all the work for me:

use Axum::{
    routing::{get, post},
    Router,
    http::StatusCode,
    extract::{State, Json}
};
use clap::Parser;
use serde::{Serialize, Deserialize};
use tokio::sync::Mutex;

type Ledger = HashMap<Id, Value>;
struct AppState {
    node: Node,
    nodes: Arc<Mutex<Vec<Node>>>,
    acceptor: Arc<Mutex<Acceptor>>,
    proposer: Arc<Mutex<Proposer>>,
    ledger: Arc<Mutex<Ledger>>,
}

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
    #[arg(long)]
    id: u64,
    #[arg(short, long)]
    port: String,
}

#[tokio::main]
async fn main() {
    let args = Args::parse();
    let port = args.port;
    let node_id = args.id;

    let node_http_addr = format!("0.0.0.0:{}", port);

    println!("Starting new node: http://{}", node_http_addr);

    let node = Node::new(node_id, node_http_addr.parse().unwrap());
    let state = AppState {
        node,
        nodes: Arc::new(Mutex::new(Vec::new())),
        acceptor: Arc::new(Mutex::new(Acceptor::default())),
        proposer: Arc::new(Mutex::new(Proposer::new())),
        ledger: Arc::new(Mutex::new(HashMap::new())),
    };

    let app = Router::new()
        .route("/prepare", post(prepare))
        .route("/handle-prepare", post(handle_prepare))
        .with_state(state);

    let listener = tokio::net::TcpListener::bind(node_http_addr).await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

#[derive(Clone, Debug)]
struct Proposer {
    pub id: u64,
}

impl Proposer {
    pub fn new() -> Self {
        Self {
            id: 0,
        }
    }

    pub async fn prepare(&mut self, state: &AppState, value: String) -> Result<Proposal, String> {
      todo!()
    }

    pub async fn propose(&self, state: &AppState, propose: &Proposal) -> Result<(), String> {
      todo!()
    }
}

#[derive(Clone, Debug, Default)]
struct Acceptor {
    pub last_proposal_number: u64,
    pub accepted_proposal: Option<Propose>,
}

#[derive(Serialize, Deserialize, Debug)]
struct Proposal {
    pub id: u64,
    pub value: Option<String>,
}

async fn prepare() -> () {
  todo!()
}

async fn handle_prepare() -> () {
  todo!()
}

Now, we have a server running on the port that we want. You can test it by running:

cargo run -- --id 1 --port 3000

We will implement the proposer logic on the /prepare endpoint. The proposer will send a prepare message to all acceptor messages and wait for the promises.

async fn prepare(State(state): State<AppState>, value: String) -> (StatusCode, String) {
    let mut proposer = state.proposer.lock().await;
    let proposal = match proposer.prepare(&state, value).await {
        Err(e) => return (StatusCode::BAD_REQUEST, e.clone()),
        Ok(proposal) => proposal,
    };

    todo!()
}

In this first phase, we will only send the prepare message to all acceptors. The prepare message is a simple message with the id of the proposal. The acceptor will receive this message and will send a promise to the proposer.

impl Proposer {
    // ...

    pub async fn prepare(&mut self, state: &AppState, value: String) -> Result<Proposal, String> {
        let client = Client::new();

        self.id += 1;

        let nodes = state.nodes.lock().await;
        let reqs = nodes.iter().map(|node| {
            client.post(format!("http://{}/handle-prepare", node.addr))
            .json(&self.id)
            .send()
        });

        let responses = futures::future::join_all(reqs).await;

        let mut promises = Vec::with_capacity(responses.len());

        for response in responses.into_iter().flatten() {
            promises.push(response.json::<HandleProposalPayload>().await.unwrap());
        }

        let quorum = (nodes.len() / 2) + 1;

        if promises.len() < quorum {
            return Err(String::from("Proposal does not receive promises of the entire quorum"));
        }

        let accepted_promise = promises
            .into_iter()
            .filter(|promise| promise.value.is_some())
            .max_by_key(|promise| match &promise.value {
                None => 0,
                Some(value) => value.id,
            });

        // Sorry, I'm not proud of it, but it's the best that I can do for now. :(
        // Feel free to improve it (PLEASE!).
        let value = match accepted_promise {
            None => Some(value),
            Some(payload) => {
                match payload.value {
                    None => Some(value),
                    Some(proposal) => {
                        match proposal.value {
                            None => Some(value),
                            b => b,
                        }
                    },
                }
            }
        };

        let proposal = Proposal { id: self.id, value };

        Ok(proposal)
    }
}

We implement the proposer.prepare method to send the prepare message to all acceptors. What this is doing is:

Calling the /handle-prepare endpoint of all nodes in the system.
Waiting for the promises of the acceptors.
Checking if the proposer received the quorum of promises.
If the proposer received the quorum, it will check if there is a value that was accepted by the acceptors. If there is, the proposer will use this value as the proposed value. If not, the proposer will use the value that it wants to propose.
Return the proposal.

Receiving the prepared value and sending the promise

Cool. We're coming to what we can call the phase 1b. The acceptor will receive the prepare message and need to send a promise if everything is OK. In this case, which things do we need to check?

If the proposal number is greater than the last proposal number that the acceptor received.
If the acceptor already accepted a value, if yes, it needs to send the accepted value to the proposer.

#[derive(Serialize, Deserialize, Debug)]
struct HandleProposalPayload {
    error: Option<String>,
    value: Option<Proposal>,
}

async fn handle_prepare(State(state): State<AppState>, proposal_id: String) -> (StatusCode, Json<HandleProposalPayload>) {
    let proposal_id: u64 = proposal_id.parse().unwrap();
    let mut acceptor = state.acceptor.lock().await;

    if proposal_id <= acceptor.last_proposal_number {
        let payload = HandleProposalPayload {
            error: Some(String::from("The proposal ID is lesser than the last accepted proposal number")),
            value: None,
        };
        return (StatusCode::BAD_REQUEST, Json(payload));
    }

    if acceptor.accepted_proposal.is_some() && acceptor.last_proposal_number == proposal_id {
        let value = acceptor.accepted_proposal.clone();
        let payload = HandleProposalPayload {
            error: None,
            value: Some(Proposal { id: proposal_id, value }),
        };
        return (StatusCode::OK, Json(payload));
    }

    acceptor.last_proposal_number = proposal_id;

    let payload = HandleProposalPayload {
        error: None,
        value: Some(Proposal { id: proposal_id, value: None }),
    };

    (StatusCode::OK, Json(payload))
}

We improved the handle-prepare function to handle all the logic of the acceptor receiving the prepare message, instead of just a todo!(). If everything is OK, the acceptor will return a promise to the proposer. If not, it will return an error message.

Receiving the promise and handling the acceptance message

Now that the proposer received the promise, we need to start with the phase 2a. The proposer will send the accept message to all acceptors. The accept message needs to contain the proposal and their identifier.

Then, the first part of our implementation will be improving the implementation of our Proposer struct. In this case, we will need to add a new function called propose.

#[derive(Serialize, Deserialize, Debug)]
struct HandleAcceptPayload {
    error: Option<String>,
    value: Option<Proposal>,
}

impl Proposer {
    // ...

    pub async fn propose(&self, state: &AppState, proposal: &Proposal) -> Result<(), String> {
        let client = Client::new();
        let nodes = state.nodes.lock().await;

        let reqs = nodes.iter().map(|node| {
            client.post(format!("http://{}/handle-accept", node.addr))
                .json(&proposal)
                .send()
        });

        let responses = futures::future::join_all(reqs).await;

        let mut accepted_promises = Vec::with_capacity(responses.len());

        for response in responses.into_iter().flatten() {
            accepted_promises.push(response.json::<HandleAcceptPayload>().await.unwrap());
        }

        let quorum = (nodes.len() / 2) + 1;

        if accepted_promises.len() + 1 < quorum {
            return Err(String::from("Proposal not accepted by majority"));
        }

        Ok(())
    }
}

This propose function will send the accept message to all acceptors and wait for the acceptance of the proposal. If the proposer receives the quorum of acceptances, it will return Ok(()). If not, it will return an error message.

Now, we need to implement the /handle-accept endpoint to handle the accept message.

async fn handle_accept(State(state): State<AppState>, propose: Json<Proposal>) -> (StatusCode, Json<HandleAcceptPayload>) {
    let mut acceptor = state.acceptor.lock().await;
    if acceptor.last_proposal_number != propose.id {
        let payload = HandleAcceptPayload {
            error: Some(String::from("Node received a proposal with a proposal ID different!")),
            value: None,
        };
        return (StatusCode::BAD_REQUEST, Json(payload));
    }

    acceptor.accepted_proposal = propose.value.clone();

    let payload = HandleAcceptPayload {
        error: None,
        value: Some(Proposal { id: propose.id, value: propose.value.clone() }),
    };

    (StatusCode::OK, Json(payload))
}

Now, we have the acceptor receiving the accept message and handling it. If everything is OK, the acceptor will accept the proposal and return an acceptance message to the proposer.

We will need to add the proposer.propose call on the /prepare endpoint.

async fn prepare(State(state): State<AppState>, value: String) -> (StatusCode, String) {
    // ...

    match proposer.propose(&state, &proposal).await {
        Err(e) => (StatusCode::BAD_REQUEST, e),
        Ok(_) => {
            let client = Client::new();
            let nodes = state.nodes.lock().await;

            let reqs = nodes.iter().map(|node| {
                client.post(format!("http://{}/handle-learn", node.addr))
                    .json(&proposal)
                    .send()
            });

            futures::future::join_all(reqs).await;

            (StatusCode::OK, String::from("Proposal accepted by the majority!"))
        },
    }
}

Removing that old todo!() and putting the proposer.propose call on the /prepare, we have the proposer sending the accept message to all acceptors and waiting for the acceptance of the proposal. If the proposer receives the quorum of acceptances, it will send the accepted value to all learners.

Learning the accepted value

The last part of our implementation is the /handle-learn endpoint. The learner will receive the accepted value and put it into their state machines.

async fn handle_learn(State(state): State<AppState>, payload: Json<Proposal>) -> (StatusCode, ()) {
    let mut ledger = state.ledger.lock().await;
    match &payload.value {
        None => ledger.insert(payload.id, String::from("")),
        Some(v) => ledger.insert(payload.id, v.clone()),
    };
    (StatusCode::OK, ())
}

After learning the accepted value, the learner will put it into their state machines. And then we have the consensus around the system. The acceptor will send the accepted value to the learner, but I think it's easier to implement just sending the accepted value to the learner via proposer.

Conclusion

This is the most simple implementation of Paxos Protocol consensus algorithm. You have some variants that brings some improvements to the Paxos, like the Multi-Paxos and EPaxos. All of these have some properties that are best for specific use cases.

If you want to see the repo with the implementation of this algorithm, you can access it here.

Thanks to hnrbs, one of my inspirations to write this code and learn more about Paxos and consensus. You can see his implementation here.

Embrace The Chaos of Your Life

Sun, 04 Feb 2024 15:23:35 GMT

The last weeks were too hard for me. I need to spend too much time doing things in my personal life and ensure that I can bring good work to my professional life.

For me, when this happens, there are always difficult moments. These moments are always complicated because they impacted me in different areas of my life, which generated a vicious cycle of bad moments and anxiety.

But, the last time that this happened, in the same scenario, I learned a new aspect of life that hadn't clicked for me yet, but it's a too simple idea that someone can ask: "Dude, it's too obvious. Why in the hell you didn't understand it before?". And my answer would be: I don't know.

You need to learn to embrace the chaos happening in your life and use it as a motion to stay on track with the things you need to do. As everyone one day said, life is like a rollercoaster with ups and downs, and you can't avoid the down moments of your life. What matters is how you approach them.

Increasing Your Friction Area

Sun, 21 Jan 2024 14:39:29 GMT

One of the best ways to grow in your life, in any aspect, is by increasing your exposed friction area to experiences. What I call friction area is the "surface" that will be exposed to the reactions you do.

Everything you do in your day compounds your friction area, and everything has feedback. If you let yourself do more things, you'll iterate more over their reactions.

With a bigger surface, you compound what things will happen to you. It's a way to control your life thinking in the long-term game. When you compose your surface area with good actions, you will be more likely to receive positive feedback.

As Sibelius Seraphini said in the article: How to become a Senior engineer faster?, if you want to grow faster in your career, you need to say "Yes" to every new opportunity. It's a way to let yourself live more experiences. With more experiences, you grow faster, and when you grow faster, you'll live better experiences. You increased your friction area, and you're receiving more positive feedback. Positive feedback loops compound.

When Shawn "swyx" Wang said on How to Create Luck, what I called the friction area can be called the "luck surface area" too. It's the same idea. It's more about how you're building habits and a routine that lets you create a strong friction area that brings positive feedback for you.

The idea of "friction area" is a way to bring a mental model that lets you move and iterate faster, building a systematic way to iterate over the feedback loop of your experiences. It allows you to reap the rewards of your actions more quickly and manage them better in the long term.

Now, what are you doing to increase your friction area?

2023 in Review

Sat, 30 Dec 2023 19:52:17 GMT

For the second year, following some of the most inspirational blogs that I follow, I will write about my year, and this time it will be public. Some of the coolest blogs that I follow on a day-to-day basis are doing it, so why can't do it too, right?

I would say that 2023 was one of the greatest years of my life. Like everyone else, I had ups and downs, but the fact that I learned too much in a lot of areas of my life, makes me think that I'm a completely new person from how I started the year. Reading the OKRs that I wrote for this year I consider this idea even more.

It's a good exercise to reflect on what happened this year and prepare for what is coming next, my idea with this post is to finish this year with a golden key and start the next one with all the excitement that I have writing here.

For this post, I will cover some specific topics that I want to share here, they are:

Books and reading
Programming
Job
Writing

Health

I would say that 2023 was not my year for health. I do not prioritize it in a lot of ways, but the three great ones that I think are: food, exercise, and sleep. And the impact of this choice came at different times throughout my year.

Food

I love to cook things and do meal prepping, but I do not spend too much of the year around it. The trade-off was that what I was eating, in general, doesn't have some nutritive benefits, and as we know, what you eat in general is a fundamental part of the rest of your health. The quality of food in general wasn't too good.

Exercise

It has its ups and downs during the year. I tried a lot of times to go to the gym and turn it into a consistent habit because I love to do exercise. I love to run and take walks, it helps me a lot to clean my brain and help me with my thoughts, and it's connected with other aspects like controlling my anxiety and helps in the quality of my sleep. But I don't take the right priority on it and I lose my streak several times during the year.

Sleep

I'm an easier sleep, I don't have any issue trying to sleep and I can easily do it in any place that I want to do. But, the quality of my sleep is awful. Doing some tracking around it, I take just 6 hours of sleeping with an average of 1 hour of REM sleep. I made some improvements in the consistency: like not going to sleep every night around 4 AM and waking up almost all days at 6 or 7 AM.

Books

This was a great year around my reading habit. I proposed to myself to take 12 books and successfully read them until the last day of December. From those 12 books, I read 10. Which, for me, it's a great achievement, considering that I completely lost one of the habits that I most like: the habit of reading. If you want to check which are these books, you can check it on my list of books that I read. For the next year, I already have a lot of books that I want to read, most of them technical books.

One of the core things that I learned from this habit and that I will bring to my 2024 is: that I don't want to read more books, I just want to read those that make me learn something. This is one of the core philosophies that I will follow for 2024, ensuring that it's better to spend time with books that impact my life, like the ones related to self-improvement that bring some cool ideas or those technical ones that are related to a subject of my interest.

Career and Work

A great year related to my career! I had the first opportunity to give a talk, and I learned a lot of cool things in a lot of different subjects, like Math, Distributed Systems, Web stuff, Compilers, and other cool stuff that I have a lot of interest in. I want to write about all these things someday. I started a lot of different projects too, like these:

nero, my tree-walk interpreted programming language written in Rust.
I rewrote my blog in Astro.
Paxos From Scratch, my attempt to learn more about consensus algorithms, also written in Rust;

One thing that I want to bring to 2024 is the ambition to finish the projects that I started one day. I think that considering all these aspects, it was a great year for my career and I expect that 2024 may be the same.

For my work, I continue working at Woovi, for a total of 1 year and 9 months, and I can say that it is one of the best decisions I made for myself. I need to thank every one of my coworkers for this year, I was able to learn a lot not only about the work, but I was able to have some introspective processes thanks to conversations I had with each of them, and what best I could bring to myself. But I'm far from achieving the performance that I believe is ideal for my professional side, and that's exactly what I'm going to look for in 2024.

Writing

I started to write more about my ideas and insights related to things that I like in tech in 2022, but I would say that was 2023 the year where I consolidated it as one of my passions and one of habits that I love to have. Exposing my ideas and my beliefs in words helps me a lot to understand myself and organize my thoughts in a way that seems coherent.

In 2023 I wrote a lot, I have cool blog posts that I wrote both here in this blog or dev.to, like these:

Other blog posts have been written here. You can find them on the respective list. 2023 was a good year for improving my writing skills and knowing how to write for the final user in a good way.

Next steps in 2024?

Well, this was a little about my year in review. I believe that 2024 will be so great than 2023 will be for me, and I hope that can be great for you too.

For 2024, the core aspect of what I want to focus on is health. Believing more and more that having a healthier body and a healthier mind is a core, fundamental piece to have a peak performance in any other aspect of my life. Focusing a lot on what I already talked about before: food, exercise, and sleep.

Meal prepping and cooking are some of the best hobbies that I have in my life, and improving them during 2024 will be great stuff. Even because cooking is a good way to take some rest of the "outside world" and recharge your batteries.

Exercise and sleep will be carefully taken as priorities too. Ensuring that I'll turn it into one of the habits for my new year.

I want to write more too. I have a lot of ideas for blog posts and series that I would like to write and I will move forward to get out of the paper and put it into screens, In 2024 I will write much more.

In terms of other aspects of my life, I want to take more travels with my girlfriend, one feeling that I think I've lost in the last years was the anxiety of discovering new things, new people, new languages, and/or new cultures. I believe that it is an enriching way to grow in life and learn more about yourself and others, and it's the kind of experience that you take for the rest of your life, it's what makes you alive. I already have some things planned on it and others I will discover yet.

The word for my 2024 will be consistency. In every aspect of my life.

I would like to say a big thank you to all the people who played an important role in my 2023. I hope your year was as special as mine. And a special thank you to these people: to my girlfriend who supports me despite my annoyance, I love you too much, to my friends who made my 2023 much better, and a special thank you to Sibelius and Ivan who were essential mentors and friends for my professional and personal growth in this year, thanks for all the advices.

Happy New Year, reader! I hope that 2024 will be so great for you too!

One Year Using Obsidian

Wed, 27 Dec 2023 20:21:07 GMT

On December 26th, 2023, I started my new and current vault in Obsidian, and was one of the best decisions that I could bring to my 2023. Now I'm doing the review around this beautiful tool that follows me in my entire year.

In the last years of my life, I turned more and more of a heavy user of note-taking tools, even those "rudimentar" ones like a pen and paper, I already tried a lot of tools around this subject, like Logseq, Notion, Bear, Apple Notes, Evernote, and finally Emacs with org-mode, when I thought that would be the state of the art of note-taking tools for me, and yes, I think that Emacs with org-mode is one of the best tools that I've used in my entire life. And I used it for about two years, and was good.

Although I like to use org-mode, I always felt that having a tool fits my workflow more easily. I'd like to just put words into a file and push it to a place where I could find it easier in the future. And well, I think that I finally found it.

Obsidian and My Workflow

The powerful philosophy around Obsidian is the concept of File over App that Steph Ango writes about. By the fact that it's just a tool that handles Markdown files in a better way and you can enhance this experience with some community plugins, you can have infinite ways to manage your workflow.

It's one of the core arguments that shows why I think that Obsidian was the best tool for me at that moment, and fit it until now. If I want to move it to another app or build my solution, I just need to handle a bunch of Markdown files and everything will work great, it's a future-proof solution.

My workflow is simple despite the range of community plugins and what you can do inside a vault, I just have six plugins, being them plugins that help me automatize some jobs, such as the Commander, QuickAdd, Templater, and Dataview, a query language plugin, allows me to do some specific tooling in my notes, but avoid it as much as possible.

I try to maintain each note as raw as possible, just with what we can find in Markdown by default because I want to help me to migrate to another software if I need to in the future.

Obsidian and My Learnings

I would say that was an awesome year for my note-taking habits in general. I could develop more about this habit and I can found what are the exact ways that work for me. I don't know everything yet, and every day I try to improve some aspect of this habit, but I saw a lot of improvements in my entire life just by taking some notes during my day.

Some statistics about what I did in my 2023 year with Obsdian:

I wrote a total of 512 notes.
227 of them are daily journaling, which is ~44.33% of my entire vault.
251 of them are related to my Zettelkasten, which is ~49% of my entire vault.
30 of them are drafts of blog posts that I hope someday will be the light, which is ~5.85% of my vault.
I added 107 tags between the files, being the #computer-science the most used tag, with 130 files.

These are some statistics related to my work on my vault in this year, I believe that 2024 will be greater than that.

The major learning related to my adventure with Obsidian was: that note-taking isn't about the tools that you use but about your process. A great process allows you to arrange your notes in a creative, better way that fits your expectations. Regardless of being Notion, Obsidian or just using your pen and a notebook. What matters is your process.

By the way, this is the graph of my Obsidian on the day that I wrote this post, let's see how it will be in the next year:

The Awesomeness of Lists

Tue, 26 Dec 2023 14:28:10 GMT

Lists are a universal tool for productivity, everything can be compound into a list or can be considered one. For example, the post-its that you have in your office wall they can be treated as a list, you can handle it recursively, putting new lists inside a list.

We are presented to lists being a child and they follow us for our entire life, it's an easier way to create a condensed, simplistic way to arrange data to be used. You even can have specific lists that are being written as an ordered way to instruct someone to do something, like a cooking recipe or a tutorial.

You can compound and have a lot of useful data that contextualizes you about everything in a specific scope by doing a list, like me, that does a list about the key points that I want to write about in this post.

The fact that you can build this solution in a lot of different solutions helps us to maintain a lot of lists easier. You can have your supermarket lists written in pieces of paper, a list of blogs that you follow written in a gist in GitHub, or even a thread at Twitter with the list of the coolest blog posts that you read, like me.

Being a forgetful person with a considerably low attention-span, I found in lists an useful, disciplined way to go through my daily routine. I have lists to handle it , like:

What I need to do on my job or at home;
What are the meetings;
What I need to follow-up;
What I didn't do;

These to-do lists helps me to handle my routine in an easier way, helping me to be a more organized person. Furthermore, it gives me an visibility and tracking about the things that I need to do, the urgency of them and I missed on my daily activities or my daily habits.

I also handle more than my daily tasks in this structure, I like to put all my useful resources into it. My notes has a lot of lists around it. For example:

A list for the blogs and podcasts that I like to follow;
What are the tracking of the books that I'm reading (or already read) over the year;
Useful links for articles or tool resources that I believe will be useful at some moment;
And every resource that I believe will be useful for me at some moment.

Lists can express a great range of communication between two or more people, they give you all the insights and the scopes related to a subject. You can structure it like a checkbox of items containing the things that you need to do with their priorities, or like an ordered list containing your favorite cooking recipe, or just an unordered list containing the summary of the presentation of a course.

They are an universal, easily tool of thought that helps us to derive through your day and the entire range of things happening at the same time.

Given this versatility to arrange the content and the fact that you can put everywhere, like a piece of paper, a computer file or even just structuring your thoughts as a list of things, it's what make me an enjoyer of lists and why I think that other people should be too.

This is my ode to lists. Thanks.

I would especially like to thank @Eckzzo and @fersilvaa16 who helped review this post. Thank you very much guys.

My reading list - November 2023

Thu, 02 Nov 2023 14:16:34 GMT

Thinking in Systems

Tue, 10 Oct 2023 01:09:53 GMT

Note: 5/5
Finished: 2023-10-09

Thinking in Systems is one of the best books that I read in 2023. To be honest, I can't absorb all the knowledge that this work writes down.

The idea around all this book is to give you a better idea around how systems works, in a internal, rational way. As an introduction to "non system thinkers", the book proposes to show to you.

With that idea in mind, they will presentate a lot of concepts about system domains and, based on that, it'll introduce a new "meta" mental model that will allow you to see our non-linear world in a better way.

Iterate over your feedback loop

Sun, 08 Oct 2023 17:23:51 GMT

In the last month, I was reading the Thinking in Systems book. It's a good book that clarify some ideas about how to sistematically think in how systems works and the "rational" behind it.

Around the complexity of an entire system. A system can be defined as a network structure connecting pieces that will produces one or more things from it.

One of the core aspects of a system is feedback loop. Everything can cause a feedback loop, and every action can produce a feedback on the system or another system.

A feedback loop is the source of a side-effect that impacts in some change around an aspect of your system. The output of the system can generate a positive or a negative response, this is the feedback of your action. Giving that response, you can use it against your system as the new input, then you validate the new hypothesis and iterate over them. This is what we call the feedback loop.

Thinking that everything that you do is a part of a system, it will help you to identify a set of feedback loops around your actions. But, why is important to have this conscioussness around what you're doing?

Identify the effects of your actions and their responses is a cheaper way to iterate with a clearer idea of your goal. After the feedback, you can adjust your mental model and identify if you're closer to your goal.

Iterate faster over your feedback loops give you advantages, more iterations over your loops give you:

A better understand about where you are. If you're reaching your goal;
A clearer understading around the rules of your system and the path that let you reach where you are;

More iterations implies in a better understading of the system. A more accurate mental model.

See what are the feedback loops around what you are doing.

My reading list - October 2023

Fri, 06 Oct 2023 02:07:39 GMT

My first talk

Mon, 18 Sep 2023 00:14:03 GMT

In the last September 16th, 2023, I did my first talk ever in a meetup. In Belo Horizonte, happened the first JSParty Brasil.

The experience of giving a talk, seeing the public listening to you, they looking for your slides while you explaining the aiming topic is awesome.

The idea behind the talk was to show a presentation about the codemod culture behind Woovi. How we scale refactor in a large codebase (more than 500k LOC) and how we move faster with these refactors.

If you want to see the presentation slides, click here.

My reading list - September 2023

Tue, 12 Sep 2023 21:58:56 GMT

Following the ideas from My reading list and Reading List August 2023, I'll be update this note while reading something that I think that can be useful for myself in the future.

Computer Science

Videos

Brazil Tried to Protect Its Computer Industry

Productivity

History

Historical maps probably helped cause World War I

Economy

Airlines Are Just Banks Now

Biology

What Makes Life Tick? Mitochondria May Keep Time for Cells

Writing things down

Sat, 18 Feb 2023 03:00:00 GMT

How much stuffs did you write down today?

As time goes by, more I believe that you need to write things down more and more. Documenting stuffs is a good way to believe in the long term game.

Writing is a good way to put your thoughts in a paper (or anything else) and validate if they make sense. If you are missing some point that is important to understand all the context behind the subject.

Writing is a good way to align your ideas with other people. Comparing the idea and checking what you don't know yet.

Everyone should write things down. Just write things down.

Simplifying things

Wed, 22 Jun 2022 03:00:00 GMT

Simplifying things is one of the most underrated ideas that people have when doing anything. But understand why you need it and how you can do it can improve a lot of things in your daily workflow.

An abstraction is a nice way to simplify things. But what is an abstraction? It's the process of removing implementation details of the final result. Abstracting things is a process that we, humans, do every day. You don't need to expose every detail from something, abstract it in a way that turns more easily to understand is a good way to do it.

We can talk that automation is a way to abstract things too, in general I agreed with that. But, automate things is a way to turn it more simplified. For example, you can automate your daily workflow in some ways:

Remove spams from your email inbox;
Schedule things in your agenda;
Routine;
Write things;

And lot of other things that you can do to help your daily workdflow. I think that we can agree that it's a good way to simplifcate your day, right?

Simplification as code

But thinking in programming, how we can simplify our model? What things we should do to improve our daily coding sessions? How we can turn our work easier? There are some thigns that we can do to improve it.

One of the things that we could understand is: we don't need every feature from some package, framework, etc. It's a good idea know about the existence of this function, but think if it's really necessary the usage of it on the scope of your project is a way to do simplification even before write a line of code.

An example about it is: did you know that Mongoose (an ODM to handle MongoDb) has a way to manage versions of your documents? If you didn't know, yes. There's a way to do it. The __v is a simple property that stores an incremental integer and the propose behind it is: every time that you change the structure of this document, __v will be incremented.

In some cases, we can treat it to do something based on the version of this document. Write a migration, treat some internal logic or other things like it. But, thinking in your code, do you think that it's a good idea to handle something like it? Thinking in every thing that you need to treat when write a code to handle it, it's a good idea to do it? With every conditional branch, every corner case, every minimal detail that you need to trait when is handle some sensitive data like a document in your database.

When you use a feature of the library, framework or something like that, and doesn't think in the consequences of it, it's the opposite of simplification, you are turn your work harder from now on. You just complicated the work that you or other person will have to do when maintain this code, and over time this work will be more and more complicated because the complexity will grow, and thinking in some months or a year, you or the person that will fix the bug that appears in your code will say that this code has been simplified or not?