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.

I also have to say, I feel like many people don’t realize how much dexterity and skill it takes to constantly crank that camera.

The twin-stick camera controls are a terrible solution, even if they may be the best we have. They are a major barrier for entry IMHO. With 2D games, you could hand a controller to someone, who doesn’t play games very much and they’d still typically be able to play along. But with 3D games, that’s so much harder, because now you have to press buttons and move the camera at the same time.

So, I imagine, even when the hardware became available, that various studios still tried to find simpler solutions.

Kind of felt like that last week. Our web-UI would automatically reload when you switched tabs, clearing out what the user had entered into a form. I started debugging, but the build times of our web-UI have been abysmal, making it extremely tedious to sprinkle log statements over the code for narrowing down what triggers the reload.

So, I decided to fix the build times first. The solution wasn’t complex, basically just pull out a module into a separate library to benefit from incremental compilation, but with all the import changes and some additional restructuring, it still ended up being around 2000 lines of code changed.

Then I went back to debugging the reload problem, looked at it for 10 minutes, maybe rebuilt 3 times or so, and then made a lucky guess where I just changed one word for another and that fixed it. 🫠

somewhat logical, but entirely in practice verb-noun command structure.

That’s supposed to be “impractical”, not “in practice”, for others reading along.

For example, the “proper” command to list a directory is: Get-ChildItem
The “proper” command to fetch a webpage is: Invoke-WebRequest https://example.com/

In these particular cases, they do have aliases defined, so you can use ls, dir and curl instead, but …yeah, that’s still generally what the command names are like.

It’s partially more verbose than C#, which is one of the most verbose programming languages out there. I genuinely feel like this kind of defeats the point of having a scripting language in the first place, when it isn’t succinct.
Like, you’re hardly going to use it interactively, because it is so verbose, so you won’t know the commands very well. Which means, if you go to write a script with Powershell, you’ll need to look up how to do everything just as much as with a full-fledged programming language. And I do typically prefer the better tooling of a full-fledged programming language…

Yeah, that’s the funniest thing to me. There’s an actual fruit that we could eat. Instead, we take the seed, roast it, grind it and soak it in boiling water. Then we drink the water.

You couldn’t disrespect the coffee plant more, if you tried.

I’ve been trying to basically build a library that helps you put together a distribution archive.
And my initial plan for the API looked something like this:

Distribution::new("my-program")
    .dir("assets")
    .file("favicon.png", |path| build_favicon(path));  // "|path| ..." is a lambda function that gets the target path passed in

So, it would allow you to define the file structure, and for the parts that actually need to be built, you’d provide a lambda function, which it would automatically run or not, depending on whether the inputs changed.

Right, inputs, what are those? I kind of need my user to tell me. So, I decided to implement the caching as a separate API, which you would call on your own when you get called by the lambda function.

Then I realized, I kind of don’t need the lambda function then. I could just construct file paths and then my user calls their build_favicon(...) function or similar on their own.

There is just one crucial problem with that. This is what the path API in the stdlib looks like:

PathBuf::new("my-program")
    .join("assets")
    .join("favicon.png");

I might not have built anything, really. 🫠

Yeah, fair enough.

Depends on the distro how that alias is defined (if it is defined)…

I just want to say that you’re probably worrying too much about it. Of course, there is lots of things one can do to improve security (which the others here are listing dutifully) and it is foolish to just assume that one’s computer is entirely secure, because as a user, you will always have the ability to bypass that.

But there’s a pretty firm consensus in the IT industry that Linux is more secure than Windows. And that the popular Linux distributions are more trustworthy organizations than Microsoft.

So, it’s good to inform yourself, but if you survived on Windows, you at least should not worry about the Linux side of things. It’s more than fine.

The thing is, producing another copy doesn’t cost you money. So, if you price it at $20 and 4 people buy it, when only one person would have bought it at $80, then you’ve made the same money.

They only decide to put the price as high as they do, because they hope to extract as much money as possible from the fools that buy on release. Then they later put it on sale in hopes of also collecting the money from those not willing to pay $80.
On some level, I assume they know how to make as much money as possible, but the same time, I do feel like the hype around Silksong would be a fraction of its size, if the game cost $80.

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…

It says “global” in the meme, so presumably all of them…

Fish is not the worst in this regard, because:

• The defaults are pretty good, so you don’t typically need a config file for it to be usable.
• As of version 4.0, Fish is (experimentally) available as a single executable for download from their GitHub page. So, even on hosts where you can’t install anything, you may still be able to copy that executable file onto there and use it.

But there may still be situations where it’s annoying, like if you’re working in a container, then you likely don’t want to mount your fish executable every time.

But I also have to say I don’t find it too big of a deal.
I still use Bash for scripting (just throw a #!/bin/sh or #!/bin/bash at the top of your script, like you should anyways), and then for interactive use, not that much of the shell syntax comes into play anyways.
And if I ever do need to copy a complex Bash command into an interactive shell, I can just run bash, then run the command in there and then exit back out.

In the sense that “on the spectrum” is often used to say that someone has autistic traits, yeah. But there would still be a spectrum and everyone would be on it, it would just reach from no autistic traits to maximum autism.

Eh, as much as there’s obviously folks who use certain distros for the fun of it, the vast majority of distros get created to cover a specific use-case. If you have that use-case, then deploying the respective distro brings you so much closer to your target setup than the easy installation of a noob distro could save you time.

I also have to say, many stereotypical noob distros make extremely conservative choices, which makes them harder or scarier to use in various ways, like for example not having filesystem rollback. I cannot imagine going back to that, specifically because I have shit to do.

Damn, this one took a moment…