Web of Things

From Wikipedia, the free encyclopedia
  (Redirected from Web of things)
Jump to navigation Jump to search

The Web of Things (WoT) is software architectural styles and programming patterns that allow real-world objects to be part of the World Wide Web. Similarly to what the Web (Application Layer) is to the Internet (Network Layer),[1] the Web of Things provides an Application Layer that simplifies the creation of Internet of Things (IoT) applications composed of multiple devices across different platforms and application domains. [2][3][4][5][6][7][8][9] Differently from IoT which focuses on the Network Layer, WoT assumes that the connectivity between the devices is achieved and focuses on how to build applications.

Rather than re-inventing completely new standards, the Web of Things reuses existing and well-known Web standards[3][4] used in the programmable Web (e.g., REST, HTTP, JSON), semantic Web (e.g., JSON-LD, Microdata, etc.), the real-time Web (e.g., WebSockets) and the social Web (e.g., OAuth or social networks).[6]

Nature of Things[edit]

Research in the Web of Things usually considers things in the broad sense of physical objects. Things can include (but is not limited to) tagged objects (RFID, NFC, QR codes, Barcodes, Image Recognition)[10] to Wireless Sensor Networks (WSN), machines, vehicles and consumer electronics.[5]

Architecture and framework[edit]

While it is being standardised by W3C,[11] the Web of Things is a set of best practices that can be classified according to the Web of Things architecture.[2][5]

The architecture proposes four main layers (or stages) that are used as a framework to classify the different patterns and protocols involved.

Layers of the Web of Things Architecture as illustrated in Building the Web of Things[2]

Accessibility layer[edit]

This layer deals with the access of things to the Internet and ensure they expose their services via Web APIs. This is the core layer of the WoT as it ensures things have a Web accessible API, transforming them into programmable things.[3][4][7][12]

The access layer in the WoT is built around two core patterns: Firstly, all things should be exposing their services through a RESTful API (either directly or through gateway).[3] REST is an architectural style at the root of the programmable Web thanks to its implementation in HTTP 1.1. As a consequence, if things offer RESTful APIs over HTTP, they get a URL and become seamlessly integrated to the World Wide Web and its tools such as browsers, hyperlinked HTML pages and JavaScript applications.[4]

Several designs describing how the services offered by things can be accessed via REST have been proposed.[3][8]

Secondly, the request-response nature of HTTP is often cited as one of the limitations for IoT use-cases as it does not match the event-driven nature of applications that are common in the Wireless Sensor Networks.[3][6][13] To overcome this shortcoming while keeping a focus on fostering integration with the Web, several authors have suggested the use of HTML5 WebSockets either natively or through the use of translation brokers (e.g., translating from MQTT or CoAP to WebSockets).[5][6][11][14] This complements the REST API of things with a publish subscribe mechanism that is largely integrated with the Web eco-system.

Some things can connect directly to the Internet (e.g., using Ethernet, WiFi or GSM/3G), but in other cases (for example when devices are battery-powered) devices can access the Internet through Smart Gateways. Smart Gateway are protocol translation gateways at the edge of the network.[8][15]

Findability layer[edit]

The focus of this layer is to provide a way to find and locate things on the Web and hence is strongly influenced by the semantic Web.[5][11]

The approach here is to reuse Web semantic standards to describe things and their services. In particular, people have been working on HTML5 Microdata integration, RDF / RDFa, JSON-LD and EXI.[5][8][11] This enables searching for things through search engines and other Web indexes as well as enabling machine to machine interaction based on a small set of well-defined formats and standards.

Sharing layer[edit]

The Web of Things is largely based on the idea of things pushing data to the Web where more intelligence and big-data patterns can be applied as an example to help us manage our health (Wearables), optimise our energy consumption (Smart Grid), etc. This, however, can only happen in a large-scale way if some of the data can be efficiently shared across services. The sharing layer ensures that data generated by things can be shared in an efficient and secure manner.

Several approaches towards a granular and social context based sharing have been proposed such as the use of social network to build a Social Web of Things.[16][17]

Composition layer[edit]

The role of the last layer is to integrate the services and data offered by things into higher level Web tools (analytics software, mashup applications such as IFTTT), making it even simpler to create applications involving things and virtual Web services.

Tools in the composition layer range from Web toolkits (e.g., JavaScript SDKs offering higher-level abstractions)[6] to dashboards with programmable widgets[10] and Physical Mashup tools.[5] Inspired by Web 2.0 participatory services and in particular Web mashups, the Physical Mashups offer a unified view of the classical Web and Web of Things and empower people to build applications using the Web of Things services without requiring programming skills.[5]

A number of Web of Things Physical Mashup have been developed[18][19][20] and tools have been proposed and are being actively developed such as.[21][22]


Pioneering work in connecting objects to the Web probably started around the year 2000. In 2002, a peer-reviewed paper presented the Cooltown project.[23] This project explored the use of URLs to address and HTTP interact with physical objects such as public screens or printers.

Following this early work, the growing interest and implementation of the Internet of Things started to raise some questions about the application layer of the IoT.[8] While most of the work in the IoT space focused on network protocols, there was a need to think about the convergence of data from IoT devices. In particular, rather than looking at "one device one app", researchers and practitioners started envisioning the IoT as a system where data from various devices could be consumed by Web applications to create innovative use-cases.

The idea of the Web as an application-layer for the IoT started to emerge in 2007. Several researchers started working in parallel on these concept. Amongst them, Dominique Guinard and Vlad Trifa started the Web of Things online community and published the first WoT manifesto, advocating the use of Web standards (REST, Lightweight semantics, etc.) to build the application layer of the IoT. The manifesto was published together with an implementation on the Sun SPOT platform. At the same time, Dave Raggett from W3C started talking about a Web of Things at various W3C and IoT events. Erik Wilde published "Putting Things to REST", a self-published concept paper looking at utilising REST to sense and control physical objects.[24] Early mentions of the Web of Things as a term also appeared in a paper by Vlad Stirbu et al.[25]

From 2007 onwards, Trifa, Guinard, Wilde and other researchers tried publishing their ideas and concepts at peer-reviewed conferences but their papers got rejected by the Wireless Sensor Networks research community on the basis that Internet and Web protocols were too verbose and limited in the context of real-world devices,[26] where optimisation of memory and computation usage, wireless bandwidth, or very short duty cycles were essential.

However, a number of researchers in the WSN community started considering these ideas more seriously. Early 2009, a number of respected WSN researchers such as David Culler, Jonathan Hui, Adam Dunkels and Yazar Dogan evaluated the use of Internet and Web protocols for low-power sensor nodes and showed the feasibility of the approach.[27][28]

Following this, Guinard and Trifa presented their end-to-end implementation of the concepts and presented it in a peer-reviewed publication accepted at the World Wide Web conference in 2009.[4] Building on this implementation and uniting efforts, a RESTful architecture for things was proposed in 2010 by Guinard, Trifa and Wilde.[29] Noticing a growing industrial and academic interest for connecting things to the Web, Guinard, Trifa and Wilde ran the first International Workshop on the Web of Things,[30] WoT 2010 which has been running yearly since. These workshops have become the first forum where a growing community of researchers and practitioners could discuss the latest findings and ideas in the Web of Things.

In 2011, two of the first PhD theses on the Web of Things were presented at ETH Zurich: Building Blocks for a Participatory Web of Things: Devices, Infrastructures, and Programming Frameworks from Vlad Trifa[6] and A Web of Things Application Architecture – Integrating the Real-World into the Web from Dominique Guinard.[5]

In 2011 Dominique Guinard and Vlad Trifa together with Niall Murphy and Andy Hobsbawm got together and founded EVRYTHNG,[31] one of the first cloud software companies entirely leveraging the Web of Things to serve industry needs. Several other WoT startups were started around this time such as Sensetecnic[32] or Yaler.[33]

In 2014, the W3C showed an increased interest in the Web of Things and organised the W3C Workshop on the Web of Things,[34] under the lead of Dave Raggett together with Siemens and the COMPOSE European project. This workshop lead to the creation of the Web of Things Interest Group at W3C[11] and the submission of the Web Thing Model.[35].

The same year, Siemens announced the creation of a research group dedicated to the Web of Things.[36] In October 2014, Google also announced their interested in these ideas by launching the Physical Web GitHub project.[37]

The Web of Things Interest Group has identified the required set of standards needed for the Web of Things in February 2017 [38] and the Working Group has start working on 4 deliverables called WoT Architecture [39], WoT Thing Description [40], WoT Scripting API [41] and WoT Binding Templates [42].

Application examples[edit]

  • One of the early prototypes of the Web of Things is the "Energie Visible" project in which sensors capable of monitoring and controlling the energy consumption of household appliances offered their functionality through a RESTful API. This API is then used to create a physical Mashup.[43]
  • EVRYTHNG[46] is a platform for making unconnected products and connected devices part of the Web based on a Web of Things architecture.
  • WeIO is an open source hardware and software platform for rapid prototyping and creation of wirelessly connected interactive objects using only popular web languages such as HTML5 or Python.
  • SMQ[47] is a real time pub-sub protocol that bridges WoT with IoT. The protocol makes it easy to design web based user interfaces for device management and supervision. The Mako Server,[48] which can be compiled for anything from embedded devices to enterprise Linux servers, includes a ready to use SMQ broker.
  • An application of the Web of Things in smart homes has been investigated in,[49] to address the problem of heterogeneous home devices by reusing Web technologies.
  • Sense Tecnic Systems[50] focuses on a lightweight toolkit for developing IoT applications and targets rapid development using Web technologies and protocols. The WoTKit toolkit has been described at the 2012 IoT conference[19] and builds on research from UBC's Media and Graphics Interdisciplinary Centre,[51] in particular the work on the MAGIC Broker as published at IoT 2010.[52]

Alternative approaches[edit]

A number of alternative approaches to Web standards have been proposed, such as WS-* services,[53] but these were later shown as not necessarily well-suited for real-world things.[28][54]

The Constrained Application Protocol (CoAP) is also quite often cited as an alternative or complementary approach for resource-constrained devices.[55] CoAP shares similarities with the Web of Things architecture such as the use of RESTful resources.

See also[edit]


  1. ^ "SlideShare The Web of Things with Mozilla Open Badges". 2014-10-20.
  2. ^ a b c
  3. ^ a b c d e f Guinard, Dominique; Trifa, Vlad; Mattern, Friedemann; Wilde, Erik (2011). From the Internet of Things to the Web of Things: Resource Oriented Architecture and Best Practices (PDF). Springer. pp. 97–129. ISBN 978-3-642-19156-5.
  4. ^ a b c d e Guinard, Dominique; Trifa, Vlad (2009). Towards the Web of Things: Web Mashups for Embedded Devices (PDF). WWW (International World Wide Web Conferences), Enterprise Mashups and Lightweight Composition on the Web (MEM 2009) Workshop.
  5. ^ a b c d e f g h i Guinard, Dominique (2011). A Web of Things Application Architecture – Integrating the Real-World into the Web (PDF) (Ph.D.). ETH Zurich.
  6. ^ a b c d e f Trifa, Vlad (2011). Building Blocks for a Participatory Web of Things: Devices, Infrastructures, and Programming Frameworks (PDF) (Ph.D.). ETH Zurich.
  7. ^ a b Guinard, Dominique; Trifa, Vlad; Pham, Thomas; Liechti, Olivier (2009). "Towards physical mashups in the Web of Things". 2009 Sixth International Conference on Networked Sensing Systems (INSS). pp. 1–4. CiteSeerX doi:10.1109/INSS.2009.5409925. ISBN 978-1-4244-6313-8.
  8. ^ a b c d e Guinard, Dominique; Trifa, Vlad; Wilde, Erik (2010). A Resource Oriented Architecture for the Web of Things (PDF). Internet of Things 2010 International Conference (IoT 2010).
  9. ^ "W3C WoT Architecture".
  10. ^ a b Guinard, Dominique; Mathias, Mueller; Jacques, Pasquier (2010). Giving RFID a REST: Building a Web-Enabled EPCIS (PDF). Internet of Things 2010 International Conference (IoT 2010).
  11. ^ a b c d e "W3C Web of Things".
  12. ^ Duquennoy, Simon; Grimaud, Gilles; Vandewalle, Jean-Jacques (2009). "The Web of Things: Interconnecting Devices with High Usability and Performance". 2009 International Conference on Embedded Software and Systems. pp. 323–330. CiteSeerX doi:10.1109/ICESS.2009.13. ISBN 978-0-7695-3678-1.
  13. ^ Yazar, Dogan; Dunkels, Adam (2009). Efficient application integration in IP-based sensor networks. ACM Workshop on Embedded Sensing Systems for Energy-Efficiency in Buildings (BuildSys '09). doi:10.1145/1810279.1810289.
  14. ^ "Connected devices, real-time push and the Web of Things".
  15. ^ Trifa, Vlad; Wieland, Samuel; Guinard, Dominique; Thomas, Bonhert (2009). Design and implementation of a gateway for web-based interaction and management of embedded devices (PDF). International Workshop on Sensor Network Engineering (IWSNE 09).
  16. ^ Guinard, Dominique; Trifa, Vlad; Fischer, Mathias (2010). Sharing Using Social Networks in a Composable Web of Things (PDF). First IEEE International Workshop on the Web of Things (WOT2010).
  17. ^ Chung, Tein-Yaw; Mashal, Ibrahim; Alsaryrah, Osama; Huy, Van; Kuo, Wen-Hsing; Agrawal, Dharma P. (2013). "Social Web of Things: A Survey". 2013 International Conference on Parallel and Distributed Systems. pp. 570–575. doi:10.1109/ICPADS.2013.102. ISBN 978-1-4799-2081-5.
  18. ^ Kovatsch, Matthias; Weiss, Markus; Guinard, Dominique (2010). "Embedding internet technology for home automation". 2010 IEEE 15th Conference on Emerging Technologies & Factory Automation (ETFA 2010). pp. 1–8. CiteSeerX doi:10.1109/ETFA.2010.5641208. ISBN 978-1-4244-6848-5.
  19. ^ a b Blackstock, M.; Lea, R. (October 2012). "IoT Mashups with the WoTKit". Internet of Things 2012 (IEEE). In Press.
  20. ^ Guinard, Dominique; Trifa, Vlad; Fischer, Mathias (2010). Mashing up Your Web-Enabled Home (PDF). ICWE 2010 (International Conference on Web Engineering).
  21. ^ "NodeRed".
  22. ^ Brut, M.; Gatellier, P.; Salhi, I. (2014). When devices become collaborative: Supporting device interoperability and behaviour reconfiguration across emergency management scenario. WF-IoT 2014 (World Forum - Internet of Things). doi:10.1109/WF-IoT.2014.6803169.
  23. ^ Kindberg, T.; Barton, J.; Morgan, J.; Becker, G.; Caswell, D.; Debaty, P.; Gopal, G.; Frid, M.; Krishnan, V.; Morris, H.; Schettino, J.; Serra, B.; Spasojevic, M. (2000). "People, places, things: Web presence for the real world". Proceedings Third IEEE Workshop on Mobile Computing Systems and Applications. pp. 19–28. CiteSeerX doi:10.1109/MCSA.2000.895378. ISBN 978-0-7695-0816-0.
  24. ^ "Putting things to REST" (PDF).
  25. ^ Stirbu, V. (2008). "Towards a RESTful Plug and Play Experience in the Web of Things". Semantic Computing, 2008 IEEE International Conference on. Semantic Computing, 2008 IEEE International Conference on. pp. 512–517.
  26. ^ "5 Years of Web of Things Workshops". 2014-10-23.
  27. ^ Hui, Jonathan W.; Culler, David E. (2008). "IP is dead, long live IP for wireless sensor networks". Proceedings of the 6th ACM conference on Embedded network sensor systems - Sen Sys '08. p. 15. CiteSeerX doi:10.1145/1460412.1460415. ISBN 9781595939906.
  28. ^ a b Yazar, Dogan; Dunkels, Adam (2009). "Efficient application integration in IP-based sensor networks". Proceedings of the First ACM Workshop on Embedded Sensing Systems for Energy-Efficiency in Buildings - Build Sys '09. p. 43. CiteSeerX doi:10.1145/1810279.1810289. ISBN 9781605588247.
  29. ^ Guinard, Dominique; Trifa, Vlad; Wilde, Erik (2010). "A resource oriented architecture for the Web of Things". 2010 Internet of Things (IOT). pp. 1–8. doi:10.1109/IOT.2010.5678452. ISBN 978-1-4244-7413-4.
  30. ^ "International Workshop on the Web of Things".
  31. ^ "EVRYTHNG".
  32. ^ "Sensetecnic". SenseTecnic. Retrieved 2012-08-05.
  33. ^ "Yaler".
  34. ^ "W3C Workshop on the Web of Things".
  35. ^ "Web Thing Model".
  36. ^ "Siemens Web of Things Research Group".
  37. ^ "The Physical Web". GitHub. Retrieved 2017-02-08.
  38. ^ "W3C Web of Things joint IG/WG meeting in Santa Clara, 5-9 February 2016".
  39. ^ "W3C WoT Architecture".
  40. ^ "W3C WoT Thing Description".
  41. ^ "W3C WoT Scripting API".
  42. ^ "W3C WoT Binding Templates".
  43. ^ "Energie Visible Web of Things Project".
  44. ^ "free, social and open source internet of things". Nimbits. Retrieved 2012-05-10.
  45. ^ github README file, 2019-02-19
  46. ^ "making products smart". EVRYTHNG. Retrieved 2013-05-24.
  47. ^ "SMQ: Lightweight IoT protocol". Real Time Logic. Retrieved 2015-02-27.
  48. ^ "SMQ Broker: Ready to use SMQ Broker". Real Time Logic. Retrieved 2015-02-27.
  49. ^ Kamilaris A. Enabling Smart Homes using Web Technologies. PhD Thesis, University of Cyprus, Nicosia, Cyprus, December, 2012.
  50. ^ "WoTKit: Lightweight IoT toolkit". SenseTecnic. Retrieved 2012-08-05.
  51. ^ "Media and Graphics Interdisciplinary Centre, University of British Columbia". UBC. Retrieved 5 August 2012.
  52. ^ Blackstock, M.; Kaviani, N.; Lea, R.; Friday, A. (Nov 29 – Dec 1, 2010). MAGIC Broker 2: An open and extensible platform for the Internet of Things (PDF). IoT 2010 (IEEE Press). pp. 1–8. doi:10.1109/IOT.2010.5678443. ISBN 978-1-4244-7413-4.
  53. ^ Carboni, Davide; Zanarini, Pietro (2007). "Wireless wires". Proceedings of the 6th international conference on Mobile and ubiquitous multimedia - MUM '07. pp. 169–175. doi:10.1145/1329469.1329492. ISBN 9781595939166.
  54. ^ Guinard, Dominique; Ion, Iulia; Mayer, Simon (2012). In Search of an Internet of Things Service Architecture: REST or WS-*? A Developers' Perspective (PDF). Lecture Notes of the Institute for Computer Sciences, Social-Informatics and Telecommunications Engineering. Lecture Notes of the Institute for Computer Sciences, Social Informatics and Telecommunications Engineering. 104. pp. 326–337. CiteSeerX doi:10.1007/978-3-642-30973-1_32. ISBN 978-3-642-30972-4. ISSN 1867-8211.
  55. ^ Kovatsch, Matthias (2013). "CoAP for the web of things" (PDF). Proceedings of the 2013 ACM conference on Pervasive and ubiquitous computing adjunct publication - Ubi Comp '13 Adjunct. pp. 1495–1504. doi:10.1145/2494091.2497583. ISBN 9781450322157.

Further reading[edit]

  • Fortuna, Carolina; Grobelnik, Marko (2011-03-09). Tutorial: The Web of Things. Proceedings of the World Wide Web Conference 2011, Hyderabad, India. Association for Computing Machinery.

External links[edit]