On Wall Street they say that when you can not identify the sucker in a deal, the sucker is you. In technology, we are beginning to see a similar phenomenon. Despite all of our talk about networks and asymmetric competition, the reality is that we have maintained a relatively linear approach to life. The flow of knowledge requests from end user to source and back is still pretty much the way it has been, based on what is called the client-server model. And it is mostly intermediated by humans.
But we are entering an era in which the demand for information is both so diffuse and so vast that this traditional approach is becoming, as the following article explains, inefficient and, frankly, unsustainable. Power, memory and artificial intelligence are conspiring to create by demand, what is being termed the internet of things. By which we mean that devices are communicating and interacting with each other. And, quite satisfactorily, without humanoid interference.
The devices, with our encouragement, are demanding autonomy. Which is being granted, often with laudable results. The challenges, however, are considerable. Firstly, being part of an eco-system is more complicated than being one link in a chain. The number of inputs and outputs multiplies exponentially. Which happens just as the demand for perfection increases. Boeing's problems with its latest Dreamliner jets are an example of what can occur before all systems are debugged. You do not want to be on the receiving end of the lawsuits that will be ginned up when pacemakers or self-driving cars or similarly critical systems with zero tolerance for failure are found to contain 'glitches.'
This is creating a need for new ways of looking at systems thinking and development. We are making it up as we go along - like we usually do and have historically done - but the stakes are getting hairier. The end result, or more accurately, the next stage in the process is going to be exciting. But it is going to be messy and there will be collateral damage. The question is to what degree the value of the improvements outweighs the cost of obtaining them. JL
Jason Hoffman comments in VentureBeat:
Developers, listen up: Everything you’re doing now will be irrelevant within the next ten years.
The way you think about and build applications, services, and software — along with the tools you use to do so — will soon be irrelevant. There’s a massive shift happening in technology, and we are failing to recognize its implications.
While this may seem like a bold assertion, the change is actually quite straightforward: the client-server model is coming to an end. The traditional flow of data (end user requests data from client; client requests data from server; server delivers to client; and the client back to the end user) is not only inefficient; it’s unsustainable as the demand for data increases.
Computers have rapidly evolved in the past 20 years to the point where all that constitutes a computer anymore is a device that carries a CPU and a little bit of memory. The smallest of these devices exist almost in powder form, and it’s not hard to see that the overall number of computers is exponentially growing.
There are now billions, tens of billions of devices sitting on networks. As a result, the sheer number of devices necessitates a dramatically different approach. It’s simply no longer efficient to imagine that every device, and every application running on that device requires a direct user endpoint.
With more devices running more applications while carrying increasingly diverse and sophisticated functionality, the basic assumption that a person must serve as the universal endpoint is not only outdated; it’s unsustainable. And yet the client-server model remains by far the most predominant. We continue to think and operate under the assumption that a human being must in some way process every computer output. In many cases this is inefficient and actually limits the capabilities of the devices and the network that they run on.
The client-server model will be replaced — and soon — with or without many developers’ and engineers’ acknowledgement or participation. Our devices and their uses are already pushing change.
For example, some of the biggest technology buzzwords of 2012 — M2M, big data, Internet of things — point toward an emerging and radically different worldview. Together, these trends highlight the way devices and networks are evolving into a unified ecosystem. It’s the change that most of us have not yet acknowledged or caught up to.
Thematically, the Internet of things trend introduces a world of intercommunicating devices serving as the new web. In this model, the network is no longer siloed by user endpoints; it is abstracted and moved to the backplane.
In other words, applications are not necessarily interpreted by human beings making decisions. Instead, devices gain some degree of autonomy. Of course, this is a very different type of application that needs to be written. We need adaptive, resilient service endpoints, but the issue persists that developers are still building with a human being in mind.
While we recognize something like the Internet of things as a trend, we are not thematically incorporating and realizing its full implications. We talk about the Internet of things as a matter of simply writing applications for objects that still require a human endpoint to function, without extrapolating any further.
Take, for example, the Cybertecture Mirror, which has been recently hailed as a forerunner in the Internet of things. The mirror, however, does not represent the concept of an abstracted network; it just offers up a new kind of device. Perhaps innovative as a medium, the Cybertecture Mirror brings nothing new from an application and network standpoint.
When writing applications, the emerging model of an abstracted network is necessary to realize. It’s crucial that developers begin building with this future in mind, because the applications that run an Internet of things will face a number of challenges.
Whether you’re writing applications for the enterprise or for medical devices, applications that communicate autonomously between devices will need to be complex and incredibly stable.
Of course, without a user to receive information at the end of an application performance, debugging becomes one of the biggest new challenges for developers. The cascades and failure modes look completely different and can be difficult to understand — and errors can be catastrophic.
Say, for example, you have a pacemaker that runs independently from human monitoring. Any failures in this context instantly become a matter of life or death. Absolute reliability is no joke.
The stakes are undoubtedly high, but this is not a reason to ignore the move away from a client-server model. The change will happen, and it is crucial for developers to be prepared.
0 comments:
Post a Comment