While they don’t write it explicitly I think they’re looking for a good junior developer, given that:

• they are not asking for Rust work experience, instead for good Rust knowledge and experience with open source development, both of which you can obtain on your own if you’re a competent student

  • but also, is there even anyone that has experience in Rust and compiler/interpreter/typesetting development and is looking for a job? If they did require that almost nobody would qualify and the cycle of “I don’t have experience for applying to this job to get experience” would continue

• 57k€ is not a bad salary for a junior developer in Europe

• the two founders have graduated recently (~3 years ago) and have been working on Typst since then (their master thesis was on creating Typst itself), so it’s likely they are looking for someone like them.

Linus got it right, it’s just that other userspace fundamental utilities didn’t.

Where I live there are a lot of “temporary” 30km/h speed limits that were never removed by the road workers after the work was completed.

A slightly better metric to train it on would be chances of survival/years of life saved thanks to the transplant. However those also suffer from human bias due to the past decisions that influenced who got a transpant and thus what data we were able to gather.

And then Discord arrived

The comparison with Discord makes non sense, the feature seems to be just a normal group chat, like the ones in Telegram/Whatsapp/iMessage. Discord’s killer feature is the ability to have multiple channels within a server, which allows more organization.

Even in english this isn’t true, for example dots can appear inside a sentence for multiple reasons (a decimal number, an abbreviation, a quotation, three dots, etc, etc), which would make you split it into more than one piece.

I’m also surprised “disk space usage” isn’t an issue for many. I just cleared out dozens of GB of disk use by Rust, and I had to fix my CI/CD to clear itself properly.

For me it’s just a matter or clearing the target directories used by older rust releases when I upgrade every 6 weeks. cargo-sweep is a godsend for this task

Well, but then you’re basically just pushing the mutability onto the container

That’s the point, when programming with immutable structures you always pass the mutability onto the enclosing structure.

It’s a good strategy at times though. Like say you’re working in a language where strings are immutable and you want a string you can change. You can wrap it in a list along the lines s=['foo'] and pass references to the list around instead. Then if you go s[0]='bar' at some point, all the references will now see ['bar'] instead.

A list is an antipattern here IMO. Just wrap it in some dedicated object (see e.g. Java’s StringBuilder).

What you need here is not the stability in memory (i.e. of pointers, which you lose when you recreate an object) but instead just the stability of an identifier (e.g. the index into a list).

It’s not open-source, stop spreading disinformation. The core of the product are the model weights and no source is provided for them, making them irreproducible. This is as open source as distributing a single exe file because after all you can read the assembly code, no?

Insanity is when you lose or can’t access your 2FA device and you’re locked out of your account.

What? You can easily escape from it if there are better alternatives you can use.

So there is no general escape hatch.

Pointing at one language and saying it is not easy to code like it is another language is a pointless argument.

I’m not arguing that it is easier to code in C# than in Rust, just that this particular escape hatch is possible in C# and not in Rust. It’s just an observation.

They all differ for good reasons and as long as you can solve similar problems in both, even if in different ways then what does it matter that you cannot do it in the same way?

It does not really matter, but does it have to?

You dont write code like this in rust.

I perfectly agree, that would be horrible code! I would generally try to restructure my code, making it better fit the actual lifetimes of the data I’m working with. The point in the article is that you can’t really escape from this. I’m not arguing this is a real problem, and I don’t think the article is neither, just pointing out that this is something you can easily do in C# and not in Rust. It’s just a difference between the two languages.

I can agree that the example function is not the best usecase. But the point still stand that there’s no realistic escape hatch from lifetimes and memory management in Rust.

Cow does not work when you are actually required to return a reference, e.g. if you’re working with some other crate that requires that. Cow also has some more strict requirements on reborrows (i.e. you can reborrow a &'short &'long T to a &'long T, but you can only reborrow a &'short Cow<'long, T> to a &'short T).

LazyLock can solve very specific issues like static, but is not a general escape hatch. Again, the example is not the best to showcase this, but imagine if you have to perform this operation for an unknown amount of runtime values. LazyLock will only work for the very first one.

(Note that I’m not the article author)

In this example, you could have just made a constant with value 0 and returned a reference to that. It would also have a 'static lifetime and there would be no leaking.

I believe the intention was to demonstrate something that works with runtime values too, and a constant 0 does not.

Btw you can just write &0 to do what you proposed, there’s no need for an explicit constant/static.

Can’t those be installed in toolbox?

If your goal is to just .await some future that require the Tokio runtime you can use the async-compat crate.