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.

I enjoy how the sign on the left says to not carry weapons and to follow traffic laws in all languages, except in German, where it just says that you’re entering the American sector.

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…

LibreOffice Draw works decently well for this.

Hmm, well no, but don’t you still risk being banned or at least being hidden away by the Algorithm™, if such scandalous thing as a nipple is to be seen?

I’m not sure now, if she actually said this is why she’s on PeerTube. Could also be that other social media platforms pissed her off and then she found a new home on the fediverse.

…just remembered, she recently posted a video, where she’s unboxing a Mastodon plush and figured, maybe she says something there, and yeah: Apparently, she got banned from Instagram a whole bunch of times, so now she’s self-hosting Masto and then evidentally also PeerTube.

https://peertube.doesstuff.social/w/qskCWUnsmJZLZ9ZP4KCiph

Yeah, Lety does some NSFW-adjacent videos, which YouTube is too stuck up for.

Most of the stuff posted to video.thepolarbear.co.uk is.

The guy who hosts the PeerTube instance, Hamish, is hardline anti-big-tech, I believe. Whereas Chris Were and Drew / uoou are mostly just tired of YouTube commenters. Well, and there’s some other folks, who occasionally post there, where I don’t know, whether they post to YouTube, too.

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.)

Also requires a plugin, so probably not your thing, but KDE with the Krohnkite KWinScript also works decently well.

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.

That is, like, genuinely an advantage, though. At $ DAYJOB, we have a project that spans embedded, backend, web frontend and CLI, and for all of these, Rust is decent.

Like, I can see why a frontend dev would want to use HTML+CSS+JS/TS (rather than HTML+CSS+Rust), mainly because the massive ecosystem of JS components makes you more productive.

But you pretty much won’t ever develop a web frontend without an accompanying backend, and then being able to use the same language-expertise, libraries, utility functions and model types, that is also a big boost to productivity, especially if you won’t have a dedicated frontend dev anyways.

Realizing that also made me understand why people subject themselves to NodeJS for their backend, which has the same advantage, just with the big ecosystem in the frontend and the small ecosystem in the backend.

Very interesting, thanks! 🙂

Huh, did that emerge out of unrelated design decisions or did they just figure

I know some of my programs used to have lines with just x.unwrap().unwrap().unwrap() or whatever, which is not pretty.

That goes away with experience, though. At least, I can’t think of a reason why you’d nest three Results or Options. Normally, you would collate them right away.

The most you see in the wild is something like Result<Option<_>> to express that a check can fail, but even if it doesn’t, then a valid result can still be that there is nothing there.

If you don’t care that your program crashes (like .unwrap() does), then anyhow is the error handling library of choice. With it, you can just write a ? in place of an .unwrap() for practically any error type. And well, it automatically combines the errors, so you won’t be writing ??? either.

To be honest, I think, they both have their place. In Rust, you typically wouldn’t return just a bool, but rather the element that you removed, so like this:

fn getofmylawn(lawn: Lawn) -> Option<Teenager> {
    lawn.remove()
}

And then with such a more complex return-type, C-style means that you can’t see the function name right away:

Option<Teenager> getofmylawn(Lawn lawn) {
    return lawn.remove();
}

I also really don’t think, it’s a big deal to move your eyes to the ->…

Yeah, I was gonna say, error handling easily makes up 80+% of the code paths, and depending on whether you’re building a library or service or script etc., different strategies are most suitable for how to deal with those code paths.

In a script, you often just want it to crash. In a library, you want to make these code paths matchable, in case the user cares why something failed. And then you have the awkward in-between, which is that 99% of your application codebase will be used by your main-function like a library, but you don’t want to spend as much effort on error handling for that as a proper library does, in particular also because you know what all consumers of your application-library need to know.

So, it’s kind of multiple different problems, with overlap, and people are hoping for one easy solution to cover all these problems.