orlp invented PDQSort and Glidesort. He collaborated with Voultapher on Driftsort.

Driftsort is like a successor to Glidesort.

Glidesort had some issues that prevented it from being merged into std, and which are addressed in Driftsort. IIRC it had something to do with codegen bloat.

Someone told me that Goldeneye actually supported dual stick controls if you plugged in two controllers. And Perfect Dark is the same engine.

I need to try that out on real hardware…

It’s honestly wild that the core feature of Bartender (hiding icons in the menu bar) isn’t builtin to macOS.

This is a good book on how Google treats production environments at their scale.

Cattle, not pets.

Google operates on a trunk model, according to this:

https://dev.to/tbodt/comment/1j4e

The entire TotT series is pretty good.

An emulator, even a paid one, would be totally legal in the US as long as:

1. It does not use any patented technologies. I’m not sure if Nintendo has any patents in the emulation space, but regardless the GBA is so simple that it wouldn’t require patented techniques to emulate.

2. It does not contain any proprietary (copyrighted) code. On more modern consoles, this would include the BIOS or Firmware files. Does the GBA even need something like that?

Number 1 is a non-issue for a GBA emulator. Number 2 is more tricky, but it’s always possible to reverse engineer and reimplement the firmware. That’s protected by the Compaq v. IBM case.

The recent drama with the Switch emulator is that they violated the second principle.

And my example of knowing critical systems for the web written in Python is somehow different from your argument?

What a joke

You have no idea. Python (and Ruby) are used widely in the industry. Large parts of YouTube are written in Python, and large parts of GitHub are written in Ruby. And every major tech company is using Python in their offline data pipelines.

I know of systems critical to the modern web that are written in Python.

Dynamic typing is not a fad.

Python is older than Java, older than me. It is still going strong.

That’s not “source available” because the software is not released through a source code distribution model.

Companies may have access in order to produce better drivers or handle security incidents, but those are back-room deals, not part of Windows’ distribution model.

I didn’t think the Windows source is widely available, only the compiled form.

.Net core is open source though.

Source Available < Open Source < Free Software

These terms have specific definitions, where each greater term is more specific than the lesser*.

SSPL is in the “Source Available” tier.

The OSI defines the term “open source,” and the FSF defines the term “free software.” The number one term of open source, greater than the availability of the source code, is the freedom to redistribute.

https://en.wikipedia.org/wiki/Comparison_of_free_and_open-source_software_licenses

* Free Software isn’t exactly a subset of Open Source. There are a few licenses which are considered Free but not Open: the original BSD license, CC0, OpenSSL, WTFPL, XFree86 1.1, and Zope 1.0.

Of course Microsoft implemented it “for Windows”.

The Mono project implements many of the .Net APIs in a portable way for other operating systems, including an implementation of WinForms on X11.

OP specifically mentioned that they were using Mono.

Mono has some docs that imply they have implemented WinForms on X11.

https://www.mono-project.com/docs/gui/winforms/

While the tone of the comment is dismissive, they have a point.

It’s not the engineers that are the problem, or even limited to the tech industry. Dark patterns are top-down business decisions, motivated by money.

It’s not that the “tech industry doesn’t understand consent,” but rather that greedy people do evil things. And software is just a low hanging fruit for that kind of business.

The Rust folks know their CS and PL theory. Of course they’ve considered monads.

Python is ergonomic. It’s very expressive without the language feeling too magical.

If you are comfortable “programming with types” then Rust is a very ergonomic language. But it does take a while to get your brain thinking in Rust.

It’s also useful to have counter examples.

C is not ergonomic. You basically have to reimplement collections for different applications.

Jobs? Probably Go.

But really what’s most important is learning portable skills, which amounts to learning about different approaches. In that case, I’d say learn both.

There are a lot of interesting ideas in both languages.

(I learned a lot of great ideas from Go, especially about concurrency. I think it’s great for writing the kind of frameworks where that matters. But in terms of “normal” business logic programming, I think it’s trash. It not ergonomic at all.)

char* fizzbuzz(int n) {
    switch (n) {
        case 0: return "fizzbuzz";
        case 1: return "1";
        case 2: return "2";
        case 3: return "fizz";
        case 4: return "4";
        case 5: return "buzz";
        ...
    }
}