Wait until you learn about the shell specific /dev “files” like /dev/udp and /dev/tcp (which can send/recv IP traffic as if from a file)!

I wish I knew. I work for the government and they even offer to pay for a Duolingo premium to learn French an a trial program, but acknowledge that it’s very much not Quebec french.

I did have some success targeting people from Quebec on Hello Talk, but that’s not really an equivalent app.

Yeah, that and listening to audiobooks read by Quebec speakers has been very helpful. It helps that I’m a sci-fi fan and Jules Verne is incredible. A lot of french audiobooks are free on librivox, though it can be hard to tell who is Quebecois or not.

More specifically look up the term “ablaut reduplication”. There’s lots of great articles and honestly some pretty good YouTube videos on the subject. I’m honestly surprised how great the YouTube linguistics scene is, from Tom Scott’s language files to rob words and name explain (plus nativlang). Hours of infotainment on linguistics for those interested!

Great read. Only constructive criticism I have is a pet peeve of mine that is especially prevalent in type theory articles. In particular it may be worth mentioning the more formal names of some of the types discussed. Trying to map Haskell’s types to other languages can be very tricky and can hinder understanding. Mentioning more googleable names like unit, top, bottom, can be helpful in disambiguation which characteristics are intrinsic to the Haskell type, versus which are properties of the type system in general.

If you read the linked document, it outlines how reverse engineering may fall under a certain level of fair use, e.g. for reasearch and/or backup/archival purposes.

It really isn’t as clear-cut as it seems at first.

Not false at all: https://en.m.wikipedia.org/wiki/Capital_punishment_in_the_United_States

11 solid yes states. Of course Florida is one too.

(obligatory this is satire)

After years, and many languages, I still have to say Ada. Kotlin, Rust, Julia, and Nim are my current contenders to overtake, but here’s what Ada does well enough to still be my preferred tool when appropriate:

• strictness: typically my code works the first time it successfully compiles with few or no bugs. Rust is almost on par in this respect.
• structure: a corollary of the above is that it forces me to “plan ahead” more than just “start coding” which I find fits my programming style better, and leads to better “Unix Philosophy” product designs. I haven’t found any other language that has the same effect other than maybe Haskell.
• speed: I honestly find that Ada code outperforms C/C++ code most of the time. The only times C/C++ outperform Ada is after optimizations that come at the cost of readability.
• multitasking: Ada’s first-class tasks and protected objects are the only way I’ve ever been able to write bug-free concurrent programs that are more complex than async/await and/or producer/consumer structures (and I took a dedicated elective on concurrency at university!). Kotlin is almost on par in this respect with its coroutines.
• hardware: The fact that Ada basically ships with a hard real-time OS built-in and can compile to e.g. AVR means that all my fancy libraries I’ve written or saved work just as well for a desktop game, a website backend, or an embedded microprocessor. Just look into representation clauses and interrupt pragmas to see its unique powers.
• design: The whole design of the language has lead it to be the only language where I can consistently return to a multiple year old passion project with no attempt to write maintainable code, and fully understand what its doing and modify it with little effort.
• tooling: While this is the biggest downside of Ada (see below) gprbuild is still my favourite build tool. I have no idea why strongly-typed build systems aren’t more common. Its always a joy to work in gprbuild, once you get gprbuild working of course.
• static polymorphism: Ada’s generics are some of the best I’ve found. But they have some limitations that leads us into…

There are some situation where Ada shows its age:

• static calculation: I love Nim (and Zig, etc) for the ability to run arbitrary code at compile time. It allows me to describe what would normally be an opaquely initialized data structure or code path in a clear and descriptive manner.
• terseness: Ada is verbose, that’s not such a big deal, but I find its just a tad too verbose which can lead to some slight difficulty when parsing code. func/proc (Nim) vs fun (Kotlin) vs fn (Rust) doesn’t make much difference to me, but function X returns Y/procedure X starts to add a lot of visual noise to a file.
• web compilation: The ability for both Kotlin and Nim to compile to either ASM or JS is AWESOME. If I have to write a “full stack” application, Kotlin multiplatform with ktor every day.
• operator overloading: Only the built-in operators can be overloaded in Ada. It always makes me wish I could overload arbitrary operators. A small thing, but a symptom of…
• TOOLING: Ada’s tooling is BY FAR the hardest I have ever seen to get working. It takes the “eat your own dog food” too far. The fact that even in Arch Linux you have to install a bootstrap package, then the real package shows how hard it is to get a consistent build environment. ALR is helping in this respect, but is still not quite mature in my opinion.

Here’s when I use the alternatives, and their biggest weaknesses:

• Kotlin: anything where I want both one or more JS artifacts and one or more JVM/native artifacts. Weaknesses: performance, static analysis, on the fence about tooling (gradle is cool, but sometimes seems too over-engineered), Biggest weakness: IDE dependency, writing Kotlin outside of IntelliJ is a pain, which is somewhat fair given who maintains it!
• Rust: so close to beating Ada, if not for two things: ugly code - so many operators and glyphs that pollute the reading experience, maybe I’ll get used to it eventually, but for now I can’t scan Rust code, nor pick up and revisit it nearly as easily as Ada; language scale - I find Rust suffers from the C++ design attitude of “we can add this as a language feature” it takes too much mental effort to hold the entire design of the language in your head, which you sort-of have to do to develop software. Java and C are IMHO the undisputed kings in this respect. After reading through the specifications of both languages, neither will ever have any surprises in store for you. There’s no magic under the hood or special case. All the cool features are done by libraries and rely on the same simple syntax. Every time I learn a new cool thing Rust can do, its at the expense of another edge case in the compiler that modifies my conceptual model of the code.
• Julia: multiple dispatch and mathematics plus clean module design and easy unicode incorporation leads to clean code for math-y/science-y code.
• Nim: templates and macros are excellent, concept system gives access to Rust-style traits without all of the additional “ugliness” of Rust, excellent performance, tiny executables. I just find that the syntax can get clunky. The UFCS easily cleans up a lot of the mess that Rust creates with its added features, since it keeps the parsing the same even when using some fancy language feature.

Thank you for attending my TED talk :P. Any questions?

FYI: I’m starting with the outline of the left half of the leaf. I have to go to work soon, but hopefully there’ll be enough outline for the rest to be filled in (just mirror it one pixel over).

Yeah, when I was picking a scale I intentionally looked for one with minimal AA cause I was worried about that. The 180-wide version was full of it, as was the 99.