The handbook is outstanding. Read as much of it as you can. Even if you’re not a Void user, you’ll learn so much!

https://docs.voidlinux.org/

It’s really annoying. It no different from people who go into Linux forums and talk about how much they love Windows.

Void Linux uses runit, for example. Here’s the documentation they provide on how to use it: https://docs.voidlinux.org/config/services/index.html

It only takes 5-10 minutes to read and understand how to manage all your services and write your own. Simple and fast. If only systemd were this easy!

Ubuntu is doing stupid things with packages, replacing them with their proprietary packaging system (called Snap). It has been controversial, the way that they are pushing it, especially since the Snap server is proprietary and non-open source.

A lot of people won’t consider using Ubuntu at all for this reason alone, and it makes sense - when you consider that there are so many other distros to choose from these days, Ubuntu just doesn’t really provide a whole lot of added value anymore.

There are a lot of other helpful replies in this thread, so I won’t add much, but I did find this reference, which you could read if you have a lot of free time. But I particularly liked reading this summary:

• _start calls the libc __libc_start_main;
• __libc_start_main calls the executable __libc_csu_init (statically-linked part of the libc);
• __libc_csu_init calls the executable constructors (and other initialisatios);
• __libc_start_main calls the executable main();
• __libc_start_main calls the executable exit().

Reserving main is definitely more hacky. Try compiling multiple objects with main defined into a single binary - it won’t go well. This can make a lot of testing libraries rather convoluted, since some want to write their own main while others want you to write it because require all kinds of macros or whatever.

On the other hand, if __name__ == "__main__" very gracefully supports having multiple entrypoints in a single module as well as derivative libraries.

Is it? I really don’t think so. What can you propose that’s better? I think if __name__ == __main__ works perfectly fine and can’t really think of anything that would be better.

And you don’t have to use it either if you don’t want to anyway, so no, I don’t think it’s that much of a hack. Especially when the comic compares C as an example, which makes no sense to me whatsoever.

Can you put some milk on the algorithm please?

B-b-b-but my convenience!!!

Daniel Stenberg (author of curl) has written a little bit about his journey working on curl: https://daniel.haxx.se/blog/2020/10/26/working-open-source/

I now work for wolfSSL. We sell curl support and related services to companies. Companies pay wolfSSL, wolfSSL pays me a salary and I get food on the table. This works as long as we can convince enough companies that this is a good idea.

The vast majority of curl users out there of course don’t pay anything and will never pay anything. We just need a small number of companies to do it – and it seems to be working. We help customers use curl better, we make curl better for them and we make them ship better products this way. It’s a win win. And I can work on open source all day long thanks to this.

Of course you can. Instead of committing the code to a repository, you just take screenshots of the everything and commit that instead.

But was this a reversion of the previous commit…?

I’ve never had the chance to use a functional language in my work, but I have tried to use principles like these.

Once I had a particularly badly written Python codebase. It had all kinds of duplicated logic and data all over the place. I was asked to add an algorithm to it. So I just found the point where my algorithm had to go, figured out what input data I needed and what output data I had to return, and then wrote all the algorithm’s logic in one clean, side effect-free module. All the complicated processing and logic was performed internally without side effects, and it did not have to interact at all with the larger codebase as a whole. It made understanding what I had to do much easier and relieved the burden of having to know what was going on outside.

These are the things functional languages teach you to do: to define boundaries, and do sane things inside those boundaries. Everything else that’s going on outside is someone else’s problem.

I’m not saying that functional programming is the only way you can learn something like this, but what made it click for me is understanding how Haskell provides the IO monad, but recommends that you keep that functionality at as high of a level as possible while keeping the lower level internals pure and functional.

If you ever feel useless, don’t forget that both true and false have manpages in Linux.

They even have --help and --version flags in case you need them.

Can we push back the deadline for the apocalypse? Have we talked to the customer to see if this is a possibility?

Looks like there’s been plenty of recent updates to me: https://github.com/void-linux/void-packages/commits/master/

Sorry to hear about the network manager issues! I could be wrong on this, but I think Gnome is not the best supported DE in void - possibly because of how heavily tied it is to systemd. I wish I could help, but I still configure my wifi using wpa_supplicant.conf. Maybe dbus wasn’t setup properly?

Regarding audio, the pipewire documentation for Void is pretty good. It’s pretty thematic of the whole Void linux experience: you have to read the handbook and follow its steps closely, but it’s very well written and easy to understand. It can definitely be time-consuming as well though.

Void is definitely all the things you mentioned. I installed it on a few machines, the first in early 2020 and it has never given me an issue. Extremely stable and boring. I’m impressed that it has so many packages in its repository, but that’s a testament to how well xbps is written. But there are a few things missing since it’s fair from the mainstream, including packagekit. I had never heard of it before you mentioned it - I found a fork on github to support it, but it doesn’t look very well maintained.

As one of the dozens of Void Linux users, I too find this very offensive!

(But hey, at least we’re getting some attention, which is nice…)

Yes, the install process is difficult to perform. But once you do it, you’ll feel like a wizard. You learn so much from the process if you do a manual chroot install. It helps you understand how the installation process for other distros like Debian works. If you have some free time, I would recommend trying it in a virtual machine.

The comic states that Firefox is a crown jewel of open source, not the crown jewel.

That said, I agree that if I had to pick only one, it would definitely be Linux over Firefox.