What Hegel would have said about Closed Source Software

Hegel if you don't know was a man who invented profoundly unique and introspective ways of thinking that are still shaking the grounds we walk our ethics on today. In this post I'll talk about how you can appreciate one mode of thinking that was inspired by his writing called dialeticism and how it can show you the utter nonsense rhetoric that motivates non-open and free-ness of software.

Dialectical deconstruction and The Halting Problem

Dialtecticism for the most part is about understanding that everything that exists; can be argued as dependent on things that define its non-existence. Essentially all existence works like a donut; the part of the donut that is missing is also part of the donut - life is only in existence because death (its complete opposite and "unexistor" must also exist). Another way to wrap this up is to use (what will potentially become) a very popular dictum: every identity depends on the identification of non-identity too! In order for the idea of existence itself to exist - the idea of non-existence must certainly then too exist!

Now how do we look at software through confusing and potentially for you dear reader completely non-intuitive means of thinking? Well lets think about Turing's Halting problem - essentially this is an unshakable bastion in the theory of computation (theory sounds like a flimsy barrier to restrict your thinking but understand that we implement computation on an embarrassingly almost hilarious subset of the machines dealt with in theory!) that holds the capabilities of Turing machines hostage. Which is to say that this is a problem no instantiation of (the most capable instantiation of computation we know) computation - no computer ever in existence ever; can be made to solve this problem... ever.

This amazing problem, is a way of saying that: there can NEVER exist a program that given an arbitrary program definition and input - determine whether the program will ever definitely always solve the problem or keep computing forever.  Essentially on the surface this seems like a problem about knowing how to tell if a program will "stop" running or "stop" running. But it is in fact something that applies to any piece of data that represents a solution to anything that can be determined as a problem of halting or not halting.

Halt? Who? Goes? There?

Essentially if you can 1) render the responses or markers of the solution to another problem; into things like "stopping a program" or "keeping a program running" OR 2) show that the means to determine whether a program can determine the difference between running and stopping is also itself based on a halting problem. There are probably more cases  I can cook up but if you stumble around in these areas of problems with any software - you are immediately on the dangerous fiercely guarded grounds of the Turing problem!  It might seem a bit macabre or perhaps impossible to imagine that you can do this with software but consider this - is your brain not a computer? You may postulate that it is or isn't; perhaps that is arguable as a halting problem itself lol - but should you say it is; well then lets pretend this sentence is a computer program running in your mind (in some capacity it very literally is!) - consider now that you are probably trying yourself to determine if this sentence will stop or not.  Of course it it just did but you admit while reading the sentence there is no means for your program to check based on running the other program whether that program will stop not so? You might need to read a sentence forever OR until you are no longer able to physically read it anymore! These are cases which show you how easily this problem can become computationally impossible to solve.

Now this idea of not being able to write a program to check other programs because the checker program needs to "run" the checked program; can be stated another way perhaps. Essentially:

If you have written a program that can check that another program "runs properly"; what checks your program that checks? And if you have a program that checks your checker program - what checks that program then?

This problem induces an unsolvable recursion that spirals completely out of manageable control. It is the anti-Newtonian calculus world of computation!

Hacking like Hegel

Why mention this? What does it have to do with Hegel? Well Hegel understood that no idea on its own is not dependent on other ideas - and so ad infinitum! Nothing is essentially true unless it can be proven related to literally every thing that is true that can ever exist.

Essentially one can say this is the same as claiming you can say something about software when the behaviour you claim is based on other software who's behaviour you have no evidence to claim about! Since every instruction in software is actually itself a composition of recursive function definitions. Essentially like claiming you can compute the derivative of a composed function with out decomposing or "unpacking" all the functions completely!

Software exists like this from a high level i.e. A java instruction is translated into many machine level instructions - every "function" you write is written with instructions that are actually themselves composed functions. This is because that is what the computer does to translate them into actions!

Looking from a low level in one view point; this could also then mean that if we take a single instruction that is as atomic and non-composed as possible. Now we say "lets write some software so that we can break Keith's stupid ideas of software works" - then i would interject and say - "Well fine; you bastards are welcome to prove me wrong at any moment; it seems that means I get to wait a fuck long time for something to happen - but anyway if this competition is fair then it means you cannot write software in way that expresses it as a composition of functions at all!" essentially if you write software with your atomic instructions it must leave you to argue that software is not composed of any functions ever that are composed of functions themselves!

You will find (if I am correct in my rhetoric) that this is impossible!  Further than that in order to determine whether you have done this correctly your are required to violate the first postulate again! Since there is probably no way to check any properties of your program without running inside another!

In Conclusion

So Hegel would have known that every program and claims about programs behaviour in its definition must have definitely fallen prey to this endless recursion. He would have definitely then knew that if anyone postulated they know anything about programs that run on his machine - he would have be able to invoke this endless chain of questions that must be answered in order to produce proof for such postulations. And if he knew to have done that which he would almost definitely have known (in my opinion of course) - he would have known that closed sourcing software definitely forces you to reason about the behaviour of software both in your interaction with it and other software's interaction with it that sees you yourself pretend the spiral of questions is not needed in deciding how you interact with the software.

How can you safely use software that stops your chain of questions and doesn't allow you to ask continuously (which is the nature of the software's definitions itself)? You must stare down an abyss of nothingness to interact with software that keeps you from understanding as much as you can about it.  Because the reality is that you are always staring down those questions in nature about gravity - magnetism etc all the forces in nature have never ending stories to tell - here comes computer science wizzing along on its magical wish dragon saying this doesn't apply to it and software can be developed and used and sold without fair means to challenge its claims.

But that might just be how I think about it though :)