Márcio Sobel - Blog

Why I switched to NixOS (And why you should, too)

Márcio Sobel — Sat, 28 Mar 2026 00:00:00 GMT

Hello! Recently, I've switched to NixOS, and oh boy it was one of the best things I've done. My system has never been so stable, while so freeing at the same time. I also have a lot more control over it: what's installed, where each config is, enabled services, daemons and so on. The nixpkgs repository is huge. And I do mean it: it's bigger than the AUR!
I will dive in why is it good, it's cons, and whether or not you should use it. First, i'll talk about what even is NixOS and how does it stand out from other Linux distros.

What is Nix?

Before talking about NixOS, let me introduce you to nix. nix is a functional package manager. This means that it treats packages like values in a purely functional programming language (like Haskell). The packages aren't installed where you would expect (like /usr/bin); instead, they are installed in /nix/store. And each package has its own unique subdirectory. Take Firefox for example:

/nix/store/b6gvzjyb2pg0kjfwrjmg1vfhh54ad73z-firefox-33.1/

This hash (b6gvzjyb...) is the unique identifier that will capture all the dependencies of this package. Thanks to the hashing, you are allowed to have multiple versions of the same package at the same time, without having to deal with dependencies conflicting or breaking.
Also, due to the unique identifier, nix is able to remove unused packages using a garbage collector. This means your system always have only what you want!

What is NixOS?

NixOS takes the nix package manager to the fullest, applying it's philosophy to a whole operating system. This means your kernel, drivers, monitor resolution, apps and configuration are all described in a functional, declarative manner.
The system does not follow the FHS standards, meaning there is no /bin, /lib or /usr. Everything it contains is in the nix store.
The system configuration can be found at /etc/nixos/, where you'll find two files:

hardware-configuration.nix: Auto-generated by the operating system. You will probably never have to touch here (at least I hope so!)
configuration.nix: Where your system configuration actually lives. Here's where you tell nix what packages should be installed, what services or daemons should be running, what desktop environment it should use, etc.

Here's an example on how to install git:

# configuration.nix
{
    # ...
	environment.systemPackages = [pkgs.git];
}

...And that's it. If you ever want to uninstall it, you just have to remove the pkgs.git from the list. It's that simple!
But, saving the file won't install git by itself. This would be a nightmare. You have to rebuild your system. And I mean it literally. Running nixos-rebuild will rebuild your whole system, from the ground up, installing or uninstalling any package you added or removed from the configuration, stopping or starting services you've enabled, and so on.
This might be a bit worrying to you, but fear not! Thanks to the nix store, your system is fully backed up before you perform any rebuild. So if you ever, let's say, delete your video driver, you can just select your previous build from the boot manager. To rebuild your system, run:

nixos-rebuild switch

This will rebuild your system, and then change to it immediately (without needing to reboot your machine). You can also easily roll back to the previous configuration using the --rollback argument.
If you want to just see how your changes affect your system without creating a backup (almost like a "throaway" rebuild), you can simply run:

nixos-rebuild test

There are many other ways to rebuild your system, including building a VM, but I will not cover those here. Also, those two are probably the commands you'll run the most, anyway.
Well, that's a simple explanation of how nix and NixOS works. You will probably want to dive deeper, and for that I can't recommend Vimjoyer's channel enough. There, you'll find more about the nix language, how to create modules, how to organize them and everything.

Should you migrate to NixOS?

Pros

First, let me funnel down to who I think NixOS suits best:

Developers

NixOS gives you such an amazing DX. It supports isolated, reproducible development environments, meaning that the argument "it works on my machine" actually means it works. You can think of this as Docker containers, but better! Also, you can use NixOS to declare a server structure, meaning that if you ever change architecture (maybe by switching hosts), you can have all your hosting settings and services up in seconds by copying the old machine configuration.nix file!

Enthusiasts

If you enjoy exploring stuff in tech, such as ricing, creating your own configs, or just tickling around in general, NixOS is a great fit! It's familiar enough to make you feel comfortable, while being different enough to keep things interesting and fun to mess with.

Cons

Now, I think NixOS is not a good option for you if you:

Just want things to work fast

If you just want to download VSCode and want it to work, or if you only use a browser, or even if you find that setting Neovim by yourself "too much work", then I think NixOS is not for you. Setting up NixOS is tedious and takes time. While you can just copy someone else's file to have a solid starting point, I believe that not making the system suit your own needs is not only a waste of it's potential and will only be a frustating experience if you ever want to change something.

Are new to Linux

If you're new to the Linux world, I think NixOS is too much to take. Go explore Ubuntu, Mint, or even Fedora. Then you can dive down into Arch, Void or NixOS. Get a feeling of how Linux works, how it's built to then be able to see how lower-level systems bends it to get the most out of it.

Conclusion

That's it! Maybe I'll make more posts sharing the stuff I find on the system. Meanwhile, you can find my current dotfiles here. See you next time!

Rust is the BEST programming language

Márcio Sobel — Mon, 19 Jan 2026 00:00:00 GMT

You’re probably already tired of hearing that “Rust is safe”, “Rust is the most loved programming language in the world,” “Rust is the future.”
Even though these claims are based on solid foundations, very little is said about the real positive aspects of Rust. I’m going to list a few positive factors beyond the language’s safety, robustness, and speed.

Clear Domain Modeling

Rust allows you to model a domain in a clear and concise way. Enums with superpowers make it possible to define rules that, in other languages, would require much more boilerplate.
Let me give you an example:

enum DownloadStatus {
    Inactive,
    Processing { progress: u32 },
    Error(String)
    Done,
}

Here we have an enum that can give us metadata about a download. In other languages, you’d probably need to create a class with all the necessary metadata (which could be null), and then implement several workarounds to validate things correctly. With Rust, not only is it impossible for metadata to be null, but it’s also very easy to access it, with the guarantee that it’s always valid.

Extremely Powerful Switch Statements

In the programming universe, switch is used to check for equal values. In modern programming, the use of match has become more and more common: a new kind of switch that allows you to use patterns for validation.
Here’s an example of a match in Rust:

let value = 5;
match value {
    0..=10 => println!("Number is between 0 and 10!"),
    11 | 13 | 17 | 19 => println!("Prime number!"),
    n if n % 2 == 0 => println!("Even number!"),
    n => println!("I don't know what to do with {n}"),
}

It’s also possible to do pattern matching in an if. Using the previous DownloadStatus example:

let status = DownloadStatus::Error("Failed to download".into());
if let DownloadStatus::Error(error) = status {
    eprintln!("Download error: {}", error);
}

It may look like just more boilerplate, but enums combined with this kind of pattern matching make the code much more robust and safe as the codebase grows!

Explicit Mutability

Another very positive aspect of Rust is its explicit mutability. Everything is immutable by default:

let x = 10;
x = x * 2; // Code fails here

The code fails because x is immutable. To make it mutable, we need to add the mut keyword:

let mut x = 10;
x = x * 2;

In this example, it doesn’t look like a big deal. But this becomes extremely useful when we’re talking about function arguments:

let mut myText = String::from("Hello, world");
printText(&myText);
changeText(&mut myText);

It’s immediately clear whether a function is going to mutate a variable or not. In C or Go, passing the address of a variable leaves its mutability up to the function’s implementation, forcing the developer to read the documentation or inspect the code.

Macros!

It’s possible to do metaprogramming in Rust — that is, code that writes Rust code. Macros in Rust are practically a whole new language, but the crates syn and quote make the process much more intuitive and fluid. I highly recommend watching this video to understand it better. I won’t go too deep into macros here, I could write an entire post just about them (maybe someday).

Configuration in TOML

I’ll admit it: I love TOML. More than YAML, and infinitely more than JSON. It’s a clear, minimal language, and you can read the entire spec in about 15 minutes. Rust uses TOML to define versions, dependencies, features, formatter configuration... It’s great!

Not everything is sunshine and rainbows

Of course, Rust isn’t perfect. Especially at the beginning, when you have to fight against your own habits to program in Rust. It has several DX issues, like verbosity, long compile times (even in debug), and don’t even get me started on lifetimes. I won't be covering the bads here, only the pros. Perhaps I could make a evil version of this post only talking about the bad side of Rust.

Conclusion

Rust has great fundamentals, a wonderful macro system, and cargo rocks. It’s definitely a modern, robust, fast, and safe language. Winning the title of the most loved programming language in the world for several consecutive years is no surprise. I hope I managed to clearly cover some of the aspects of the language that I like the most, beyond the obvious points from many other posts on the internet (safety, blazingly fast, etc.).
If you’re starting to use Rust in a project, remember to make it very clear that you use it — just like an Arch user (btw). The cult must grow. 🦀

My first blog post

Márcio Sobel — Sun, 11 Jan 2026 00:00:00 GMT

Hello, welcome to my blog. I'm still starting, so my writting skills won't be that high lol. Although, I'm happy to finally have my own place to post my silly stuff.
As for a first post, I've tried to come up with a cool topic to stick to, but it would only make me get stuck on an infinite loop of ideas, so I will start with...

How did I make this blog

The first challenge was how to write. I've ended up sticking with markdown, since I'm already familiar with it's syntax.
Next step was picking were to write. There's lots of options (I thought a lot about using Astro or Hugo), but, since I wanted to have more control on the site itself, I've chosen Nuxt.
Nuxt allows me to not only have control over the site appearence, but this amazing module let me place all of my posts in one directory as well, exatcly what I wanted!
Another really good thing Nuxt allows me to do is group my posts by language. I want to create posts in english and portuguese (depending on my will power).
Also, I remembered that I use Linux (Arch, btw.) and I've created a symlink in my Obsidian vault to the posts directory. This means I can write my posts directly on it!
Well, creating the blog in itself was quite simple, turns out that what was blocking me to create one was only... myself. Now I only need to decide...

What am I gonna do over here?

A blog is not like Twitter (currently X), Bluesky, Threads or any other social media where people post updates; it's a unique, personal corner that does not have any algorithms or content restrictions.
I've always had those moments where I see something cool, or I make something that I think it's cool, that I end up keeping to myself, because I have really extensive tastes that sometimes does not overlap with my social circle. So writting a blog would be a place where I can just yap about anything, put it in a box and let it be. Maybe someone likes it!