In the error monad NaN = NaN (or Nothing = Nothing or None = None, depending on your terminology) because mathematical equality is an equivalence relation. There are many foundational debates about equality, but whether or not it is an equivalence is never the question.
The root of the problem, completely overlooked by OP is that IEEE 754 comparison is not an equivalence relation. It's a partial equivalence relation (PER). It does have its utility, but these things can be weird and they are definitely not interchangeable with actual equivalence relations. Actual, sane, comparison of floating points got standardized eventually, but probably too late https://en.wikipedia.org/wiki/IEEE_754#Total-ordering_predic.... It's actually kinda nuts that the partial relation is the one that you get by default (no, your sorting function on float arrays does not sort it).
> just involves lecturing about the same material over and over again
It doesn't, specifically not in primary education. Also definitely not for subjects with any kind of amount of practical work. Let's see.. foreign languages, sports, physics, chemistry, biology...
Which part of these relevant quotes understand? Or perhaps have counter-arguments?
> shows how low our appreciation of pedagogues has fallen
> Dropout rates for these classes hovered around 90 percent
> learning is a social experience
> an expert is watching you and cares whether you succeed or fail
I beg to differ. Tried to use a kaios nokia 800 tough. Firefox/KaiOS using a stupid kind of webview for every UI, you get two consequences: first, everything is ugly: wrong padding everywhere, complex layout with non-integer number of list items fitting on screen (this is important, vertical list is the primary widget on small screen dumbphones). And second: everything is sluggish. My true "series 30" nokia launches app instantly, whereas i'm sure the SoC is order of magnitudes slower.
So the UX definitely shows complete absence of culture of design in this kind of space (eg gameboy UI design, classic dumbphone UI, ...). Small screens need very simple widgets (most importantly grid and vertical list), hand made paddings and proper space optimizations, most likely some bitmap font tailored to the resolution.. You can't just slap some dynamic layout and expect it to work nicely on such a small screen. Everything vectorized will be both costly and of dubious rendering quality, etc..
And of course these things only have "decent", but definitely not "1 month scale" battery life. I guess LTE is the real culprit here.
> so not exactly the kind of thing you'd notice making a document
By "user interface" I mean (like Martin, in the linked video) the surface language, the way you interact with TeX, its syntax and how it presents itself to the user, the programming model. So definitely the kind of thing you'd notice making a document. Leaky abstractions and footguns are basically everywhere when you write a big LaTeX document.
> I mean TeX is basically an overpowered lambda calculus with a focus on text markup and generation.
No, lambda calculus has capture-avoiding substitution, aka hygienic macro expansion if you will. TeX has naive substitution. By the way, macro expansion is typically CBN, which is very much a rare and weird evaluation order (yes, Haskell, i know). TeX is much closer to some kind of assembly language for a virtual machine.
The user interface / language design. See talk "LaTeX: It's Not You, It's Me" by Martin Haug (cofounder). TeX's language design is at the level of Basic's. Which is in fact not surprising given the timeframe.
Speed and nice error messages in (La)TeX, and to some extent ease of programming, are entirely doomed because of fundamental design choices. Being based on unhygienic macro expansion means that there is only one way to evaluate (the slow way), there will never be incremental compilation (everything can possibly be stateful in horrible ways), there will never be good error messages because there's basically no AST information anywhere (begin/end is a joke).
Regarding ecosystem: tons of undecipherable LaTeX packages are basically one-liners (ok, 10 liners) in typst. I know it from experience: I've written my PhD manuscript in typst. So perhaps one reason why there are so many (basically frozen) packages in LaTeX is because they are so hard to write and maintain.
edit: of course, being only a few years old, typst is nowhere near as solid as TeX, but you can already use it for a lot of things and its a breeze to use.
This! My first actual project (besides some testing) has been my phd manuscript, and after ~2 days i actually had a tufte-style 1.5 column layout going, written from scratch. And its probably like ~250 lines.
There are some rough edges still, the dom model and advanced programming stuff is not quite there yet (user-defined elements, user-defined settables, advanced layout like chaining blocks for laying text flows). But like the quality of the user interface is several orders of magnitude better than (La)TeX.
There are 3 syntactic modes in typst: markup, code and math. In markup, everything is literal, unless you put a `#` sigil like `#expr` in which case `expr` is parsed in code mode. In code mode everything is an identifier, as usual in programming. In math its a bit of an ugly tradeoff but its ok: single-letter things are parsed as literals but multi-letter tokens are parsed as identifiers. Finally, in code you can enclose in `[...]` to parse in markup mode. So typically, your document will be mostly in markup mode and you will encounter stuff like `#something[An argument]`, which is a function call to which you pass one content-typed argument.
So above, `y` is parsed as literal, while `dt` is parsed as an identifier, hence function call.
I got interested into the hashgraph algorithm quite early and wrote a toy implementation in python (in fact discovering an error in the paper in the process). Unless something changed it's entirely useless for open-membership internet-scale consensus. As I remember, the processing time of a message at a node is linear in the number of nodes and same for the local storage at a node, meaning it's not very scalable. Moreover, the nodes must somehow a priori agree on the list of participants of the consensus process, again something which is not realistic for internet-wide consensus. The protocol is quite neat and not too hard to implement but it's similar in scope to paxos/raft: consensus inside an organization, where some things are a priori agreed upon.
Always infuriating to see that people always focus on the his pre-70s (hardcore math) or post-80s period (borderline mysticism ramp up). In the 70s he was most politically active and _definitely_ not delirious in any sense of the word and in fact according to Leila Schneps this is one of the few periods of his life he described as happy, the "sunday of his life" [1]. I translated the '72 CERN talk, its baffling how relevant it is, to this day [2].
Demonstrating how some languages and some compilers are bad at tasks such as writing constant-time crypto routines is fine. Concluding that all compilers and non-asm languages are bad is a non sequitur. Just because you don't want non-branching code to change into branching code doesn't mean you should have to do register allocation by hand. Write simple domain-specific compilers and languages people.