On Preventing the Re-Invention of the Wheel:
Thoughts on Object-Oriented Programming.
Abstract: Alan Turing described us humans as Universal Turing Machines since we can simulate all other Turing Machines using just pen, paper, and some time ... Thus we are at the top of the top of computational models, and we can show that the UTM can extend its own boundaries beyond that of standard Turing Machines. Intellectually, we don't fully understand what our limits are because the possibilities are extended by advancements in science. I think there's a way to turn that boundary into a variable by treating concepts as hypothetical machines (For instance, a conjecture that relies on an unsolved problem), where we can flesh them out and see what we would need to do to make these machines real.
A whole lot of people have studied and created machines more powerful than standard Turing machines. Even Alan Turing himself gave examples, and there's already a large body of field-work on the subject. My goal isn't exactly the same idea although it does coincide often:
Purpose: provide and refine a simple, elegant structure that extends the application of Computability Theory ( and 'Hypercomputation' ) to Abstraction Theory, using 'concepts', conjectures, and proofs in a useful fashion (which often gives highly mnemonic and re-usable results). This structure can thus be restated as: a practical system to measure, refine, approximate, derive, and classify hypothetical/ abstract/ imaginary concepts and algorithms into facts and objects.
Current background reading:
Theory of Mathematical Evidence, Computability Theory, 'Hypercomputation', Abstraction Theory, (soon)Artificial Intelligence, and most importantly, yet surprisingly, Object-Oriented Programming - this is the basic idea, I suppose.
Eventually, although it may need 'refinement' and many exceptions, I want to be able to apply abstract algebra (groups, fields, polynomials) to any given concept. (Side note: it really hurt my brain just to type that last sentence in.)
You can even use this towards refining completely paradoxical and silly ideas into something that actually gives astonishing truth-statements and properties about such trivial ideas.
I will formalize two versions: a version that allows full application of Computability Theory, and a version that's quick and easy to use in a less mathematically-sound fashion.
At last, the Punchline! The joke is that the quick and easy version of this system is object-oriented programming! It's a paradigm many programmers have been working with for the past thirty-six years! Ha ! To use these tools, we simply need to program in our favorite object-oriented programming language or pseudocode - but from then on, it gets tricky: The second half is actually the study of Compilers (& Turing-Completeness), Abstraction, Discrete Mathematics, Mathematical Evidence ... the list goes on, and we must also ensure that we use standard operators and define them using the axioms of mathematics as a guide. In short, we must utilize Computer Science.
This is why I'm a programmer.
And it's also why I love C++ and SML ;-)