Lucy :3

DOS

LMAO

Though the worst flaw is still there then, which is needing to use Copilot.

Don’t worry, @[email protected] already integrated OpenAI in Emacs.

makepkg won’t even run as root iirc

That’s fucked up

curl ‘https://software.download.prss.microsoft.com/dbazure/Win11_25H2_EnglishInternational_x64.iso?t=9aac58b2-ce2b-404c-af19-2d46a660984e&P1=1767903414&P2=601&P3=2&P4=yELO%2BWbJEvyiRSx%2BuIPm00E5HUK7AkxA50J2smT55F7bCks7t8TQWW8OXgvifN4K%2BUNevu46i%2FD3yO1xXu%2B7OdntJNNd%2BawkcUt5OynkFpvicoo790uCi8%2BVxodUaOKx3h4LWFMsPt%2FoWyUFG45XkDbSecc64mgVuksYivmjUsGQ77zjA%2Bi7XkC8PgKNlaGbIV1R5sHanvrzuzju0F92f%2Fv%2B%2BVfzDaLdDza5FSRiYmUOCoWLg7%2F%2Fj3XTOyniMrTLghlRQY9Dj8nEEz4Hx9n80sTLgypWnX3Vr61xfgacHShbTPhuVdXeMHUBmEVj4sgoWd%2FayrhHnllLUtxEoJ4wUA%3D%3D’ -o /dev/null

Rust:

fn getofmylawn(lawn: Lawn) -> bool {
    lawn.remove()
}

C:

bool getofmylawn(Lawn lawn) {
    return lawn.remove();
}

With Rust you safe 1 char, and gain needing to skip a whole line to see what type something is.

Average Rust code:

macro_rules! sum {
    ( $initial:expr $(, $expr:expr )* $(,)? ) => {
        $initial $(+ $expr)*
    }
}

fn remove_prefix<'a>(mut original: &'a str, prefix: &str) -> &'a str

let mut up = 1;
    'outer: loop {

This is on the level of the esolang I made at 8 y/o, with random characters denoting random actions everywhere, at random positions.

Also looking at Rust. Yeah, I totally like recompiling thousands of crates for a single webapp single-threaded.

Average Rust code:

macro_rules! sum {
    ( $initial:expr $(, $expr:expr )* $(,)? ) => {
        $initial $(+ $expr)*
    }
}

fn remove_prefix<'a>(mut original: &'a str, prefix: &str) -> &'a str

let mut up = 1;
    'outer: loop {

Hell I don’t want to know what you define as ugly then.

Key point being, similar to some random languages. JS and Python Syntax don’t fit a typed and compiled language at all.

Pretty syntax would probably be something like C, where not every single character already widely reserved for specific keywords (like !, ', =) is reused in completely random ways.

From the first syntax examples on Wikipedia:

fn main() {
    let foo = 10; 
    // Suddenly, types are implicit now. A safe language should never have implicit types (now it's the (IDEs) implementations judgement which type that is. Combined with the variable shadowing "feature", this seems like a major clusterfuck. Now the IDE is the sole thing to tell you that you totally fucked up the logic, and both declarations/definitions (well which one is it? Would be nice to always have a direct KEYWORD telling you which type this fucking variable has. But no, the lazy piece of shit Rust 'programmer' left that as an exercise to the dear reader. Because in they just need to leave that part out instead of explicitly stating "I'm a lazy piece of shit" by *instead* typing 'auto'.) This is just Python-level BS. Yes, I also hate C++ for its auto keyword - but at least it explicit.
    println!("The value of foo is {foo}");
    let foo = 20;
    println!("The value of foo is {foo}");
}

fn add_two(x: i32) -> i32 {
// That is, again, the syntax of Python. Why? Because Python is explicitly untyped. So having types be a *literal* afterthought is Ok. They're fully optional anywhere there. Now we're in Rust. They're sometimes optional, sometimes not, but they're always preferred. Yet, they're also an afterthought, seemingly.
    x + 2
    // Implicit statements are bad. Very bad. They so much invite to glossing over stuff, especially when your brain expects to see something else. Also, having every statement ended with ;, except context blocks, but suddenly *not* having statements ending with ;, is fucking ugly (which is the entire point of this rant). It's completly inconsistent. Which in itself is a huge magnet for errors.
}

if x > 5 {
// Now why would you leave the parantheses, which are a major contributor to readability, away. Or even allow this. Rust is just memory safe, like dozens of other mainstream languages, but continues by allowing, promoting and requiring hazardous practices.
    println!("value is greater than five");
}

Now I’m slowly getting annoyed from typing on phone (at least in nvim), and my throat gets clogged with mucus again.

Remember, some of that are subjective preferences and opinions. And the core idea of Rust - fast but safe programs - is good, yet very obvious and not innovative at all, while the syntax and implementation (of cargo (yes I like to wait an hour for a simple webapp to compile because there aren’t binary crates and cargo just doesn’t multicore 99% of the time)) is subpar to something that’s hailed as the savior for everyone and everything by such a large cult.

Literally every single bit of the syntax.

Almost any language is OK, but Rust is just so, so fucking ugly

Did you try virtualizing in i.e. QEMU?

Just don’t have windows installed.

Looks like windows, acts like windows.

“beyond repair” my ass, this is Linux