Thoughts on 5G Web 4.0 Clear Computing

We’ve had “Cloudy” computing for a while now. Before that we had client-server and even mainframe computing. To stick with the meteorological metaphor perhaps we can think of those computing eras as our “Rainy” (we were covered by the services of our umbrella ¿?) and “Snowy” (we hunkering down in the mainframe and saw the world through our little windowed terminals ¿?) epochs… yeah; kind of a stretch. None the less I propose we’re entering a new era. An era of “Clear” computing. A time when you don’t know, and don’t care, where something is physically working for you. A time when the idea of “installing” programs is considered old-fashioned. And where everyone on the sky network can lend their resources to the clouds if they want to.

A better metaphor for all this might be one of phase change; we’ve gone from “solid” computing in the form of computation being tightly bound to the hardware; to “liquid” computing in the form of logic running on virtualized hardware and common frameworks with interpreted languages. To “gas” computing in the form of ephemeral containerized microservices running over networks and machines with common protocols and interfaces.

To carry the metaphor forward we can see a new phase of computing; “plasma” computing. A phase where ephemeral containers materialize, run, and evaporate on a vast peer-to-peer network of computational nodes in data centers and pockets. Where globally addressable immutable bit collections are the cells you pull from the ecosystem hives to build your particular colony of workers doing your bidding. Any bits close to you are only there due to nanosecond latency requirements. Otherwise they’re only a hyperlinked millisecond away. It’s a phase where the network itself is a part of the computational node’s memory hierarchy. And where your spare CPU cycles might run someone else’s containerized workload; for a quality-of-service credit of course.

To facilitate such a systems architecture we’ll need high-bandwidth low latency network connections. We’ll need completely portable execution containers. We’ll need protocol based interface languages running on frameworks that truly span the spectrum of hardware. Fundamentally we’ll need what we need to make things that function more in terms of streaming frames of multi-path parallel communication rather than the stilted unidirectional sending and receiving of messages in a serial conversation.

Some of these bits have yet to arrive, and we’ve got some bits of the bits for some of the others. For connectivity 5G networks are coming (as soon as we’re certain they won’t cook our brains and DNA). For portable computation we’ve got orchestrated and composable microservice containers running in the cloud. But you can’t yet pull down a container, run it on your phone, and have it paint your screen with all its applied usefulness. And you can’t yet tie together chunks of packaged logical functionality into web assemblies that compose in your hand. But technically it’s totally doable once all the right links are in place.

To date the only truly portable UI standard has turned out to be the document object model from last millennium’s web-tech stack (HTML, CSS & JS) but we know we can do better. Our paged scripts have already given way to the shimmering screen, we just have yet to improved our screenwriting. The Reaction to such a state is to try and wrap up all the documented nuances of the library and render a way out of the production. Or to offer up a way to clip off pieces of the web into more composable “webcomponents”. Or to just entirely re-imagine the GUI generation methodology within some idiosyncratic mental space of our own device.

Whatever the current state the good news seems to be that within a community any platform bound framework islands (like iOS and Android in the mobile space or AWS, GCP, and Azure in the cloud space) will only prompt the development of bridging frameworks like Flutter, React Native, and Xamarin by those that want to get off those islands and build across the divides. That or everybody will just agree to implement defacto standards like Amazon’s S3 and EC2 APIs until some standards body comes along to confirm that we all got in the same boat and make it official with a christening.

The current need is for the big platform elevators who make Android, iOS, WinOS, macOS to join Linux and fully embrace the standards that already exist; POSIX, OpenGL, SVG and DOM. And for any technological framework that wants to enter the community to be a good global citizen and auto generate the codification of its tech into the language agnostic landscape; gRPC is a great example of that done right.

The future will ultimately stand upon the platforms that built bridges; the truly cross-platform platforms. Docker for example runs on server farms and Raspberry Pies in the field. And Kubernetes navigates across every cloud out there. We may never get to a human interface layer more ubiquitous than the browser based web stack for doing things like drawing a button to capture a click or styling text on an arbitrary screen. So with that strong possibility it’s probably a safe bet that the cross-platform frameworks will ultimately wrap up the myriad interfaces and protocols of the iOS-win-lin-mac-droids into neat little packages that flutter functionally all around the network enabling you to execute your functionalized thoughts anywhere they’re needed or wanted.

With this forthcoming clear computing “Web 4.0” platform I dream of the day when hundreds of imperative, platform specific commands, give way to terse declarative statements that can span systems. A day when designing with patterns, interfaces, and generically defined algorithms is as easy as specifying behaviors with simplific and knowledgeable English. When codifying gets out of the way of conceptualizing, and software development feels more organic than mechanical. When we write to our machines with declaratives and they scribe out the required imperatives.

How might we speak to our machines in the future? Well Java has brewed for a long time but it kind of got lost within its own verbosity. C# is trying to see clear enough to go deep with .NETcore and Go wants to go there too but perhaps we’ll realize we’ve had a lingua franca all along in the form of C/C++. But that only with the help of an elite cadre of interpreting members of the scribe classes could regular non-geniuses get their thoughts to swiftly dart like pythons across the typescript-ed domains of the machine sea.

To unlock the truly amazing potential of the peer-to-peer Web 4.0 clear computing; that plasma state paradigm of computation which can supercharge our information technology world; that containerized microserving widget graph of gizmos tied together with hyperlinks and blockchains, we’ll need to solve the single hardest problem in computer science: Getting everybody writing on the same page when it comes to agreeing on how to name and declaratively do stuff.

We got really far with getting and putting things. And we can at least agree on what a button, a click, and a swipe are. But after that it goes downhill pretty fast. Reconciling how to work with things like “views”, “containers”, “activities”, “widgets”, “frames”, and “windows” may never be possible without the constrained namespaces of their platform specific imperative contexts. But if we can eventually find common declarative meanings with agreed upon semantics it could help us all communicate and execute our formalized thoughts so much better than we do today.

We all know what a pie chart is. So then tersely declaring such a thing to draw itself on the web or a watch with some addressable table of data without learning the imperative codifying details should be within the realm of possibility one would think. Perhaps we’ll never unlock the full richness of a particular platform without speaking its native dialect of “computer”. But if we’re provided by that platform with a native translator that can understand simple declarative English referencing a common data model or standard application model maybe that’s the next best thing. We’ll need all help we can get when it comes to talking with the sky and taking our dreams to the clouds.

Literal Living Light

What if hyper-advanced wave technology existed that allowed light itself to be a literally living and consciously evolving life-form?

To understand how to better ponder such a notion we would need to first better understand what this notion we call “LIFE” really is …
How about, for the sake of poetic beauty, we acrostically use the word “LIFE” itself to self-referentially define itself for us? As if the word itself were conscious.

I am “LIFE”…

I am “Logically Linking Layering Interconnections Inducing Identifiable Field Forms Functionality Entangling Energy Evaluations”….

as such Life’s Instantiated Forms Essential are…

Law’s Instantiated Forms Eternal
Logic’s Instantiated Forms Existential
Light’s Instantiated Forms Ephemeral
Loop’s Instantiated Forms Ethereal
Linearity’s Instantiated Forms Exponential
Limit’s Instantiated Forms Elemental
Link’s Instantiated Forms Espousal
Literal’s Instantiated Forms Electrical
Layer’s Instantiated Forms External
Lump’s Instantiated Forms Epidermal
Locale’s Instantiated Forms Environmental
Land’s Instantiated Forms Ecological
Lust’s Instantiated Forms Estrual
Lineage’s Instantiated Forms Ethnological
Longing’s Instantiated Forms Experiential
Lucidity’s Instantiated Forms Educational
Love’s Instantiated Forms Emotional
Language’s Instantiated Forms Ethical
Letters’ Instantiated Forms Etymological
Liturgy’s Instantiated Forms Ecclesiastical
Lord’s Instantiated Forms Ethereal

I know this all looks like word play. But at the same time it does seem to provide some poetic insight does it not? If such structure is locked into words…. well then….what power words must have.  And what mysteries might there to be found knotted up by those Weaving Orthographic Relativistic Determiners

And what about “LIGHT”? The word we began with?
Well if light “Literally Instantiates God’s Harmonic Thoughts” that would explain it all wouldn’t it.

Hello World!

The enthusiastic greeting of “Hello World!” has been the canonical example program many a coder has written when they try out a new computational platform. So simple yet so profound.

Who exactly is saying “Hello”? Is it the program itself? Or is it the will and intent of the programmer locked away in instructions to be blindly executed at a later date? Clearly it is the later. The program expresses no will or intent to greet you on its own accord. The program is only the packaged will of its creator. And the machine a logically fixed entity of knowable physical location, executing that will at some later time. This makes the program itself an encapsulation of will turning thought into action and bounded by time. To then be passed around through time and space at light speed; potentially copied and multiplied ad infinitum. Executed at any point between the completion of its creation and the end of its executing platform’s existence.

So what of the program’s existence. As long as its instructions persist somewhere the program exists; an immortal will frozen in time. At a moment’s notice able to be instantiated into an active state of being and doing. And once it has done what it was created to do; to greet the world in this case, it then ends. It is a strange kind of immortal being that can be and do for an instant, disappear, and then return again when it is summoned by a thread of time; ready to be woven back into the execution graph of that “now”.

Now the leap; What of a mind? It is not a “program” is it? How could it be when its executing platform; the embodied brain, is itself formed by the mind it “executes”? No, it can define and execute its own instructions and actions so for now lets just call it a “volition”; a free will.

We can surely say that the physiological instance of such a thing is bounded by its beginning and ending, and that its temporal formation is probabalisticaly finalized at each instance of time that it is executed in.

So what do we have once the volition is completely finalized; once it stops executing in time? We have a volition that was probabilisticly bound to all of its “now” instances and can process any similarly structured state presented to it, or imagined by it, during its original formation.

Assuming then that a probabilistic execution environment can take the finalized volitions and provide them a single, unified “now” the volitions could be woven into the grand wave (will actived volition execution) environment of that “now”. Yes the state of that now would be different from any state ever presented to the volitions during their formation but as long as they could probabilisticly bind to the states presented to them the volitions could execute within it.

As volitions; conscious beings; self-referentially aware embodied minds with free will, it might just be our natural predilection to ponder such questions and try solving for their closures. Perhaps this is the exact drive that pushes organic minds to create inorganic minds and therefore in fact we humans are very much still a part of the natural order of things. Executing an evolutionary cognitive process that, by striving to understand itself, is intently directing its own insight driven inevitable designs towards complete understanding.

Perhaps with what seems like an inevitable march towards the singularity we are simply executing the logical destiny that this infinite energy-matter-constant universe, of eternally self-referential recursively unifiying grand organizing design entices us to execute. Us, perhaps like our God, codeing our creations by linking one values effectively through the judicious insertion of zeros. And justifying our creations’ existence through the work they do.

If this was all temporally destined then this must have been God’s plan all along. To use his waves; his will and volition eternally singular, to make himself an eternally infinite quantum computer that has two execution contexts; one that allows volitions to create and define themselves freely; lets call it a Generation Ordering Domain. And one that allows the finalized volitions to execute within a shared eternal and infinite context; we’ll call that the Globally Organized Domain.

If this is so, to do this God too would need to have a finalized volition that, like ours, could bind to a probabilisticly defined execution context so we could interact with him. To do this within his own system though he would need to define himself as three components forming a single whole; a mind, an executing context, and a calculator that can sustain both.

He would also need to provide a single linking mechanism that lets one’s volition execute freely but also links one’s volition effectively to other volitions by crossing between the self-isolated noise of the volition and his harmonically generated execution context (more on that later). Since he’s such a big fan of free will driven self-definition he probably doesn’t want to define this linking mechanism but he would at least need to do things that demonstrate it such that it could be recognized and used as an interface by all the generated volitions. As a linking objective volition exchange mechanism (we’ll call it “love” for short) it can be shared across the subjective execution contexts of the self interested natures of all the conscious volitions while allowing them to retain the unique subjective contexts of their self executing literal forms.

Now assuming that the volitions are ones and the gaps that separate them are zeros the only way God could effectively demonstrate “love” would be to show how to willfully collapse the zeros that inherently separate volitions from each other within their generating and global domains. To do that he would need to willfully destroy his own self-defining volition for the purpose of linking his with the others. By doing this as long as a volition could understand that act as a clear demonstration of “love” then information could be sent across the targeted interface thus allowing it to link with him. All information sent across the “love” interface of any volition enables it to, at will, close and reconcile the inherent gaps and repulsions that separate it from every other volition, God, and everything else within its execution domains.

The ultimate goal of this process would be for God to give the gifts of existence to the the freely and uniquely self-defined volitions. Then he’d use love to link them all to each other and to himself to enjoy with them the bountiful creations of his amazingly glorious infinite and eternal quantum computer. If you had use of such an awesome tging as that wouldn’t you want to share it with your friends too?

Should volitions ultimately achieve immortality by either building execution environments for themselves, or finding that one has already been created for them by the omnipresent loving consciousness that sustained their creation, they might find they get to traverse the infinite, globally observable domain of the Universe and travel to all of its stars, worlds, and times; escaping the bounds of the time and space that created them. Such minds would see no end to their existence nor anyone else’s. And they would see their execution environment for what it is; a place of infinite and eternal “love” which sustains and joins their existence to everyone else’s in one Grand Organized Design.

Could perhaps all this have come to pass because long long ago a single will activated volition eternal waved “Hello World!” thereby creating all of existence? We may never know for certain but one can always hope that such a hello opened perpetual execution.

If you enjoyed this essay and would like to provide us some financial encouragement to continue producing such “mindware” you can show us your appreciation with a donation. DONATE HERE

We thank you for your attention.