How IoT Is Strengthening Ubiquitous Computing (Part 2)
How IoT Is Strengthening Ubiquitous Computing (Part 2)
To make ubiquitous computing a reality, IoT needs to adopt a standardized middleware protocol (put the xkcd comic away) that brings in peer-to-peer networking.
Join the DZone community and get the full member experience.Join For Free
First were mainframes, each shared by lots of people. Now we are in the personal computing era, person and machine staring uneasily at each other across the desktop. Next comes ubiquitous computing, or the age of calm technology, when technology recedes into the background of our lives. —Mark Weiser
As explained in my previous article, ubiquitous computing considers making computers available throughout the physical environment (i.e., on actual physical things) but in an invisible manner that leads to context-aware and responsive environments for users. IoT can provide the primary infrastructure for ubiquitous computing, having many physical things with sensors/computing capabilities interconnected over the Internet. But most of the existing works in IoT are far behind in achieving the characteristics of ubiquitous computing.
Requirements for Next Gen IoT
The requirements for the next generation of IoT can be classified as the need for standard middleware and application protocols. The middleware protocol should abstract the underlying network complexity of heterogeneous devices (sensors, actuators, and various other processors) and provide a simplified API for the application protocol to develop autonomous applications that lead users a natural way of interacting with the physical environment. The standardization expected here is quite analogous to the Internet and its specifications.
The widespread usage of the Internet today is due to its standardization. The standard network protocols like TCP and IP allow connectivity of many computers together over a variety of networking technologies. Application protocols like HTTP, SOAP, FTP, etc. enable many useful applications to be implemented, simply abstracting the underline network complexity over TCP/IP. A similar standardization is required for IoT to bring it to the next level, fulfilling characteristics of Ubiquitous Computing.
Standard Middleware Protocol
The number of IoT devices are expected to grow exponentially in upcoming years. A standard middleware protocol should support management of large-scale IoT, and their overwhelming data flows. Also, the middleware protocol should allow any "thing" to join and leave the network of IoT efficiently.
As it is going to be an open middleware platform, there would be new, emerging security risks. The middleware protocol should guarantee basic Security and Privacy Principles for IoT and their data.
In addition, the middleware protocol should encourage the general community to contribute more IoT devices to the network, which will make our environment.
Standard Application Protocol
Unlike the existing IoT approaches, which offer closed access to specific things (sensors, actuators, and other devices), the new middleware protocol will allow the development of applications that use of a pool of IoT. The application protocol should direct the development of autonomous applications, which encourage a natural way of interacting with physical things. The applications should lead to a context-aware and responsive environment. Also, the applications should be capable of reasoning large-scale data sets, which confirm users’ goals and preferences.
The applications will be developed and contributed to by many individuals with different goals. Therefore, the applications should be able to communicate and cooperate with each other without making any conflicts. As all these applications are running on a same pool of things, the applications themselves should be able to negotiate with each other when accessing the shared set of IoT.
Also, there can be scarce things abstracted from the middleware protocol. These include some expensive sensor or actuator devices, which are contributed to by some government or commercial parties. The application protocol should be able to reach agreement in accessing these scarce IoT.
Platform for Next Generation IoT
As explained above, the requirements for a standard middleware and application protocol can be summarized as follows:
Fortunately, the requirements for a standard middleware protocol are already part of the research field of Peer-to-Peer computing and have been producing various successful protocols during that time. In the same way, the requirements for a standard application protocol have been already improved and standardized in the field of Multi-Agent Systems.
A peer-to-peer (P2P) system is about the sharing of computer resources in a decentralized manner. The resources include network bandwidth, storage, memory, and processing power. In P2P systems, each host directly connects to each other over the network, forming virtuality for resource sharing. A set of peers can be collaboratively grouped together to form a distributed file/database system, a search engine, or even a virtual supercomputer.
P2P system was first attractive in the year 2000 with Napster. Unlike having an exceptional content delivery network (CDN), the desktop machines in the general community turn up the large scale of file sharing system. BitTorrent and Blockchain (Bitcoin) are other successful P2P systems today. All these systems address the issues of network complexity, scalability over a broad set of community, intensive data load, and network churn while encouraging peer resources as the utility.
A standard P2P protocol has a high opportunity to improve the current direction of IoT. It will remove the need for a centralized resource management approach, over the cloud, that may not scale over the growing number of IoT. The sensors/actuators, together with some processing devices, can form peers that are interconnected over a standard P2P protocol. The P2P protocol will ensure the scalability over the number of IoT peers, their intensive data loads, and the other challenges mentioned above.
An agent is a computer system that is situated in some environment, and that is capable of autonomous action in this environment in order to meet its delegated objectives.
Michael Wooldridge uses the above definition for an Agent in his book. The actions it takes are automated. It delegates its objectives toward the environment. As further explained in the book, an agent becomes an intelligent agent with the following properties:
Reactivity: Intelligent agents are able to perceive their environmen, and respond in a timely fashion to the changes that occur in it order to satisfy their design objectives.
Proactiveness: Intelligent agents are able to exhibit goal-directed behavior by taking the initiative in order to satisfy their design objectives.
Social ability: Intelligent agents are capable of interacting with other agents (and possibly humans) in order to satisfy their design objectives.
That is, Intelligent Agents perceive their environment and react to changes that occur in the environment, but in a proactive manner that exhibits goal-directed behavior. The field of Multi-agent system arises when multiple Intelligent Agents cooperate in a single environment. Like the human, intelligent agents are expected to communicate with each other and reach agreements in achieving their design objectives.
Michael Wooldridge uses the following picture to present an abstract view of an agent. Even though the author does not highlight anything about IoT in the book, the figure shows an application model for IoT.
As it illustrates, agents can be designed to perceive information from sensor devices and decide actions internally to take toward effectors/actuators. With the P2P middleware protocol explained previously, the agents are no longer limited to particular sensors or actuators. The following figure depicts how an agent’s view can be adapted to modern IoT applications.
As presented in the above picture, Agents are not limited to particular sensors or actuators. With a Multi-Agent System over the aforementioned P2P Protocol, we can develop applications (Agents) that perceive sensor data from one vendor device and make actions toward actuators from another vendor.
For example, an Agent can be designed to read a patient’s biometrics from Preventice’s wearable sensor devices and adjust Nest’s thermostats to heat a patient’s room appropriately. In this way, the new platform is not limited to a certain set of devices, and it opens many possibilities over the P2P protocol to produce novel (multi-Agent) applications that enrich the idea of ubiquitous computing.
Multi-Agent technology has already become an extensive subject in the research field of computer science for several years. And it is already used in different domains of commercial applications. Process controls, system diagnostics, manufacturing, and logistics are few of names from the commercial industries. Therefore, most of the requirements identified previously for IoT applications are already addressed in the field of Multi-Agent Systems, with standardization. The Foundation for Intelligent, Physical Agents (FIPA) is a widely used specification for multi-Agent systems.
The following figure summarizes all the key aspects discussed previously for having a standard IoT platform. As it presents, the environment will consist of many IoT that is supposed to grow rapidly over the next couple of years. Sooner our environment will be composed of many physical things with sensor and computation capabilities, which make the technology direction pervasive and invisible. A standard P2P middleware protocol will provide a reliable distributed system model for this technology direction, which is intrinsically scalable over the expected growth of IoT.
An application protocol based on Multi-Agent Systems will allow implementation of autonomous applications capable of communication, cooperation, and negotiation with each other. Unlike general applications, Agents are designed with goals to be fulfilled on behalf of its users. That is, Agents will take necessary actions efficiently towards its environment over the P2P protocol.
With a P2P middleware protocol, there are a lot of possibilities to read the user's context accurately. The Agents will use all this information to take context-aware actions for the users. In this way, Multi-Agent Systems over the P2P middleware protocol encourages natural human world interaction without introducing any additional tools, hence strengthening ubiquitous computing and its characteristics.
Opinions expressed by DZone contributors are their own.