Since gravity is the curvature of spacetime, quantizing gravity would mean quantizing spacetime (or quantizing geometry) also, which would lead to their being smallest units of space and time, perhaps somewhere around the Planck length and Planck time.
This reminds me a bit of a Clojure library called Plumbing (formerly Graph): https://github.com/plumatic/plumbing. It also let you create a DAG for structured computation. It was used for a web service, at that time.
Research into belief perseverance shows that even when people are shown overwhelming evidence contradicting one of their beliefs that they dig in their heels and stick to the belief anyway. [1]
There's also Frank Lunz's observation that many people form opinions based solely on the emotive content of the words (Russell conjugation [2]) they're presented with, regardless of the facts. [3]
Libraries like this enable differentiable programming, which lets you backprop through more than just neural networks. For instance, people have built a differentiable raytracer and plugged a physics engine into reinforcement learning to accelerate training.
There were only two professors I was on a first name basis with in college. One was my advisor, I also worked in his lab for two years. The other was another professor in the department. It was different in grad school. It was first names for professors you worked with. At that point, they don't know more than you do about your research.
> The current way to get a lot of efficient computation on a modern computer is to engage the GPU of said machine. This means that any language hosted on the CPU is going to be at a disadvantage.
That's only true if your calculations are mostly the kind of things that take advantage of GPUs, like working with deep neural nets or graphics. For most other things using multiple CPU cores will be better.
It seems like the author is wrong about the weak Sapir-Whorf hypothesis not applying to programming languages.
This is anecdotal, but once I learned Clojure, some things about the way I thought about problems changed. I didn't think about things in a functional way before that. The same has happened since I started learning Rust. Now I'm thinking about ownership and lifetimes. And in C I had to manually allocate and free memory.
Perhaps the hypothesis should be amended to refer to programming language paradigms, or something along those lines.