Dev

Building for the Internet of things (and the demise of the client-server model)

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.


Related: With 5B wireless chips shipped, 2013 will be the year of the Internet of things

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.


Related: The Internet of things, delivered via smartphone

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.

jason hoffmanJason Hoffman is the CTO of Joyent. He is responsible for research and advanced development, technical outreach, evangelism, consultative efforts for partners and business units, and Joyent’s intellectual property portfolio, including open source projects, licensing, technology transfer, assessments of potential partnerships, and mergers and acquisitions. His specialties include bioinformatics, grid computing, cloud computing, distributed systems, collaborative applications, and deploying and scaling web applications.

0 comments