g___

Suppose O is the oracle for the halting problem.

We create a machine: given a program P, ask O whether P halts given input P and negate the answer.

λP. ~O (P P)

Now we ask whether this machine will halt given its own source code as input. In symbols:

(λP. ~O (P P)) (λP. ~O (P P))

which is the Y-combinator in lambda calculus.

For over a decade, the author of this video has been leading an effort to complete Super Mario 64 with the smallest amount of A presses, often using extremely complex strategies. Here's a 5h video with the history. Bismuth says the history video took roughly 1500-2000 hours.

https://www.youtube.com/watch?v=yXbJe-rUNP8

The videos are old, but the blog series is new, Dec 2023.

This was fixed.

"In addition to targeting researchers with 0-day exploits, the threat actors also developed a standalone Windows tool that has the stated goal of 'download debugging symbols from Microsoft, Google, Mozilla and Citrix symbol servers for reverse engineers.'

The attackers used a 0-day but getsymbol is not one.

Probably because million is unambiguous. Billion sometimes refers to 10^12 rather than 10^9.

At least FreshDesk has an "occasional agents" option (users who are paid per every day they logged in).

https://support.freshdesk.com/support/solutions/articles/227...

This is the only one I remember that matches your description. I also liked "Simple made easy" by the same presenter but it's a completely different topic.

Hammock driven development https://www.youtube.com/watch?v=f84n5oFoZBc

David Beazley: Python concurrency from the ground up https://www.youtube.com/watch?v=MCs5OvhV9S4

You need more than termination to protect against a denial of service; you need to know that a function terminates promptly. Most denial-of-service attacks are about functions that run slowly (e.g. O(N^2) or exponential).

Another interesting paper is "Build Systems à la Carte" https://www.microsoft.com/en-us/research/uploads/prod/2018/0... which explains characteristics of some build systems "static vs dynamic dependencies; local vs cloud; deterministic vs non-deterministic build rules; support for early cutoff; self-tracking build systems; and the type of persistent build information. ... We show that we can instantiate our abstractions to describe the essence of a variety of different real-life build systems, including Make, Shake, Bazel, and Excel, each in a dozen lines of code or so"

Right, you can have rose trees without polymorphic recursion:

data Tree1 a = Leaf1 a | Node1 [Tree1 a]

flatten :: Tree1 -> [a]

But this type needs it:

data Tree2 a = Leaf2 a | Node2 (Tree2 [a])

flatten2 :: Tree2 -> [a]

Tree1 can vary in depth between nodes, while Tree2 is either a, [a], [[a]], [[[a]]] etc.

I've read it and highly recommend it.

Does anyone know books that are similar in style? (conceptual, showcasing different solutions to problems and their tradeoffs, high signal-to-noise)

Related post: Mathematical Embarassments http://rjlipton.wordpress.com/2009/12/26/mathematical-embarr...