I never said I preferred Outlook to Thunderbird, but both are generally horrible.

It affects Windows 10, too.

The mail server for the accounts I’ve noticed it struggling with is GMail, and it manages to push mail to other clients on my non-Windows devices just fine.

Having the tinkerer options should come after making the software work. From my perspective, Thunderbird is a passable clone of a bad mail client. None of its tweakable options turn it into a good mail client, and so it would be a better mail client than it is had the effort spent on implementing the tweakable options instead been invested into making it generally better.

Desktop mail clients all seem to be dire, but Mail for Windows 10 seemed to suck a lot less than anything else. I, too, am a victim of it not noticing new mail for a couple of hours after it’s sent unless I explicitly refresh it, despite it being set to get new mail on push, but I’d still rather use it over Thunderbird, which I tried years ago, and tried again when they started warning about forcing Outlook onto people. Unfortunately, it looks like Mozilla decided that there were a non-zero number of good things about Outlook, and made a clone of it, as it’s got basically all the things I hate about Outlook.

Yeah, the Wayback Machine doesn’t use Reddit’s API, but on the other hand, I’m pretty sure they don’t automatically archive literally everything that makes it onto Reddit - doing that would require the API to tell you about every new post, as just sorting /r/all by new and collecting every link misses stuff.

The archive sites used to use the API, which is another reason they wanted to get rid of it. I always found they were a great moderation tool as users would always edit their posts to no longer break the rules before they claimed a rogue moderator had banned them for no reason, and there was no way within reddit to prove them wrong.

I think you’ve misunderstood my complaint. I know how you go about composing things in a Unix shell. Within your post, you’ve mentioned several distinct languages:

• sh (I don’t see any Bash-specific extensions here)
• Perl-compatible regular expressions, via grep -P
• printf expressions
• GNU ps’s format expressions
• awk

That’s quite a lot of languages for such a simple task, and there’s nothing forcing any consistency between them. Indeed, awk specifically avoids being like sh because it wants to be good at the things you use awk for. I don’t personally consider something to be doing its job well if it’s going to be wildly different from the things it’s supposed to be used with, though (which is where the disagreement comes from - the people designing Unix thought of it as a benefit). It’s important to remember that the people designing Unix were very clever and were designing it for other very clever people, but also under conditions where if they hit a confusing awk script, they could just yell Brian, and have the inventor of awk walk over to their desk and explain it. On the other hand, it’s a lot of stuff for a regular person to have in their head at once, and it’s not particularly easy to discover or learn about in the first place, especially if you’re just reading a script someone else has written that uses utilities you’ve not encountered before. If a general-purpose programming language had completely different conventions in different parts of its standard library, it’d be rightly criticised for it, and the Unix shell experience isn’t a completely un-analogous entity.

So, I wouldn’t consider the various tools you used that don’t behave like the other tools you used to be doing their job well, as I’d say that’s a reasonable requirement for something to be doing its job well.

On the other hand, PowerShell can do all of this without needing to call into any external tools while using a single language designed to be consistent with itself. You’ve actually managed to land on what I’d consider a pretty bad case for PowerShell as instead of using an obvious command like Get-ComputerInfo, you need:

(Get-WmiObject Win32_ComputerSystem).FreePhysicalMemory / 1024

Even so, you can tell at a glance that it’s getting the computer system, accessing it’s free physical memory, and dividing the number by 1024.

To get the process ID with the largest working set, you’d use something like

(Get-Process | Sort-Object WorkingSet | Select-Object -Last 1).Id
# or
(Get-Process | Sort-Object WorkingSet)[-1].Id

I’m assuming either your ps is different to mine, or you’ve got a typo, as mine gives the parent process ID as the second column, not the process’ own ID, which is a good demonstration of the benefits of structured data in a shell - you don’t need sed/awk/grep incantations to extract the data you need, and don’t need to learn the right output flag for each program to get JSON output and pipe it to jq.

There’s not a PowerShell builtin that does the same job as watch, but it’s not a standard POSIX tool, so I’m not going to consider it cheating if I don’t bother implementing it for this post.

So overall, there’s still the same concept of composing something to do a specific task out of parts, and the way you need to think about it isn’t wildly different, but:

• PowerShell sees its jurisdiction as being much larger than Bash does, so a lot of ancillary tools are unnecessary as they’re part of the one thing it aims to do well.
• Because PowerShell is one thing, it’s got a pretty consistent design between different functions, so each one’s better at its job as you don’t need to know as much about it the first time you see it in order to make it work.
• The verbosity of naming means you can understand what something is at first glace, and can discover it easily if you need it but don’t know what it’s called - Select-String does what it says on the tin. grep only does what it says on the tin if you already know it’s global regular expression print.
• Structured data is easier to move between commands and extract information from.

Specifically regarding the Unix philosophy, it’s really just the first two bullet points that are relevant - a different definition of thing is used, and consistency is a part of doing a job well.

Powershell isn’t perfect, but I like it a lot more than anything that takes sh as a major influence or thing to maintain backwards compatibility with. I don’t think the Unix philosophy of having lots of small tools that do one thing and do it well that you compose together has ever been achieved as I think being consistent with other tools you use at the same time should be part of doing your thing well, and things like sed, grep and perl all having different regular expression syntax demonstrate inconsistency and are easy to find. I also like that powershell is so verbose as it makes it much easier to read someone else’s script without knowing much powershell, and doesn’t end up getting in the way of actually writing powershell as the autocomplete is really good. I like having a type system and structured data, too.

Some of these things are brought to a unixier shell with nushell, but I’m not convinced it’ll take off. Even if people use it, it’ll be a long while before you Google a problem and the solution also includes a nushell snippet, whereas for any Windows problem, you’ll typically get a GUI solution and a powershell solution, and only a maniac would give a CMD solution.

Commands and flags (for native powershell commands) are case insensitive, but the autocomplete both in the shell and text editors is really good, so people typically use it and have it tidy up whatever they’ve written to match the canonical case.

He got upset that there was an X button making it look like he could remove the ads, but it didn’t remove the ads.

There are other rarely-used C+±like languages that fit your criteria, and they basically all aim to eliminate the kind of thing I was talking about. If someone was used to one of those and tried picking up C++ for the first time, they’d probably end up with working, but unnecessarily slow C++, having assumed the compiler would do a bunch of things for them that it actually wouldn’t.

The popular low-level systems programming languages that aren’t C++ are C and Rust. Neither is object-oriented. C programmers forced to use C++ tend to basically write C with a smattering of features that make it not compile with a C compiler, and produce a horror show that brings out the worst of both languages and looks nothing like C++ a C++ programmer would write, then write a blog post about how terrible C++ is because when they tried using it like C, it wasn’t as good at being C as C was. Rust programmers generally have past experience with C++, so tend to know how to use it properly, even if they hate the experience.

I’d say this is pretty dependent on the language. For example, with C++, you need to micromanage (or at least benefit from micromanaging) a lot of things that you can get away without knowing about at all with other languages. That stuff takes time to pick up if you’re self-teaching as you can write stuff that looks like it works without knowing its half as fast as it could be because you aren’t making use of move semantics, and if a colleague is teaching you, then that’s time they’re not spending directly doing their own work. On the other hand, someone with Typescript experience could write pretty decent Javascript from the get-go.

It says few opposite of that, i.e. to try the webapp in Microsoft Edge or Chrome, or use the desktop app.

It’s not unreasonable to think that the inertial dampeners can perfectly compensate for any planned movement, but when you’ve got the equivalent of a hundred nukes going off a few tens of metres away when a torpedo hits, it might take a couple of nanoseconds to react, and that kind of force for a couple of nanoseconds would jostle things about a bit.

It’s easy to look at source code and see that it’s got complicated. It’s harder to work out when it’s complicated because it needs to do something complicated like model something from the real world that’s complicated, or when it’s complicated because it’s accumulated loads of old crap. If you start experimenting with a rewrite, typically it’ll look like it mostly works before you’ve added most of the necessary complexity, and that can trick people into thinking that it wasn’t actually necessary.

There is only one photo. The left pair of sockets is upside down.

One of them’s upside down. That on its own is enough to make them mildly infuriating. The distance from the dartboard wasn’t a concern as the sockets were just below the ceiling, and the dartboard was dartboard-height. I wouldn’t say the environment’s particularly bright - UK sockets are typically brilliant white, and the PVC conduit is also very white, but they’re both a long way from overexposed in the photo.

Usually, because they know a second language, but the first safe country they pass through doesn’t use that language, or because they’ve got a relative living legally in a different country that they think can help them.