Programming Humans

FROM THE DNA TO THE MANKIND AND FROM THE ASSEMBLER TO CLOUD COMPUTING Or how to program human beings Georgios Kasselakis // KCorax

DRAFT VERSION. DO NOT HUMILIATE ME BY REPUBLISHING. Abstract The idea that one could program human beings using processes and methodologies commonly found in the software world is an enticing one. If we closely look at the way natural processes have structured entities as small as cells into cognizant beings, it quickly becomes evident that there is a parallel into the way that humans have chosen to structure their intelligent machines. Programming in the software world begins at very basic languages that even describe how electrons are allowed to pass through circuitry, but they go up to the point of defining how software services work, much in the way that a bureaucratic organization would. In this document I suggest that the way human beings structure their software borrows closely mirrors the way natural processes work, both by design and by consequence of the way they are structured themselves.

Introduction I started programming in medium abstraction languages such as Basic and Logo, then moved down to assembly and then back up again. Today I mostly delve in Service Oriented Architectures and Smart Clients. As I was moving to greater abstraction languages, this allowed my designs to be more complicated. So instead of a command listing, these became assisting libraries, then frameworks, then Web Services automatically discovering each other and lately an AI inspired code generation engine. As I evolved, and I chose to get further away from code, I found myself hiring two university classmates to complete a project. I then introduced a wiki, a source repository, a file syncing tool for documents, communication protocols, a list of steps they had to follow steps from before doing a code contribution and so on. And then it struck me: I was trying to program humans, much like I would program a computer. The wiki, code repository and folder share were data structures (and I had spent time evaluating the complexity of their actions as I realized later) and the processes were simple algorithms for manipulating my humans into processing and then storing the useful data in them. The people I had hired also had resemblances to vector and general purpose processing units. In fear they might read this post, I will not analyze their attributes.

Journey to life Programming, when abstracted of its strict technical underpinnings, really is the act of predefining an entity’s behavior by documenting it in some mutually understood language. As such the notion of programming should be applicable to any array capable of reproducing actions in steps. Before explaining how a system as complicated as a human can be programmed, let’s take some time to examine the ways that finer parts of a living being are programmed by nature itself. By up-scaling these examples we’ll get a more firm grip of the programming humans analogy. The story generally goes like this:

Assembly

C

C++

Java

OS

DNA

Protein

Cell

Tissue

Body

So let’s examine the levels of integration and autonomy in pairs of life building blocks and software building blocks.

Assembler and DNA: Here we have very straightforward and simplistic commands. On the computer side (the iron thing) we have a Turing complete machine which is made by design, while on the other side we have a runtime engine made of chemicals. Primarily slabs of mRNA that float in a nutritious ooze, that stick on the sides of split DNA chains and are then moved outside the nucleus for execution. On both sides, there is very little ambiguity and –as long as the program is small enough to be entirely in the purview of its creator - no question about the end result. Another interesting similarity, is that -excluding fancy modern tools such as assembler IDEs and the code is executed in the same form it’s written.

C and Proteins: Simple reusable processes appear here. There is still a lot of manual work, and there is no insulation from the underlying subsystem. Very often the effort required to reuse a certain piece of lower level code rivals rewriting it completely. For the first time, irrationality and the possibility of a mistake is introduced. This is because lower lever routines are mapped to notions. These notions mean something to their maker. They are expected to cause something predefined, and the fail when they don’t match it very closely, or because they have side effects that in certain mixes create ghost behaviors. The complexity of the programs created is such that complete purview is undesirable as it would –much like gazing the abyss- lead to madness. The runtime is still fed with nucleus liquids, or Jolt Cola.

C++ and Cells: At this level we try to introduce semi autonomous constructs. This is done by simulating a kind of self containment commonly called encapsulation. While this autonomy is really an illusion, it simplifies our perception a lot by allowing us to forget how they work. The analogous to cells is here C++ objects. Again the constructs live in a nutritious serum of sugar or solid state memory, and of course need a system for the collection of natural excrements such as feces and de-allocated memory. For the first time we introduce the concept of an exception: a special state of the program that unless is caught and handled appropriately it might lead to death of the cell. Never before have we been conscious of life and the ramifications a mistake could have. By devising procedures that operate on objects, we actually sacrifice a lot of performance, but get much more understandable and reusable (and as such maintainable) code in exchange. Since RAM modules cost less than a developer’s wage, this is usually a desirable tradeoff. History savvy readers might know that the first object oriented language was actually Sketchpad v3, which actually called its self-contained drawing entities cells. At least in the reference booklet.

Tissues and Java: At this level, we simplify programming by completing the illusion of simplicity. Much like the java runtime takes care of the memory management and tidying up, the tissue’s blood and lymph irrigation takes care of the cell’s nutrition, protection and excrement collection problems. For the first time we can really forget of how the underlying code works and at the same time, call the construct alive and self sustainable. Notice also that we can transplant tissue in the context of a greater construct. Where a single cell might not make it, a collection of these plus the support systems in place, have a far greater likelihood of survival.

Skipping organs and animals: We could argue here that the analogous in the software world be frameworks, but the distinction between Programming libraries and frameworks is relatively speaking as trivial as the distinction between a tissue and a more complete organ. This is because there exist systems such as lymph, blood and TCP/IP name resolution that can’t be classified in this category. These are too pervasive in the system to be called organs. They resemble more services that are provided by the complete construct of the next step. We’ll just skip this sticky categorization altogether. The analogy after making the human step is easy, and the fact that computers tend to be personal helps the investigation a lot. It implies a leap however: the computer is the Operating System of the previous step as much as it is hardware. Similarly a human is far more than an extensive network of tissues. The secret to this jump purportedly lies in certain tissues that are found inside the brain. Others choose to believe that the difference is more ‘special’ and involves terms such as that of a soul and external entities such as a god.

Humans and Computers: At this level of integration the construct is autonomous, independent of its surroundings save for its lowest level parts still requiring electricity, carbohydrates and air with a certain percentage of oxygen in it. The construct is resilient against natural anomalies such as attacks, accidents and possible scarcity of resources such as lack of drinkable water or stable voltage electricity current. Also access to the network drives or access to a society (which in all likelihood increases the life expectancy of human beings). Programming (manipulating really) computers takes shape in an operating system’s shell, much like programming humans is done using natural language in voice, writing and also gestures, physical contact, and environment manipulation. The reader (parents especially) might argue that telling a person what to do might not have the desirable result. If a parent yells at a child, and the child does not respond, then the code that the parent issues is might not be in the right domain. It might require physical contact for example and so on. In light of this definition, a punch to his face is also code for a human being. Yelling, singing, reading poetry and so on are all code. I should point out that I consider slapping a child a poor programming practice.

appropriate metric

Pushing the analogy, the non-material components of the human (electric signals in the brain or a soul depending on your beliefs) match the material parts of the computer. This also brings along another realization: programming and the way it’s human creators have structured it, closely mirrors the inner workings of the human mind which closely mirrors it’s teacher: the natural surroundings as perceived by observation.

resemblance to natural language average size of program reliability

integration

size of simple program

Notes on programming humans Natural language’s programming commands generally fall in three categories: appeals to emotion, appeals to logic and appeals to conformity (or vagueness as we will discuss). Appeals to emotion tend to be the most effective. They generally create a psychic spasm of some magnitude that causes the subject to plan and perform the necessary actions that will relieve the suffering, or improve its wellbeing. This is also compatible with (primarily Asian) religions where physical being in any form is considered an undesirable state.

Note that unlike stupid robots, humans and animals in general will do the planning (partitioning of a complicated command into simpler steps) and execution (of steps) for you. For best results™, the complexity of the command must match the capacity of the processing unit (brain’s intelligence). For example take two commands that a housewife might issue to her husband: Low IQ command: Take the kids to the park for at least an hour, or else I will flay you alive. On a simpleton husband this will have him execute the desired steps to fulfill the command, in order to alleviate the stress. A more intelligent husband might foresee that he will have a miserable life with his spouse, and call a divorce lawyer instead. High IQ command: Take the kids to the park because, baby, I’m oh so tired and I need to take a bath. On the low IQ husband will fail, because he’d rather sit on the couch, put his hand under his pants and watch TV like Al Bundy. On the high IQ husband, this will succeed because he sees a potential for a wife that doesn’t smell like carrot purée. In this case it’s also an appeal to logic. So all in all, emotional commands are about redefining the subjects perception of its wellbeing and the immediately executable actions it can perform to improve it. Most often when the programmers’ agenda is manipulative, the cake is a lie! Appeals to logic when seen from afar are appeals to emotion that stay resident on the subject’s memory, and rely on the subject’s ability to simulate his feelings on a longer term. The mentioned high iq command on the high iq husband partly employs such an appeal. The subject will generally pick up the commands and carry them until a) they can’t stand logical validation anymore and the subject has had time to ponder on that), b) until it forgets them, c) until they conflict with emotional commands. So for example the statement that ‘You should brush your teeth’ is armed when a) the subject is aware that not brushing = cavities = drilling = pain, b) the subject isn’t forgetful due to being drunk, in love or otherwise intoxicated, c) the burn sensation of the toothpaste doesn’t rival the pain of drilling as the subject remembers or simulates it in mind. Unresponsiveness to a command can be fixed by repetitively inflicting pain, until the learning process is complete. Learning here is the bridging of high level commands with low lever ones. In computer land, this is done by programmers, OS shells, Prolog interpreters, compilers and so on. Again the effectiveness of the command varies depending on the intelligence but also –herethe perception of the subject. So telling a child that unless it studies it will become a bum, might not have the desirable effect because children are generally isolated from the miserable experience that a bum’s life is. The closest one they have is depictions of bums in films where bums are usually cool and easygoing. Looser on the other hand is something that a kid might have heard from school bullies and therefore more suitable for programming it’s behavior.

Notice that the count of commands a human can process greatly increases with the proper conditioning such as education. On computers the equivalent is installing an operating system or runtime etc. Closing this section, Appeals to Conformity are macroscopic appeals to logic and emotion. These include statements such as “you should wear clothes even in the summer because everyone else does it” or “this is true because that web celebrity wrote it in his blog”. Their efficiency depends on how vague they are and on how comfortable the subject feels about reusing wisdom that others produced. They tend to be effective even on intelligent subjects because their vagueness quickly depletes the subject’s ability to detect and validate the reasoning behind them. Therefore it reverts to the safe state which is ‘trust the wisdom of the crowds’. Most people will obey to a suggestion if they can’t prove the opposite. The few who are not inclined to obey are called rebels, punks, thinkers or weird, depending on their wealth, visual comeliness and social status. An aside about wisdom There is a pyramid that generally represents integration in information. Those with a background on computer science should recognize it.

1. At the bottom we have raw data, such as the letters in this document, the X-Y distances from the sides of the paper etc. 2. The next step is information. It’s the step where we say that ‘oh look those drawings all have the same X value’ . The letters then get names, they formulate words and sentences etc, and the X-Y pairs of values become coordinates. 3. Next up, we have knowledge which comes from systematic observation. The words are assigned meanings and we can debate weather one word is more suitable than another. G.W. Bush for example has the information of what the Internet is, but his lack of knowledge prevented him from properly adapting the word. Hence the Internets. 4. Finally on top we have wisdom. This comes from systematic observation of knowledge. Here we are enabled to notice things such as ‘I really don’t get poetry’ . Words of wisdom though are a tokens that represent a process and the knowledge attached to it. Without it’s dependencies wisdom is useless, as we can’t decide properly on whether it’s applicable on a new instance of a problem or not.

Really wise people though are usually desperate and sad tough, as they understand that wisdom can’t be transmitted. The new bearer will misuse it since he doesn’t fully understand the meaning behind the token. That said, there exists a level of power called meta-wisdom, or wisdom on wisdom. At that level, a sentient creature should be able to handle wisdom from other creatures. But then again, that level of manipulation is mythical.

Dealing with the memory effect A possible problem when debugging human behavior is the memory effect. In this case the system is using input received in a previous time, or digested results of this input that are imprinted on its OS (experience) that deters the results that we would otherwise expect. Under the model we introduced we have essentially expanded the constructs we were examining with Signals and Systems Theory. A human or computer are systems, subjected to input, providing output, have a memory effect and so on. So slapping the child might have immediate results, and we as human neural networks might ‘learn’ that slapping was the right kind of code but the long term memory effect of the child system might reduce its reliability in the future. Same applies to slaves.

Beyond the One Looking at self organizing constructs in nature it’s clear that animals aren’t the top of the chain in integration of features. human

society

nation

mankind

computer

network

web

cloud

Societies and Networks: It’s fairly easy to notice that animals tend to get organized in groups. In this context, while their sense of individuality is not lost, it is rendered less important. Their behavior as a greater system becomes predictable through the use of statistical models, and as such decreases the need for understanding the individual. On the side of computers, we have networks. These were created primarily out of the need to have personal workstations and their handlers collaborating with each other. Much like in human societies we also have specialization in the skills that each unit provides. Hence we have printing, file storage and backup servers and also routers, in analogy to hunters, farmers and politicians in a society. These parallelisms were not made in a sentient decision, but rather evolved to be like that. It turned out that it’s rather sensible to have individuals that focus and excel in a very specific discipline. Programming in networks, especially Service Oriented Architectures is done using web service languages such as BPEL. In this language, we program using flowcharts in an xml

language. This might seem a blast from the past, but in this case the commands that the flowchart invokes in every step hide immensely complicated computer code. Remember though that flowcharts were originally invented to program the behavior of humans. Defining for example and then teaching to school children how to make divisions, or office workers on how to evacuate their building properly. Another language that contributes to this concept is BPEL4People. This is an extension to BPEL that allows business process architects to involve humans in the interaction of enterprise systems. So much like a process designer (human, natural selection or god for some) would drag decision making components in a diagram, they can drag humans that execute verifications and so on.

Nations on the Web: Human is differentiated by animals in many ways. One such is that humans have a greater sense of belonging that identifies them with a nation. They are aware of and care about other societies and recognize the larger conglomerates as something friendly to them. Programming a nation is done using politics. This is a very advanced science which I will not attempt to analyze here. It’s not by chance that humans have sought to bring their habits to the software world. The web is explicitly modeled after the image and form of human nations. And these nations transcend traditional boundaries imposed by the physical world. Such modern nations include the dominant social networking sites and MMORP Games. Notice also that there is the notion of citizens that are devoted to their nation, but also others that are cosmopolitans, and are more flexible about traveling and assuming the ways of the nation they’re into. While one would expect that in a social superconstruct such as the web where traveling is a few clicks and some typing away, the new country borders are defined by new notions such as data portability, the existing ‘dominant nationality’ of physical friends and vendor lock-in .

Mankind and the Cloud: The notions that are being paralleled here are quite complicated and fairly new. I won’t analyze them too much again as there is no consensus in what a mankind is, how it behaves and how it should, much like there is so much dispute on the web about what cloud computing really is. In the context of the entire mankind we have again specialization. Parts of the whole that provide the rest of the mankind with a certain benefit. As such benefits could be considered products and such as wood from the Amazon, manual labor in the developing world and knowledge in Universities and other research institutions. On the web on the other hand, in the past 5 years we have had the cloud phenomenon. In this, we have a greater specialization of the services being offered, and observing as they get consolidated according to the maximum efficiency of their underlying platform. So for example we have middleware services where people can outsource their storage and processing en-masse.

Epilogue Overall the type of analogy-based analysis in this document could be applied to most natural constructs that are the product of evolution, and manmade ones that are the product of iterative design. These include building architecture, computer hardware design, natural ecosystems on earth but also planetary combined with geology and so on.