What I find tricky, is that you’re always describing a work-in-progress. I also wanted it to be useful as soon as possible, so I started building the actual core logic first and documented that part of it.

But to actually use it, you need several steps before, which need to be documented, but preferably automated or ideally eliminated.
So, you kind of don’t want to invest time documenting that, because you know it’ll change a lot still.

And just as well, any quirks you document, it’s always like, okay, but what if I fixed this quirk instead?

Obviously, one has to strike some kind of balance. Things will never be 100% perfect or final. And I am most definitely lying to myself, when I figure that fixing it won’t take much longer than documenting it. But yeah, it’s just a constant struggle to find that balance…

Am vegan. Certainly don’t eat nearly as much as @Carnelian@lemmy.world. But it is a pretty flexible food. Like, I can get soy yoghurt that tastes like the real deal. I can get TVP, which is chewy like a steak. I just had fucking noodles out of 85% soy + 15% chickpeas, and they actually tasted good. And of course, the all-time classic: Soy sauce.

I don’t stan for soy nearly as much as many others, because other legumes and nuts are awesome, too, but you just can’t deny that soy covers a lot of bases quite well.

Yeah, this is one of those issues that I feel separates the seniors from the, uh, less experienced seniors. (Let’s be real, as a junior, you know jackshit about this.)

Knowing when to use an ORM, when to use SQL vs. NoSQL, all of that is stuff you basically only learn through experience. And experience means building multiple larger applications with different database technologies, bringing them into production and seeing them evolve over time.

It takes multiple years to do that for one application, so you need a decade or more experience to be able to have somewhat of an opinion.
And of course, it is all too easy to never explore outside of your pond, to always have similar problems to solve, where an SQL database does the job well enough, so a decade of experience is not a guarantee of anything either…

It’s key-based client authentication. Just open your SSH key’s .pub file in Microsoft Publisher, then export to PDF.

https://wildlife.org/australian-firehawks-use-fire-to-catch-prey/

I do agree, yeah, although I can certainly also understand LISP fans being annoyed that someone created a custom DSL for something that is adequately solved by the LISPs. I’m also certainly not enamored with the Nix syntax myself, but do find it easier to parse than a million parentheses.

But yeah, ultimately the complexity of Nix and Guix isn’t in the particular symbols you type out. The complexity comes from them being expression-based (which does make sense for the use-case, but isn’t as familiar as e.g. imperative languages), as well as just having to learn tons of modules for the different things you want to configure…

Wikipedia seems to do a decent enough job defining it:

Authoritarianism is a political system characterized by the rejection of political plurality, the use of strong central power to preserve the political status quo, and reductions in democracy, separation of powers, civil liberties, and the rule of law.

But basically, my point is:

• If your government represents the people, then it is possible for your people to elect authoritarianism, especially if they are unhappy, like the meme describes, and/or when there’s foreign nations trying to destabilize the system.
• If your government does not represent the people, then it is likely to devolve into authoritarianism on its own, because individuals or individual groups will want to assume all power and limit the rights of others.

Basically, my opinion is that politics is a constant work in progress, no matter the political system.

Both of you could’ve simply named the political system that you think is magically immune to being overthrown, while somehow not being authoritarianism itself.

Don’t think the original LISP is used much anymore, but there’s various dialects like Scheme, Racket and Clojure.

Some examples where it’s used, off the top of my head:

• Lilypond for when you need your sheet music to be turing-complete. Uses Scheme.
• Emacs, for configuring the whole editor. (Has an own dialect, Elisp.)
• GNU Guix, which uses Scheme for configuring the entire operating system.

Obviously, you can also use them for general software development. A few years ago, I read of some project that used Clojure for a larger backend service, with the author gushing all over the place.
Some folks are really passionate about the LISPs, but yeah, not terribly popular in the corporate world…

I feel like the series presents itself as a bit too serious for the kids, too. Especially FF16 with its Game of Thrones vibes pandered to an adult audience. It just doesn’t look like the kind of simple fun that kids tend to enjoy.

You don’t enjoy people talking on your social media, do you?

I’ve kind of standardized on writing it as “Failed to bar when beebbooping, while fadoodling.”

Maybe a more concrete example:

Failed to write file when persisting audio, while recording. Caused by: Permission denied.

The while-part is optional, in case you’ve got a larger context.
Well, so is the rest of it, really. I may just write “Error when beebbooping”, if I believe the error from .bar() to describe itself rather well. Error handling is hard. 🫠

But yeah, you kind of have to describe that an error occurred, rather than purely describing what you want to do, because anyhow doesn’t prefix it or such.

Ah yeah, I was thinking of the “Caused by” shenanigans, which it prints in addition to the stacktrace.

Pretty sure that’s every political system, unfortunately…

Other useful Debug implementations:

• PathBuf and Path will give you the path with quotes and I believe, it escapes any non-UTF8 characters.
• std::time::Duration will give you reasonably formatted output, like Duration::from_millis(54321) will format as 54.321s, whereas Duration::from_millis(321) will format as 321ms. Not appropriate for every situation, but works pretty well for logging.

In my experience, the biggest problem is that maintainable code necessarily requires extending/adapting existing structures rather than just slapping a feature onto the side.

And if we’re not just talking boilerplate, then this necessarily requires understanding the existing logic, which problems it solves, and how you can mold it to continue to solve those problems, while also solving the new problem.

For that, you can’t just review the code afterwards. You have to do the understanding yourself.
And once you have a clear understanding, it’s likely that the actual code change is rather trivial. At least more trivial than trying to convey your precise understanding to an LLM/intern/etc…

Yeah, IPv4 addresses use four bytes. Those four bytes are represented as four decimal numbers, separated by dots. And a byte can only represent the decimal values 0–255.

Everything I implement at work is open source because I don’t want to wait for a purchase approval.

Just to say, though, I feel like 99% of the software we deploy is open-source for that exact reason. Projects generally start out small, where you try to evaluate some concept. You’re not gonna spend months to go through the purchase process of some proprietary tool, if you can help it…