aeneasmackenzie

In haskell they're optimized out, but some delicate work has gone into ensuring that. They're actually faster than alternative methods in some cases, uniplate was rewritten in lenses and got faster and with better type safety as well.

I picked it up briefly to familiarity. You can learn to read it very quickly ("read" here meaning you no longer need to refer to the key so you can increase your reading speed just by reading more). If you're going to learn it consider learning dotsies v3[0] instead. All vowels plus y, and only the vowels, touch both edges which fixes the main issue, that you can't tell abcde apart.

0: https://news.ycombinator.com/item?id=3602163 the bottom link is v3.

How does it compare to a vertical mouse?

It's all of them. You can't give an example of a real number that's not computable.

You can easily do so (usually not that specific representation) but there "are" more reals in the classical construction than you can represent with computations. Constructive mathematics just lets you say "No, this is all of them."

You would need to include irrelevant details. TLA+ is an actual declarative language, so it's not executable, but it can be model-checked.

Philosophy has made progress -- backwards. Most developments since the end of the scholastic era have been failures.

They still have REPLs, which is the relevant part.

TLA+ is only for specification. In one of the papers on it Lamport mentions just putting a copy of the specification in a comment above the implementation. If you get a bug you just need to find where your implementation differs from your specification which he finds is usually pretty easy.

If your code doesn't have a specification (of course usually less precise), fixing bugs is incoherent. How can you say come behavior is a bug?

PostgresQL used to have an unusual bug tracking system: you report the bug, and either someone on the mailing list volunteers to fix it, or it's dropped. It has the advantage that you don't have an ever-growing collection of bug reports.

That's it! Thank you.

A few months ago I saw a program like this that would derive a data structure for you based on what operations you wanted to perform (inserts and queries, for example) but I haven't been able to find it again.

Importantly, this is actually true of the real numbers.

I like Calculus Made Easy because it uses informal infinitesimals. You can make these fully rigorous if you want and they're a much more intuitive technique than epsilon-delta.

EA is, if you read between the lines, a program to maximize deaths from starvation over other causes. Also a form of money laundering, the number of tiers of EA organizations allocating money is always growing. The money goes to employees of charities increasingly.

This operator is (&) in Haskell these days.

Pointless. Here's a version without the restrictions: https://github.com/lerna/lerna/tree/02a2380b8f18c35799600320...

A guided missile is a type of arm, what's the problem?

They are usable for all tasks. What are you going to do with a number you can't compute? Nothing, because you can't do anything with it.

An article by the author on the language:

http://archive.vector.org.uk/art10500710

Are the feces, shattered glass, and tent cities only a minor inconvenience to this person in a wheelchair?

This is actually Central Park theory from The Killing Star.

Here is an "exposed structures and visible thought processes," website: http://motherfuckingwebsite.com