Ephera

I haven’t actually taken such a course, but I imagine it’s stuff like how much you’re allowed to load, how to secure it, on what surfaces you can drive etc…

I mean, as it says at the end, this blog post is in good fun. It most definitely expresses frustration, but it also recognizes that perfect is the enemy of good, and that you already put in more effort than one can expect by writing a tutorial to begin with.

I guess, my main takeaway is that you really don’t need to bother writing up your life story. It will fly over the head of your readers, for sure. (Although a bit of context may still be important.)
And you should probably spend a few more words, describing the actual steps, no matter how obvious those may seem to you.

Here in Germany, it certainly isn’t. You need to take like a dozen theory lessons and then a test…

Man, I don’t know what kind of CLIs this guy is building, where you need to keep long-lived references around and whatnot.
CLIs are typically quite easy to build in Rust, because in most cases, you just load your ~/.notes, iterate over the files/lines once, print out the result and then exit. I have a hard time coming up with a scenario where building an in-memory (!) tag index benefits you in a CLI.

As for When to abstract, you particularly want to deduplicate code that implements logic (as opposed to boilerplate code).
It’s much more likely for this kind of code to require changes or bug fixes over time and therefore for the separate versions to drift apart.

I’ve also found that you should still lean strongly towards deduplicating code, because it isn’t just you who needs to know to change both versions of a code snippet. Your colleagues need to know, too, including those who join the project later. And the chance of this working out as intended, is practically zero. If you have duplicated code, you need to assume that multiple versions of it will exist.

Huh, it really is like spoken English after all.

This isn’t supposed to be readable code, by the way.

I actually doubt that somewhat. The language models do still go off of words to a large degree.

As the other comment said, outside the browser WASI is what does IO. As for DOM access in the browser, I doubt they want to reimplement the DOM API, because:

• It’s insanely complex. This wouldn’t be done within one release, but rather take years to add a substantial amount of APIs.
• No one wants to have to maintain two versions of the DOM API documentation. You’d need to basically translate the entirety of MDN to some WASM API description. And in the end, hardly anyone would read it either way, because they’re likely using some wrapper library to interact with the API.
• If you’re using such a wrapper library anyways, it hardly matters to most people, whether this library generates JS API calls or some WASM API calls.

I try to stay as far away from JS as possible, and I do not think it’s worth developing a WASM DOM API. With a competent framework, you can develop complex web-UIs without ever touching JavaScript, which is good enough for me.

Jujutsu is a Git frontend, from what I understand, much like there’s tons of Git GUIs. So, you interact with it in a different way, but you still push to a Git repository and others can interact with your code by using Git.

I guess, it somewhat lessens the grip of Git, because they can hook different backend services (e.g. Subversion, Mercurial, Fossil) into this frontend, and from what I understand, they plan to develop an own backend eventually. But yeah, for now, the communication standard is still Git.

That uniform actually looks extremely binary…

Yeah, I kind of respect the stance, because it knows what it wants to be, but I also wrap number types into a separate data type to document that maybe you shouldn’t multiply a port number by the wheel count and pass that into the temperature parameter, because I want more fine-grained typing, not one-size-fits-all.

Groovy will automatically convert integers into objects, as it sees fit. And one such case is when you assign null to an integer.

There’s some more languages, which try to treat primitive types like objects, to make them more consistently usable. As I understand, nullability is a big part of the reason why it can’t be solved with syntactic sugar, so presumably this would be possible in all those languages.
If I’m not mistaken, Ruby is another one of those languages.

I believe, that would mean that any 0 is equivalent to the null pointer, since the null pointer is just memory address 0…

I do agree, yeah. If we would have auto-detection, I’d want a manual override to be implemented for sure.
It’s a CLI, so it wouldn’t be too bad to add a --browser=firefox flag or similar, but it just makes it even more obvious that this feature only adds complexity, because we would have two solutions when we hardly needed one.

We currently have a semi-serious project at $DAYJOB, like we’re basically allowed to work on it as a team building thing. And one guy who’s tugging along has ten years more programming experience than me, but no experience with the programming language we’re using, so he’s been generating everything with LLMs.

He knows to write unit tests and well, the programming language in question is Rust, which’s strict compiler prevents lots of bad code from happening. So, this isn’t your stereotypical vibecoding.

But …yeah, it’s still been challenging to work with.

Yesterday, the guy built a feature which basically gives the user instructions how to create a bookmark in their browser. There’s a few ways to implement this:

• You don’t. Our userbase is gonna be technical, they probably know how to do that.
• You show the instructions for all browsers and let the user pick which instructions to follow.
• You ask the user interactively what browser to set up and then show them only the instructions for the chosen browser.

Right, and apparently the fourth way to implement this, which the LLM generated, is to detect what the default browser of the user is.

Leaving aside the problem that some users will want to set up different browsers than their default browser, how do you implement that? Is there some nice, cross-platform API for it? Well, if there is, the LLM didn’t know about it.
And neither are there nice APIs per operating system. On macOS and Linux, it runs some random commands to access this information. On Windows, the generated code looks at the Registry.

All of this is absolutely horrid to maintain. I do not want to be testing on each OS separately. I do not want hundreds of lines of code for a feature that’s not actually needed. And the worst part is, the guy should know this. He has the experience.
But I’ve seen the guy when he chats with an LLM, just falls into an absolute trance. Does not surprise me that he’s unable to take a step back to think, if this even makes sense to do…

Ah, fair enough. Not sure how to do that then.

I was gonna say, I feel like the current method does a good enough job documenting that validation has happened, but I guess you do want it reflected in the structure of the type, so that the code that takes the information from the struct can safely make the assumption that some of the options don’t exist. And then, yeah, it would be nice to not need a separate parsing step for that.

Just to note, I disagree entirely. Even in commercial development, it’s the core premise of agile development to ship features early and continuously integrate feedback. Granted, lots of companies claim to do agile without actually doing it, but it’s at least not a law of nature what you’re describing.

But with this not being commercial development either way, I really don’t feel like you can make any predictions. If the volunteer that implemented this sees your bug report, they could decide to drop everything else and fix that, because they get to pick their own priorities. They might have the solution in their head right away and it doesn’t take them long at all to implement. Or someone new to the project might decide this sounds like a good issue to get started with.

Clap has dependent options and mutually-exclusive argument groups built-in: https://docs.rs/clap/latest/clap/_derive/_tutorial/index.html#argument-relations

For the environment-specific requirements, you can use compiler feature flags…

Yeah, a few years ago, a friend handed me their iPhone to see, if I could find an option they were looking for. And I was genuinely appalled at how slow everything felt, solely due to the animations. Like, iOS has objectively better UI performance, but then they chose beautiful over usable with the animations and that makes it feel worse in many ways.