Ephera

There can also be circumstances where you have to offer people a natural-looking key for general consumption. You can’t put UUID’s on car plates for example.

Often times, the first section of the UUID is unique enough. With certain UI design choices, one can encourage users to normally work with that, while having the full UUID available in a detail view or from a copy-button.

Another strategy I quite like, is to have the UUID as the definitely-always-unique identifier, and then have a separate name, which either the users can enter or we generate something like random adjective+animal.

But yes, neither of those strategies would work for car plates.

Hmm, interesting idea, to ask the user to provide the overall intent by making them edit/write the plan, since the LLM can’t do intent.

But man, we’ve recently had a number of programming beginners join us in our relatively large codebase, and I’ve basically had to write such a plan, i.e. step-by-step instructions, for them many times.

It just means that I go through the whole codebase and have to think everything through, without doing it myself.
It often took similarly long do that, and formulate instructions, as it would have taken me to write the code myself. Because obviously we’re using a high-level programming language, so there’s not many detail problems which are easier to describe in a natural language.

It’s also incredibly difficult to provide correct instructions that way, since I don’t get to read the existing code while I write the code.
And reviewing their code to figure out what came from it, that binds even more time.

So, yeah, it really doesn’t sound like this LLM thing would save me time either…

You don’t know the circumstances. They might have only seen the query results after several processing steps…

I have no knowledge of NixOS, but:

missing pkg-config file for openssl

That’s relatively common error with Rust dev, unfortunately. You need the pkg-config library installed on your system. On most distros, you install the pkg-config package via the OS package manager and then it works.

Also unrelated but am I correct in assuming that I cannot install KDE without also installing the X server?

Doesn’t work on openSUSE either. I believe, SDDM (the login manager) still makes use of X11.

Just had to look at it out of curiosity and man, it looks like yet another C+=1. The code samples on Wikipedia contain one of those gaudy for-loops and a ternary, as if that was still peak language design four decades after C got published.

But what I seriously don’t get: Why the hell did they develop Go then? That’s yet another C+=1, with even some design similarities to Dart, e.g. it’s garbage-collected but compiles to machine code.
Like, yeah, it wouldn’t be the first time that different teams develop competing products at Google, but what kind of culture leads to there even being demand for two C+=1s?

I would argue so, because Google has quite a reputation for killing projects: https://killedbygoogle.com

Especially with a programming language or framework, you don’t want to invest in it, only to find out that it’s going on the chopping block.

I feel like you could’ve asked “what’s your favorite language?” and gotten the same responses. Like, it’s Rust for me. I could argue that because Lemmy is written in Rust, there’s already some mature libraries to work off of, but someone else could argue that for e.g. Ruby, too.

Well, the alternative to “Rust” here is not another programming language, but rather another game engine.

Because ultimately, most game engines will be implemented in either C++ or Rust, for performance reasons, and C++ itself isn’t terribly better at iteration speed than Rust.

The C++ engines have simply already invested decades into abstractions, like an ECS architecture, higher-level APIs and scripting languages. There’s nothing inherent to Rust which prevents these abstractions from being built into game engines, it just hasn’t been around for that long.

Yeah, that was exactly my intention.

It’s quite common for LLMs to make use of agents for retrieving factual information, because the text processing is just garbage for that.

For example, basic maths is not something you can do with just text generation.
So, you hook up some API or similar and then tell the LLM before the user prompt: “For calculating maths, send it to the API at https://example.com/calc and use the response as a result.”

The LLM can figure out the semantics, so if the user asks to “compute” something or just writes “3 + 5”, it will recognize that this is maths and it will usually make the right decision to use the API provided.

Obviously, the specifics will be a bit more complex. You might need to give it an OpenAPI definition and tell it to generate an OpenAPI-compatible request, or maybe even offer it a simple script that it can just pass the “3 + 5” to and that does the request.
Basically, the more work you take away from the LLM, the more reliable everything will work.

It’s also quite common to tell your LLM to just send the prompt to Google/Bing/whatever Search and then use the first 5 results as the basis for its response. This is especially necessary for recent information.

Yeah, I’d recommend so. Otherwise, it might look like you don’t know the difference between Git and GitHub, which a software developer should.

Yeah, my word choice was quite deliberate there, because there’s this other full-fledged programming language, which is also often less verbose than PowerShell, called Microsoft Java C#.

There is some nuances, which don’t make this quite as hard-cut, but in far too many cases, PowerShell is just an objectively worse choice than C#.

(And I’m not saying that C# is a particularly good choice, but since it can also make use of the .NET APIs, it is particularly easy to argue that it’s better than PowerShell.)

I’m mainly annoyed by Scala not being more popular, because Kotlin is popular (obviously for political reasons) and I really don’t feel like it’s simpler.
Namely, it implements a similar number of features, but because it’s not yet as mature of a language, there’s tons of weird rules how you can’t use these features, because they basically haven’t implemented that yet.

These days, WASM is also an option. I’ve written an SPA with HTML+CSS+Rust. The Rust gets compiled to WASM. There’s a bit of JS under the hood to load the WASM and access the DOM, but that can be generated for you by a framework, like Leptos.

Personally, I think, it’s dumb, because it’s more verbose than most programming languages. I’m normally even a fan of verbosity, but Powershell just feels like using big words when little words would do.

Hmm, not quite sure why Clippy didn’t say anything then. I think, it was a Option<&String> which I had seen as a parameter type. Maybe it doesn’t complain when it’s wrapped in an Option…

Hmm, interesting. The documentation tells me, it creates a new Option value, and allocating memory every time someone just wants to look at a value could be pretty bad.

But I guess, an Option of a reference never needs to allocate memory, because it’ll either be a pointer to a value (Some) or a pointer to null (None). Right?

Well, that explains why it’s technically possible.
As for why Option<&str> is preferrable then:
It hides away your internals. Your caller should only care whether they can get the value or not (Some vs. None), not what the precise reason is. That reason or your internal structure might change.

@larix

I took a very quick look at the code and one thing I noticed, is that you’re using &String.

For a parameter in a function, you always want to use &str instead, as explained here: https://doc.rust-lang.org/book/ch04-03-slices.html#string-slices-as-parameters

I believe, it’s also not a thing to return &String (nor to store it in a struct). I don’t have as solid of an explanation for it, it’s just not something I see much in Rust code (and in the chapter above, they do use a &str as return value, too).
Maybe someone else can weigh in on that.

The same applies for:

• &[] rather than &Vec
• &Path rather than &PathBuf
• &OsStr rather than &OsString

I would also recommend using Clippy. I think, you can just run cargo clippy and it’ll work.
It’s a linter and will tell you lots of code style issues (like using &String as a parameter).
If you’ve never run it, it might spit out a lot of warnings at first, but working through them can teach you quite some things.

You must’ve read that wrong.

The first example, but formatted differently:

let value = "My name is Rho.";
let result = unformat!("My {} is {}.", value);

Now, result contains:

Some(("name", "Rho"))

…because the words “name” and “Rho” in value happened to be at the position of the {}-slots in the unformat!()-pattern.

Hmm, interesting.

And yeah, that is my understanding, too. If an attacker knows that a certain e-mail address has an account associated, they might try to bruteforce the password or send a phishing mail to that e-mail address, which looks like an official mail from Amazon.

I’m guessing, Amazon requires 2FA, which would protect from this to some degree, but still seems unnecessary to hand out information like that.