Except if you think about it, this is possible with smartphones too. They have cameras in the front and the back. The phone just has to be vertical. But docks and holders take care of that. The only thing left is the camera to be recording. Sure there are permission systems. But they're all software. No physical switches or indicators for safety. You won't know even if it's recording. And if it's recording, it will uploading it just as easily. We're addicted to a spy device.

The vast majority of Linux users consider systemd as a good thing because it apparently makes system administration easier. They also don't agree that systemd is monolithic, because it's actually designed modular.

But of course there are detractors. The only thing I like about systemd is its declarative service definition and parallel service startup. But if I wanted to run an OS with bloated and inscrutable software (even with the source code), my choice wouldn't be Linux or Systemd.

I also routinely switch parts of my OS. This is harder with systemd. Although it is modular, the modules are so tightly coupled that it will prevent the replacement of modular components with alternatives. Frankly, I think systemd is killing the innovation in system component development.

Most websites still use standard back ends with RSS support. Even static site generators also do it. The only difficulty is user discovery.

That was only a very rough version. His original plan was to use it as a backend for other VCS. Torvalds handed over the maintainership of the project to Junio Hamano after about 4 months. Much of what we know today as git are contributions from him and others.

None of this is to say that Torvalds didn't invent it. He invented the content addressed object storage format. But it's important to understand the actual history of git's evolution.

You said bugs caused by 'memory problems'. And that Rust programmers vastly overestimate them. Those aren't generic logical bugs that you get in Go or Java. And Rust never claimed to solve logical bugs.

You never reach a phase when you can confidently say that you understand git. But it's certainly possible to go from "When something goes wrong, I just delete the repo and clone it again" to "Aha! Now I can deal with most of the issues".

Mine was when I realized that git commands come in two flavors. Those that deal with commits as snapshots (commit, checkout, switch, reset, etc) and those that deal with commits as changes/diffs/deltas (merge, rebase, cherrypick, revert, etc). (Note: This isn't about how git stores commits on disk). I believe that this is actually the main source of confusion for beginner and intermediate git users.

That sounds like a .... good thing?

PS: I didn't realize wood working and gardening are therapeutic. Sounds like a wonderfully productive solution to a pesky problem.

I didn't advocate for IRC. I'm strongly on the side of forums. But in case you want to compare, IRC is still a better deal than Discord. IRC has loggers and searchable web archives where it matters. Discord on the other hand is holding the conversation hostage. Someday the closed nature of discord will come to bite. The honeymoon isn't going to last forever.

• Ability to search answers without having to join a 'server'

All his other arguments have some meat, though they're debatable. This one statement is the most surprising and probably the only unacceptable stance in that entire article. Rust is just starting to be more widely used - and that success can be attributed to how much people and companies are fed up with bugs caused by unsupervised manual memory management.

C didn't have that sort of machine supervision for safety - but then again, computers simply weren't powerful enough to do the safety analysis back when C was created. Retrofitting an analyzer isn't possible without changing the language completely. But today the situation is different. We have vastly more powerful computers and static safety analysis isn't a limiting factor for newer languages. Insisting that unsafe programming is acceptable is a very regressive stance. Look for a safety paradigm with less cognitive overhead to the programmer? That's worthwhile. But safety is an absolute necessity. If decades of programming has taught us anything, it's that even the most knowledgeable coders can make mistakes with disastrous consequences due to momentary lapses in judgment. There's no justification in not using the computing power at our disposal to catch such mistakes when they happen.

You really really don't need photographic memory for this. I assume you read the article. Now just create a new repo and go explore the .git. Things from the article will immediately make sense. You immediately get a very intuitive understanding of tags, branches, heads, trees, commits etc. Then just give it a rest. Come back after a few days and try it again. After a while, it will be better than any photographic memory.

I found Jim Blandy's Programming Rust to be quite easy to follow. On the other hand, The Rust Book is free. Anyone with C or C++ background will find it quite easy to get started in Rust with any available resource.