And the worms are winget.

I mean… that’s not incorrect, but…

>>> len("apt update && apt upgrade")
25
>>> len("pacman -Syu")
11

let you build faster like Python

I have to write so much boilerplate code to make sure my objects are of the correct type and have the required attributes! Every time I write an extension for Blender that uses context access, I have to make sure that the context is correct, that the context has the proper accessor attributes (which may not be present in some contexts), that the active datablock is not None, that the active datablock’s data type (with respect to Blender, not Python) is correct, that the active datablock’s data is not None… either all that or let the exception fall through the stack and catch it at the last moment with a bare except and a generic error message.

I used to think that static typing was an obstacle. Now I’m burning in the isinstance/hasattr/getattr/setattr hell.

@Mods, please don’t delete this. It’s a valuable lesson.

None of the issues you’ve described are Cargo’s fault. The long compilation time is simply rustc’s compile-time checks (ensuring type and memory safety is much more involved than lexing in GCC), and the number of dependencies to compile is a result of the crate ecosystem. Cargo is just the front-end that automates fetching dependencies and compilation with rustc. Blaming it for slow compilation is like hitting your monitor when the computer is acting up.

It’s called a hyperbole.

(edit) But, honestly, it’s still kind of accurate. Many of the most significant software suites that define the Linux ecosystem in more recent decades were written in the 80s or earlier. X (the display protocol) was released in 1984, and X11 in 1987. GNU Emacs was released in 1985. Vi, in 1976. UNIX System V, from which sysvinit and compatible init systems were adopted, was released in 1983. It’s not a stretch to say that certain people want to regress to the 1980s state, even if the kernel wasn’t around.

Off the top of my head, in no particular order:

• Systemd and its components are responsible for too many essential system functions. Init, services, mounts, timers, logging, network config, hostname, DNS resolution, locale, devices, home directories, boot, NTP sync, and I’m sure there are others, can be handled by systemd or one of its components.
• Systemd violates the UNIX philosophy of “do one thing and do it well”. Systemd is a complex solution to a complex problem: this thread has several comments by a former Arch Linux maintainer that explains why they’ve switched to systemd, and why the earlier method of using single initscripts was unsustainable.
• It is owned and maintained by Red Hat, known for its many controversies.
• Some people just don’t like modern things and think that the Linux ecosystem peaked in the 1980s.

Most (though not all) of the popular complaints are completely unreasonable. Those people usually see themselves as moral and righteous and expect the world at large to follow their personal creed. I especially consider the UNIX philosophy to be outdated, and strict adherence to it to be an obstacle for modern apps and systems.

I have some issues with systemd, and I don’t like that one for-profit company has such a massive influence over the entire Linux ecosystem, but I have to acknowledge that it works, it works well enough to counter my personal issues, and that the people whose opinion matters the most (specifically Debian and Arch maintainers) chose it for a good reason.

Both harmonicas and bagpipes produce sound by passing air over one or multiple reeds (tuned to resonate at specific fundamental frequencies), inducing oscillations in the reeds, which modulate the air flow. Bagpipes use pipes to amplify the sound, and harmonicas use the cavity between the reed plate and the body, and often the player’s hand.

A digital keyboard that doesn’t produce sound is just a fancy human interface device.

“Shell scripting (various languages, both POSIX-conformant and nonconformant)”

You need to pad that CV with meaningless acronyms!

At the end of the day, every instrument is just a mechanical-to-acoustic transducer with a resonating body to selectively amplify the desired notes and harmonics. The real question is whether a jackdaw qualifies as a sandwich.

Magnus the Red when Emps told him to sit on his crimson ass and do nothing:

The technique is called steganography, and the product is called stegomalware. The payload is concealed as part of some legitimate file, like the pixel data of an image file. It requires the reader software on the targeted system to already be infected, or to have a vulnerability that the payload can exploit.

Low Level video: https://www.youtube.com/watch?v=89ysXVYH2Sk (one more reason to hate Webp)

Quick example by John Hammond: https://www.youtube.com/watch?v=JBIbL8zwZOs

Because someone in the 1970s-80s (who is smarter than we are) decided that single-user mode files should be located in the root and multi-user files should be located in /usr. Somebody else (who is also smarter than we are) decided that it was a stupid ass solution because most of those files are identical and it’s easier to just symlink them to the multi-user directories (because nobody runs single-user systems anymore) than making sure that every search path contains the correct versions of the files, while also preserving backwards compatibility with systems that expect to run in single-user mode. Some distros, like Debian, also have separate executables for unprivileged sessions (/bin and /usr/bin) and privileged sessions (i.e. root, /sbin and /usr/sbin). Other distros, like Arch, symlink all of those directories to /usr/bin to preserve compatibility with programs that refer to executables using full paths.

But for most of us young whippersnappers, the most important reason is that it’s always been done like this, and changing it now would make a lot of developers and admins very unhappy, and lots of software very broken.

The only thing better than perfect is standardized.

OMZ is overrated. It’s too much code for too little effect when most of the plugins boil down to aliases and prompt themes, and all you have to do is source them in your .zshrc anyway.

I am by no means saying that the plugins and themes are useless. I’m saying that OMZ is unnecessary.

deleted by creator

People with deep knowledge of string instruments and/or shell languages are rapidly approaching your location.

This isn’t about some feature of the language being good or bad. It’s about Rust being ugly or not. The things I mentioned will always look ugly in the source code.

Enums and nested blocks. I understand the importance of Option and Result, but it’s fucking infuriating when I have to check and destructure the result of every function call and either bubble the result up the stack from six levels of nested if let blocks or risk Cloudflaring my program by using .unwrap(). And while I like being able to extract a return value from an if...else expression, the structure gets really convoluted when multiple if and match blocks are nested (of course each one returning a value), and it gets completely fucked once closures are introduced.

I like Rust, but calling it pretty is delusional.

Unauthorized port scanning. If your job involves networking or cybersecurity, you’re contracted to do pen-testing, or your activities are limited to a network you own, you’ll be fine.