Yeah, the latter is certainly a big part of it. The way to make it compile-safe is to use macros to generate code, so that my users can write e.g. Package::my_frontend.version and that gives them the version of their frontend package.
Writing such macros, i.e. writing code to generate code, is certainly something I haven’t done a ton of yet, because you practically cannot justify doing that in an application codebase, only in a library, so it is new stuff that I learn.

But well, you did already call it a “nice abstraction”, which is another big part where my excitement comes from and where I think, the special nerdery is necessary.
Others might build projects which are visually tangible, like a sexy GUI, or which do something tangible, for example a colleague (who I will absolutely not deny his own special nerdery) is currently building a driver for a motor. If that driver works, you can see a motor moving in the real-world. Even non-nerds can at least tell that something is happening.

But with my project, my success is that you can write Package::my_frontend instead of Package::from_str("my_frontend")?. And that if you rename the package to super_duper_frontend, that the compiler will tell you to fix the code rather than it only breaking once you actually run the build code for the frontend.
No chance of explaining to non-coders why this is exciting or even just when you’re successful.

On Monday, one of our students at $DAYJOB asked me what projects I do in my freetime. After I infodumped on her for half an hour, she asked in disbelief “And you do these in your freetime, without being paid?”.

Like, mate, did you not listen how feckin’ excited I got just then? Of course, I do these in my freetime.

To be fair, though, the last project I told her about is very dry. It’s a library to help automate CI builds. And the thing I’m thrilled to build is a compile-safe API for accessing the packages in your workspaces. Like, yeah, it does take a special kind of nerd to get excited about that…

I mean, Rust does have a pretty inclusive community…

Ah, I think, I know what you mean, that the format is supposed to be written with foolish oversimplifications that are borderline incorrect, whereas “secured by TLS” just sounds like a normal statement from an expert…

I’m guessing that was supposed to be “secured by a thin layer of TLS”…

AI slop turned into ASCII art. That’s a new one…

Yeah, I virtually only use --force for moving tags around (which one could definitely argue isn’t really a thing you should be doing regularly either)…

Yeah, we always try to automate as much as possible with generic language build tooling and scripts, so that ideally the call in the runner is just a single command, which can also be triggered locally.

Unfortunately, if you want to be able to re-run intermediate steps, then you do need to inform the runner of what you’re doing and deal with the whole complexity of up-/downloading intermediate results.

--force-with-lease* 🙃

You often just want to go with what’s popular, since hardware vendors will only provide APIs for select languages.

Well, and depending on the field, you may need to get certifications for your toolchain and such, so then you have to use what’s popular.

In my corner of the embedded world, it feels like everyone is practically jumping to integrate Rust. In the sense that vendors which haven’t had to innovate for 10+ years will suddenly publish a Rust API out of the blue. And I’m saying “out of the blue”, but I do also regularly hear from other devs, that they’ve been pestering the vendors to provide a Rust API or even started writing own wrappers for their C APIs.

And while it’s certainly a factor that Rust is good, in my experience they generally just want to get away from C. Even our management is well aware that C is a liability.

I guess, I should add that while I say “jumping”, this is the embedded world where everything moves extremely slowly, so we’re talking about a multi-year jump. In our field, you need to get certifications for your toolchain and code quality, for example, so lots of work is necessary to formalize all of that.

Yeah, particularly the broadcasting really irks me.
That is an opinion you can hold for yourself and then make compromises as you encounter reality. I do expect programmers to hold strong opinions.

But when you broadcast it, you strip yourself of the option to make compromises. You’re just saying something which is going to be wrong in one way or another in most situations. I do expect programmers to be smarter than that.

The problem is that it sounds like a riddle. In a riddle, you’re traditionally supposed to work within the rules that you’ve been told. So, not thinking outside the box here is not an indication that the person isn’t capable of doing so.

Of course, if I encountered this problem in real life, I’d ask Carol from accounting to check the other room, while I flip the switches. But my instinctive answer was that it is not possible, because I assumed it to be a riddle and the provided rules did not allow a solution.

I mean, there is a reason why that is so pervasive. It makes you set up the dev environment and figure out how to run a program, which is a step that you cannot skip.

Of course, you should go for a slightly more complex project afterwards.

To be fair, you can also somewhat steer whether it will take off as a dev, by how you promote it and how much time you take to make it easily usable by others. Many devs really don’t care to have their passion projects take off, because it means you’ll likely spend less time doing your passion thing, more time doing user support.

I almost expected someone to learn that just from me posting. 😅

Basically, OpenOffice used to be organized by Sun Microsystems. Then Sun got bought by Oracle back in 2010.
Oracle does not have a good reputation at all, so the OpenOffice devs from back then figured they’d need to take things into their own hands and set up The Document Foundation to organize further development. But the OpenOffice trademark was owned by Sun/Oracle, so they had to rename and get a new homepage and everything. The name they chose is LibreOffice: https://www.libreoffice.org/

After the OpenOffice project was effectively dead, Oracle handed it and its trademark over to the Apache Foundation, where it’s seeing occasional bug fixes. But to my knowledge, they don’t even have the capacity to fix all the security problems.
All the actual feature development happens over on the LibreOffice side.

So, in practice, if you want OpenOffice, what you really want is LibreOffice.

Yeah, not great. You always hope that projects under a larger foundation, like GNOME, have a higher bus factor¹, but unless that foundation has dispensible income to pay someone, you’re ultimately still reliant on volunteers and not many people volunteer for maintenance.

What the foundation can do, though, which is also really important, is to hand over the keys to a new maintainer, should you disappear over night.
Like, yeah, forking is great, but some people will never learn of the fork. It happens about once a year that I find someone online who’s still using OpenOffice and that project has been practically dead since 2011.
So, I do hope we can get more open-source projects under some sort of umbrella. No idea how to actually do that, though. I also have open-source projects where I would not even know where to start to get them under some organization…

I really don’t agree with saving keypresses being a useful metric, since auto-completion is a thing and code is read significantly more often than it is written. I am also a staunch opponent of abbreviations being used for variable names.

But I will say that I don’t mind abbreviations in keywords, since well, you need to learn the meaning either way.
And yeah, I’ve come to somewhat like them being used for keywords, since it reduces visual noise where it really isn’t useful, and it distinguishes keywords from actual code.
Ultimately, keywords are just syntax where letters were used instead of a symbol. You do read them like a symbol, so if they don’t look like a real word, that seems to work quite well for my brain.

Well, you’d typically put the loops into a function and then do an explicit return to jump out of there. I believe, there’s some use-cases where this isn’t possible, which is why I’m cool with loop labels existing, but I’ve been coding Rust for seven years and have not needed them once…

I’m not sure, what you mean by “Chekhov’s footgun”, but well, it isn’t a footgun, so you won’t accidentally return a wrong value from the function, if that’s what you’re thinking.

It’s not a Rust invention, most functional programming languages have implicit returns, but basically think less of them as a function return and more just as the value that a scope evaluates to.

So, here’s a simple example:

let sum = {
    let x = 5 + 9;
    3 * x
};

Obviously, this is an extremely contrived example, but yeah, as you can see, it does not even have to involve a function. The implicit return makes it so that sum is set to the result from 3 * x.
And the scope-braces are nice here, because you can do intermediate steps without having x in scope for the rest of your function.

In practice, if you see scope-braces and the line at the end does not have a semicolon, then that’s the value that the whole scope evaluates to. Those scope-braces can also be the braces of a function, but then you need to annotate what the function is going to return, too, so it’s practically impossible to return a wrong value.

Well, and I would actually argue that explicit returns are a footgun in comparison.
Because someone might introduce clean-up code at the end of the function and not realize that an explicit return skips that clean-up code, somewhere further up in the function.
The implicit return always has to be at the end of the scope, so it’s not possible to accidentally skip code.