Garbage collection: the root of all evil

Garbage collection is the scam on which all others are based.

Without garbage collection, there would be no lazy evaluation, no functional programming, no closures, no placing the lambda calculus on a pedestal. All of these scams are based on garbage collection.

``Functional programmers'' had to invent a new branch of mathematics: ``domain theory'' to describe lambda calculus.
http://www.cs.nott.ac.uk/~pszgmh/domains.html

``Domain theory'' is really garbage collection, thunks, and stacks, dressed up in complicated math.

This brought the idea of ``bottom'' into computer science. Before, people didn't think about programs as bottoms and functions: they thought about actions.

This changed the meaning of ``undefined'' too, from real actions defined by the specific implementation (like what the computer does when indexing an array out of bounds), into its ``modern'' definition (out of bounds indexing is meaningless, so it can be assumed never to happen) by identifying it with bottom.

I enjoy being the bottom.

gc is for cucks

Is bottom state?

>>1
C has no garbage collection and it still defines 'undefined' as something that can be assumed never to happen

``Functional programmers'' had to invent a new branch of mathematics: ``domain theory'' to describe lambda calculus.

``Isaac Newton'' had to invent a new branch of mathematics: ``differential calculus'' to describe physical reality. What's your point, exactly?

>>5
C was standardized long after domain theory was part of mainstream education.

http://www.cs.nott.ac.uk/~pszgmh/dom1.pdf
Look at page 11 here. Bottom did not exist before Scott invented it.

You have to look at what ``undefined'' meant in programming languages before the invention of domain theory. It meant defined somewhere else.

>>6
Lambda calculus was defined as a formal system with three ``conversion'' rules.

This study is the original motivation for the calculi -- but they are so formulated that it is possible to abstract from the intended meaning and regard them merely as formal systems.

There was no mathematical foundation for lambda calculus and no explanation for garbage collection. Why do we need a program that scans through memory? What does this mean from a mathematical perspective? Lambda calculus was used for explaining why garbage collection should exist. They knew that closures (and all physical representations of lambda terms) were garbage collected data structures, hidden behind math.

The creation of domain theory was a trick for hiding this ``physical reality'' of change and actions (stacks, garbage collection, and thunks) behind their new math.

Infinity hides the halting problem behind bottom. It's no longer about actions that may or not halt, it's about a magic value called bottom.

>>7
Turing machines (which are a lot closer to the imperative model than Lambda calculus is) don't need garbage collection either, since the length of the tape is unbounded, and when you're no longer using an object, you can simply move on to another section of the tape. Garbage collection only becomes necessary when memory is limited - both LC and TM assume unlimited memory, such that there is no meaningful distinction between GC and a memory leak.

Garbage collection only becomes necessary when memory is limited

Yeah, especially those little chips with kilobytes of RAM.
Who would of thought Haskell runtime was so efficient?

>>8
Turing machines are also closer to imperative programs because they do not need domain theory or have a ``bottom'' value.

The halting problem for Turing machines is not hidden either: the machine halts or it doesn't.

🦆🦆 🐔

>>9
it's not about efficiency, it's about necessity. you could implement lambda calculus with no gc if memory was unlimited because you wouldn't need to explicitly free any memory, you'd just ignore the parts you're using and never run out of resources.