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.

By “unit”, you probably mean a SystemD unit, right?

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.

Hmm, interesting, thanks!

Yeah, I get called a tankie on the regular now, just because my user account is on .ml and I still don’t actually know what it’s supposed to mean. Apparently, I’m supposed to have political opinions on topics that I’m significantly more ignorant on than the people who call me that.

Yeah, but anyone willing to implement shaders for Luanti can just contribute it to the game itself. Then you wouldn’t need to do anything to get the support.

A friend recently told me that they have a fig tree and an orange tree at home, which don’t normally grow in our climate.
Then she said that they had to bring them inside for the winter, so I thought, makes sense, but how do you move a whole tree inside?
And then she added that the fig tree is now stood in their living room.

I had so many questions, but started out by saying that it sounds cool to have a proper tree in your living room. Only then did she point out the somewhat crucial detail that they’re still tree saplings. 😅

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…

The Rust compiler is more sophisticated than most compilers, so it can be slower at the same kind of tasks. But it also just does a different task here.

One of the tradeoffs in Rust’s design is that libraries get compiled specifically for a concrete application. So, whereas in most programming languages, you just download pre-compiled libraries, in Rust, you actually download their source code and compile all of it on your machine.

This isn’t relevant, if you get a pre-built binary. And it’s not particularly relevant during development either, because you get incremental compilation. But yeah, if someone wants to compile a Rust codebase from scratch, then they have to sit through a long build.

Yeah, the good tooling also means it isn’t even terribly difficult for the dev to provide builds, but it isn’t quite as automated as publishing to crates.io, so many don’t bother with automating or manually uploading…

Yeah, as I’m implementing this, I’m also now noticing how problematic that crate split is.

If you want to generate code which uses (non-generated) types that your crate provides in its public API, you have to re-export the macro from a separate crate that also re-exports the types.
That in itself is clunky, but it’s just complexity for the implementer, not the user, so it’s fine.

But where it stops being fine is that this means you cannot easily provide a usage example in the macro’s documentation.
If you try to use it like normal, it has to generate code referring to your API crate, which will not be defined in your macro crate, so the documentation test won’t compile.

So, basically your choices are:

• Do some hacky horseshit, where you try to re-define the public API in the usage example.
• Provide a usage example, which is not checked for compile errors.
• Provide a usage example on the module that re-exports the macro rather than on the macro itself.
• Don’t provide a usage example.

And yeah… if you’ve coded Rust for long enough, you will recognize these patterns of bad/missing usage examples, which is particularly problematic, because proc-macros are rarely terribly obvious to use. Really hope they can fix this sooner rather than later.
As far as I can tell, it would even be a valid fix, if editors and such consistently showed the documentation declared on top of the re-export, then you could write out your usage example there.

Oh man, I think it’s been taken offline, but there was a video podcast thingamabob on PeerTube, where two dudes would wax philosophically about politics, which they called “Dagoth Hour”. 🙃

(The main baddy in Morrowind is called “Dagoth Ur” and he likes to wax philosophically.)

Originally, they were made from the marshmallow plant, by the way: https://en.wikipedia.org/wiki/Marshmallow#History

But yeah, the modern-day formula is quite different and rather highly processed…

2. ß isnt used when you have a pair of s letters next to each other. Its most commonly used if you have long vowels beforehand. See “Trasse” vs “Straße”.

Perhaps worth adding that we had a spelling reform in 1996, which kind of put this rule in place.
If you learned German before then or had a teacher who learned it before then, it’s possible that you got taught it the old way…

Usually, the desktop environment devs come together and standardize on something. But yeah, someone has to drive that effort. Open-source isn’t really something you plan, you just need someone to push for it.

Oh yeah, I’m not saying this is what makes Rust special. Rust’s strength in comparison to Bash is that it’s a lot more competent at control flow and structuring programs. But yeah, virtually any programming language is at least better at that than Bash, so whichever one you’re most comfortable with, is probably the best choice. This trick just allows you to make use of Bash’s biggest strengths, which is easily running commands and piping between commands, while also having the competent control flow and structuring of your programming language of choice.

“I think proc macros are a really big superpower for Rust.”

Yeah, been working on a framework and proc-macros are really useful to simplify the API.

For example, previously I needed users to define a struct and then an impl block with a function inside. Well, and they need to do that a lot, so it was genuinely a bit of a pain to write out, but it also made the code feel more complex than it really was.

Now I’ve got an annotation, which you can slap onto a function and then it generates the struct from the function parameters and puts the function into the impl block.
And while you do need to be aware that the function parameters will be put into a struct and therefore you want owned parameters, all-in-all it still feels really nice to just delete dozens of boilerplate lines and an indentation level in the codebases where I’ve introduced it.

One of the simplest tricks is that you can throw down a function, which you can call with a command like e.g. this: run("cat /etc/os-release | grep NAME")
by constructing a Command like so:

Command::new("sh")
    .arg("-c")
    .arg(command) //the string passed as parameter

There’s proper libraries to make running commands even easier and more robust, but if you don’t want to pull in a library, that’s really easy to write out ad-hoc and gets you 95% of the way there, with shell piping and everything.