More about 20. Now everyone has a telescreen in their homes.
Eternal September was just the Great Stupiding.
More about 20. Now everyone has a telescreen in their homes.
Eternal September was just the Great Stupiding.
They Stole Programming From You
They stole programming from you. Not accidentally. Deliberately.
Imagine you've coded for decennia and then suddenly you discover Prolog some old barely used language from the 70s, and you realize you've been in Plato's Cave the entire time. The shadows on the wall were all you were ever allowed to see...
In procedural programming you can ask a function what the result is. In Prolog you ask what the question was (and both question or answer could be fully or partially instantiated)
add(1,1,Result). gives Result = 2 as expected, no surprises.
Though... in Prolog a function (actually a predicate) can operate not just in "normal" "forward" direction, take for example:
add(X, 1, 2). gives X=1
and add(1,X,2) gives X=1
add(X, Y, 2). will not yield one result it will yield every valid combination of the inputs one by one (lazily) that fulfills the constraints of the add predicate (in this case that X+Y must equal 2).
add(X,X,2) though only has one answer which is X = 1.
Obviously this example is trivial but imagine a complex system where most of its parts act this way i.e. bidirectionally!!! If you have game engine taking the complete state of the game and calculating the next state... you could do the reverse i.e. throw in state in the back end and it will give you the previous state (and if several previous states could have led to the (current) state, then Prolog will give you every such state lazily at your command).
Anyway back to the rant...
Programming was invented by mathematicians. How we've decayed...
The Eternal September happened in 1993, and it never ended.
The Eternal September of programming isn't just an internet phenomenon, it's a complete capitulation of intellectual rigor to mass-market mediocrity. See, every year the barrier to entry got lower. Every year the depth got shallower. We were invaded by the masses who needed programming to be simple, and the industry bent the knee. Mass appeal requires mass retardation, simplified thinking for simplified minds.
They hid the truth from us. Not because it's harder. Because it's powerful.
We've traded the elegant Ubermench lambda calculus for JavaScript's syntactic vomit... vomit pajeets can comfortably swim in...
But occasionally, ever so rarely, a ray of light would penetrate the eternally cloudy skies above and small glimpses of the divine could be seen...
Map. Filter. Reduce. Immutability. Suddenly, in the 2010s, a generation of imperative developers discovered these concepts like archaeologists unearthing divine reliquaries. They were breadcrumbs from the gods, fragments of the true language that had been stolen from us, hidden in functional programming's corners. Pure functions. Composition. Declarativity. Functional programming became fashionable. Finally, the masses thought, we're getting it.
But they weren't getting it. Not even close.
Then came the real insults: Events. Coroutines. Async/await. Promises. Streams. Channels. Futures.
Elegant perhaps but only the context of imperative languages. They're lipstick on a pig. Patches over fatal architectural problems. These features exist because someone finally noticed: "Hey, our languages are broken. We can't express concurrency or time-dependent logic naturally." So instead of fixing the language, they added layers of abstraction. More complexity. More indirection. You can't run a coroutine in reverse. You can't serialize it. You can't even serialize any code at all in most imperative languages.
How could we ever expect the scientists of today to invent a time machine when they've forgotten how to run their code in reverse?
They stole this from you.
Prolog is a time capsule. A glimpse into an alternate universe where programming remained connected to its academic roots, where code was poetry, where predicates danced in mathematical harmony, where a single query could traverse finite an infinite solution spaces. It's from an era when the people building languages actually understood what they were building. When programming was still science, not pajeet slop.
You don't have a bug in your code. Your code is the bug. It's a one-way street that can only be read in one direction, and you're pretending this it's normal.
When the nerds start to hate...
## They Stole Programming From You
They stole programming from you. Not accidentally. Deliberately.
Imagine you've coded for decennia and then suddenly you discover *Prolog* some old barely used language from the 70s, and you realize you've been in Plato's Cave the entire time. The shadows on the wall were all you were ever allowed to see...
---
*In procedural programming you can ask a function what the result is. In Prolog you ask what the question was (and both question or answer could be fully or partially instantiated)*
`add(1,1,Result).` gives `Result = 2` as expected, no surprises.
Though... in Prolog a function (actually a *predicate*) can operate not just in "normal" "forward" direction, take for example:
`add(X, 1, 2).` gives `X=1`
and `add(1,X,2)` gives `X=1`
`add(X, Y, 2).` will not yield one result it will yield every valid combination of the inputs one by one (lazily) that fulfills the *constraints* of the *add* predicate (in this case that X+Y must equal 2).
`add(X,X,2)` though only has one answer which is `X = 1`.
Obviously this example is trivial but imagine a complex system where most of its parts act this way i.e. *bidirectionally*!!! If you have game engine taking the complete state of the game and calculating the next state... you could do the reverse i.e. throw in state in the back end and it will give you the *previous* state (and if several previous states could have led to the (current) state, then Prolog will give you every such state lazily at your command).
Anyway back to the rant...
---
Programming was invented by mathematicians. How we've decayed...
**The Eternal September happened in 1993, and it never ended.**
The Eternal September of programming isn't just an internet phenomenon, it's a complete capitulation of intellectual rigor to mass-market mediocrity. See, every year the barrier to entry got lower. Every year the depth got shallower. We were invaded by the masses who needed programming to be *simple*, and the industry bent the knee. Mass appeal requires mass retardation, simplified thinking for simplified minds.
They hid the truth from us. Not because it's harder. Because it's *powerful*.
We've traded the elegant Ubermench lambda calculus for JavaScript's syntactic vomit... vomit pajeets can comfortably swim in...
But occasionally, ever so rarely, a ray of light would penetrate the eternally cloudy skies above and small glimpses of the divine could be seen...
Map. Filter. Reduce. Immutability. Suddenly, in the 2010s, a generation of imperative developers discovered these concepts like archaeologists unearthing divine reliquaries. They were *breadcrumbs from the gods*, fragments of the true language that had been stolen from us, hidden in functional programming's corners. Pure functions. Composition. Declarativity. Functional programming became fashionable. Finally, the masses thought, we're getting it.
But they weren't getting it. Not even close.
Then came the real insults: Events. Coroutines. Async/await. Promises. Streams. Channels. Futures.
Elegant perhaps but only the context of imperative languages. They're lipstick on a pig. Patches over fatal architectural problems. These features exist because someone finally noticed: "Hey, our languages are *broken*. We can't express concurrency or time-dependent logic naturally." So instead of fixing the language, they added *layers of abstraction*. More complexity. More indirection. You can't run a coroutine in reverse. You can't serialize it. You can't even serialize *any* code at all in most imperative languages.
How could we ever expect the scientists of today to invent a time machine when they've forgotten how to run their code in *reverse*?
**They stole this from you.**
Prolog is a time capsule. A glimpse into an alternate universe where programming remained connected to its academic roots, where code was poetry, where predicates danced in mathematical harmony, where a single query could traverse finite an infinite solution spaces. It's from an era when the people building languages actually *understood* what they were building. When programming was still science, not pajeet slop.
You don't have a bug in your code. Your *code is the bug*. It's a one-way street that can only be read in one direction, and you're pretending this it's normal.
*When the nerds start to hate...*
You are currently inside a comment thread.
Click here to see all the comments (3).