Apparently the maintainer trusted the first-time contributor enough to propose tackling another bug.

There is no trust needed when asking someone to fix a bug. It's not like the maintainer would lose anything if the contributor failed to fix the bug.

Besides, I think it is natural to want recognition when you do a lot of work for free. Many other people wouldn't do this unpaid work at all; recognizing their contribution is the bare minimum of good manners. Even in a company where employees are paid for their work, it is customary to give credit to co-workers who have helped you. Most people don't like to work in places where they don't feel appreciated, and that is also true in Open-Source.

No it's not, it is 100% a unit type (except it's not really a type, since you can only use it as return type and nowhere else)

• Svelte/Vue/React components need to be compiled
• JavaScript should be minified if the project has a significant size
• File names should have a content hash, so they can be cashed in the browser
• Even with HTTP/2, there's still a case to be made for bundling hundreds or thousands of JS modules into a single file for better performance
• Bundlers give you a dev server with live reload and hot module replacement for great developer experience
• Setting up Vite is really easy and requires minimal configuration (compared to Webpack, for example)

Easy interop with legacy code is how kotlin took off, so maybe it will work out?

Good interop was a requirement for widespread adoption, but not the reason why programmers want to use it. There's also null safety, a much nicer syntax, custom DSLs, sealed classes, type inference, data classes, named and optional arguments, template strings, multi-line strings, computed properties, arbitrary-arity function types, delegation, custom operators, operator overloading, structural equality, destructuring, extension methods, inline functions and non-local control flow, reified types, ...

Some of these features have since been added to Java.

Actually, it's not a package repository (it doesn't store crates), it's "just" a website to display metadata from crates published on crates.io. It also shows certain information from docs.rs, GitHub, rustsec.org, etc, and has many useful features that the crates.io website lacks, including a pretty good full-text search.

I've been using Manjaro with KDE for a few years now. It works smoothly, I never ran into any issues with it.

The pacman package manager is pretty nice, too, I found it faster and easier to use than apt-get, and the provided packages are always kept up-to-date. Updating the system (even installing a newer Linux kernel) is very simple and works reliably. So you always have the latest version of your apps, the kernel, and the DE.

In the rare occasion that a program is not available in the official repositories or the community-maintained AUR, you can also install snap or flatpak packages.

And since Manjaro is derived from Arch, you can use the Arch Wiki, which is very useful when you want to set up a database, use the android debug bridge, install another package manager, or do anything else less than trivial.

Even if this was true in 2013, when this article was written, the more accurate answer today would be "it depends".

In Rust, there are multi-threaded async executors implementing M:N threading (e.g. tokio), where M asynchronous tasks are mapped to N operating system threads. So when you await, the rest of the function may very well run in a different OS thread.

Swift also has async/await, and like tokio it uses multiple threads to run concurrent tasks in parallel (therefore using multiple OS threads).

Scala's equivalent to asynchronous tasks are Promises, which can also run in parallel, as I understand it.

Kotlin doesn't have async/await, but it has a similar concept, coroutines, which are basically a superset of asynchronous tasks. While Kotlin's coroutines are single-threaded by default, there is a multi-threaded implementation, enabling truly parallel coroutines.

Go also uses coroutines (which it calls "goroutines"), which can use multiple threads.

C++ will soon get coroutines as well, which support multithreading to run coroutines in parallel.

My Fairphone is 4 years old, it has been dropped on the floor (even hard surfaces like rocks and asphalt) countless times. It still works and looks like new. It has a protective cover that covers the edges, but not the screen or the back. It still survived all these years without a scratch.

True, code for critical IT infrastructure should always be reviewed. But from what I understand, this is difficult because there is one full-time developer (paid by the Rust Foundation) and a small number of volunteers, who don't have the time to review all the employee's changes.

When I searched "bitcoin", I found the bitcoin crate, but I had to scroll down a bit.

We have pointers in Rust, too :) see documentation

Microsoft does collect a lot of data. But storing every keystroke is first of all impractical, because it would take a lot of disk space to store every keystroke of every user, and secondly not very useful unless they also knew when, in which application, and in what context each key was pressed.