Dr. Aly, O.
Computer Science
Abstract
Keywords: World Wide Web, Web, Performance
Bottlenecks, Large-Scale Data.
Introduction
The journey of the Web starting with Web 1.0 is known as the “Web of Information Connections,” followed by Web 2.0 which is is known as “Web of People Connections” (Aghaei, Nematbakhsh, & Farsani, 2012). Web 3.0 is known as “Web of Knowledge Connections, “Web 4.0 is known as the “Web of Intelligence Connections” (Aghaei et al., 2012). Web 5.0 is known as “Symbionet Web” (Patel, 2013).
This project discusses this journey of the Web starting from Web 1.0 until Web 5.0. The inception of the World Wide Web (W3) known as the “Web” goes back to 1989 when Berners-Lee introduced it through a project for CERN. The underlying concept behind the Web is hypertext paradigm which links documents together. The project was the starting point to change the way we communicate with each other.
Web 1.0 is the first generation of the Web, and it was read-only, with no interaction with the users. It was used to broadcast information to the users. It used the simple framework of Client/Server which is known as a single point of failure. Web 2.0 was introduced in 2004 by Tim O’Reilly as a platform which allows read-write and interaction of users. The topology of Web 2.0 is Peer-To-Peer to avoid the single point of the failure in Web 1.0. All nodes are serving as server and client and have the same capabilities to respond to users requests. The topology of Web 2.0 Peer-to-Peer is called Master/Slave. Web 3.0 was introduced by Markoff of New York Times in 2006 and is known as the Semantic Web. Berners-Lee introduced the concept of the Semantic Web in 2001. The Semantic Web has a layered architecture including URIs, RDF, Ontology Web Language (OWL), XML and other components. Web 4.0 and Web 5.0 are still in progress. Web 4.0 is known as the “Intelligent Web,” while Web 5.0 is known as “Symbionet Web.” It is expected that the Artificial Intelligence will play a key role in Web 4.0, and consequently Web 5.0. The project addressed the main sources for the large-scale data in each Web generation. Moroever, the key technologies and the underlying architecture and framework for each Web generation are also discussed in this paper.
The project also discussed and analyzed the bottleneck and the performance of the Web for each Web generation from Client/Server simple topology of Web 1.0 to Peer-To-Peer of Web 2.0 topology, to the layered topology of Semantic Web of Web 3.0. Moreover, the bottleneck is also discussed for Web 4.0 using the Internet of Things technology. Each generation has added tremendous value to our lives and how we communicate with each.
Web 1.0 – The Universal Access to Read-Only Static Pages
Web 1.0 is the first generation of the World Wide Web (W3), known as the Web (Aghaei et al., 2012; Choudhury, 2014; Kujur & Chhetri, 2015; Patel, 2013). The inception of the W3 project took place in CERTN in 1989 to enhance the effectiveness of the CERN communication system (Kujur & Chhetri, 2015). Berners-Lee realized this hypertext paradigm could be applied globally (Kujur & Chhetri, 2015). The W3 project allowed access to the information online (T. J. Berners-Lee, 1992). The term “Web” for the world goes to the similarities for the construction of a spider (T. J. Berners-Lee, 1992).
The underlying concept of W3 was using hypertext paradigm, through which documents are referring to each using links (T. J. Berners-Lee, 1992). The user can access the document from that link universally (T. J. Berners-Lee, 1992). The user can create documents and link them into the Web using the hypertext (T. J. Berners-Lee, 1992). If the data is stored in the database, the server can be modified to access the database from W3 clients and present it to the Web, as the case with the generic Oracle server using the SQL SELECT statement (T. J. Berners-Lee, 1992). Large sets of structured data such as the database cannot be handled by Web 1.0 hypertext alone (T. J. Berners-Lee, 1992). The solution for this limitation is to add “search” functionality to the hypertext paradigm (T. J. Berners-Lee, 1992). The indexes, which are regarded to be “special documents,” can be used for the search where the user can provide a keyword that results in that “special document” or “index” which has a link to the documents found as a result of that keyword (T. J. Berners-Lee, 1992). The phone book was the first document which was published on the Web (T. Berners-Lee, 1996; T. J. Berners-Lee, 1992).
Berners-Lee is regarded to be the innovator of the Web 1.0 (Aghaei et al., 2012; Choudhury, 2014; Kujur & Chhetri, 2015). Web 1.0 is defined as “It is an information space in which the items of interest referred to as resources are identified by a global identifier called as Unifrom Resource Identifiers (URIs)” (Kujur & Chhetri, 2015; Patel, 2013). Web 1.0 was read-only passive Web with no interaction with the websites (Choudhury, 2014). The content of the data and the data management are the sole responsibility of the webmaster. In the 1990s, the data sources included digital technology and database systems which organizations widely adopted storing a large amount of data, such as bank trading transactions, shopping mall records, and government sector archives (Hu, Wen, Chua, & Li, 2014). Companies such as Google and Yahoo began to develop search functions and portals to information for users (Kambil, 2008). Web 1.0 lasted from 1989 until 2005 (Kujur & Chhetri, 2015; Patel, 2013). Example of Web 1.0 includes the “Britannica Online” which provide information for read-only (Loretz, 2017).
Key Technologies of Web 1.0
The key protocols for Web 1.0 are HyperText Markup Language (HTML), HyperText Transfer Protocol (HTTP), and Universal Resource Identifier (URI) (Choudhury, 2014; Patel, 2013). New protocols include XML, XHTML. The Cascading Style Sheet (CSS) Server-Side Scripting include ASP, PHP, JSP, CGI, and Perl (Patel, 2013). The Client-Side Scripting include JavaScript, VBScript, and Flash (Patel, 2013).
Web 1.0 Architecture
The underlying architecture of the Web 1.0 is Client/Server topology where the Server retrieves data responding to the client requests where the browser is residing (T. J. Berners-Lee, 1992). A common library of the information access code of the network is shared by the clients (T. J. Berners-Lee, 1992). The servers existed at the time of W3 project were Files, VMS/Help, Oracle, and GNU Info (T. J. Berners-Lee, 1992). The Client/Server topology is described as a single point of failure as there is a total dependency on the server (Markatos, 2002).
Web 1.0 Performance Bottleneck
Web 1.0 framework consists of a web server, clients which are connected to the server using the internet (Mosberger & Jin, 1998). HTTP is the protocol that connects the client and the server (Mosberger & Jin, 1998). In (Mosberger & Jin, 1998), httperf tool was used to test the load and the performance of the web server which responds to several client requests (Mosberger & Jin, 1998). The httperf tool has two main goals (Mosberger & Jin, 1998). The first goal is about the good and predictable performance. The second goal is about the “ease of extensibility” (Mosberger & Jin, 1998). Load sustainability is a key factor in a good performance of the web server (Mosberger & Jin, 1998). There are various client performance limits which should not be regarded as server performance limits (Mosberger & Jin, 1998). The client CPU imposes a limitation on the client (Mosberger & Jin, 1998). The size of the Transmission Transfer Protocol (TCP) port space whose numbers are sixteen bits wide. Privilege process reserve 1,024 of the 64K available ports. The port cannot be reused until it gets expired. Thus, the TCP TIME_WAIT plays a role as its expired state allows the port to be reused (Mosberger & Jin, 1998). This scenario can cause a serious limit and bottleneck for client sustainable offered rate (Mosberger & Jin, 1998). With one minute timeout, the sustainable rate is about 1,075 requests per seconds. However, with the recommended value of RFC-793 to be four-minute time out, the maximum rate would be 268 requests per second instead (Mosberger & Jin, 1998). The total and the per-process number of file descriptors that can be opened are limited in most operating systems (Mosberger & Jin, 1998). The “per-process limits” is ranged from 256 to 2,048. The file descriptor cannot be used until it is closed, the httperf timeout value plays a role in the number of the open file descriptors. If the client confronts with a bottleneck, the operating system of the client can be tuned to increase the limit of the open file descriptors (Mosberger & Jin, 1998). The TCP connection typically has a “socket receive” and “send buffer” (Mosberger & Jin, 1998). The clients loads are limited to the clients’ memory available for the “socket receive” (Mosberger & Jin, 1998). Concurrent TCP connections can cause a bottleneck and poor performance (Mosberger & Jin, 1998).
For the server side performance, the granularity of the process scheduling in operating systems is measured in millisecond ranges and plays a key role in the performance of the server responding to several requests from several clients (Mosberger & Jin, 1998). Tools such as httperf check the network activity for input and output using select() functions and monitor the real-time using gettimeofday() functions (Mosberger & Jin, 1998). The limited number of the ephemeral ports is ranged from 1,024 to 5,000 which can cause a problem when running out of ports (Mosberger & Jin, 1998). Tools such as httperf re-use the ports as soon as they are released. However, the incompatibility of the TCP between Unix and NT broke this solution where Unix allows pre-empting the TIME_WAIT state, while NT did not allow it during the arrival of the SYN segment (Mosberger & Jin, 1998). Allocating the ports using round-robin method solves this problem. Several thousand TCP control blocks can cause slow system calls (Mosberger & Jin, 1998). The hash table is usually used to look up the TCP control blocks for incoming network traffic is standard for execution time (Mosberger & Jin, 1998). However, some BSD-derived systems still use linear control block search for the bind() and connect() system calls, which can increase the slow system calls. The solution was found when system closes the connection. Thus, tools such as httperf applied the concept of closing the connection by using RESET (Mosberger & Jin, 1998).
Web 2.0 – The Universal Access to Read-Write Web Pages
In 2004, Dale Dougherty the Vice-President of O’Reilly Media defined Web 2.0 as read-write web (Aghaei et al., 2012; Choudhury, 2014; Kujur & Chhetri, 2015; Patel, 2013). Web 2.0 is defined by Tim O’Reilly as cited in (Aghaei et al., 2012; Choudhury, 2014; Kujur & Chhetri, 2015; Miller, 2008) as follows : “Web 2.0 is the business revolution in the computer industry caused by the move to the internet as platform, and an attempt to understand the rules for success on that new platform. Chief among those rules is this: Build applications that harness network effects to get better the more people use them.” Others defined Web 2.0 as a “Transition” from Web 1.0 where information is isolated to computing platforms that are interlinked together which function as a local software for the user (Miller, 2008). In an attempt to differentiate between Cloud Computing and Web 2.0, Tim stated as cited in (Miller, 2008) “Cloud computing refers specifically to the use of the Internet as a computing platform; Web 2.0, as I’ve defined it, is an attempt to explore and explain the business rules of that platform.”
Web 2.0 has shifted Web 1.0 not only from read-only to be read-write but also to be technology centric, business-centric and user-centric (Choudhury, 2014). The technology-centric is found in the platform concept of the Web 2.0 which is different from a client/server framework of Web 1.0. The platform technology is associated with blogs, wikis, and Really Simple Syndication (RSS) feeds (Choudhury, 2014). The business-centric concept is reflected in the shift to the internet as a platform and comprehending the key success factors using this new platform concept on the internet (Choudhury, 2014). The user-centric concept is the shift from companies publishing content for read, to communities of users who are interacting and communicating with each other using the new platform on the internet (Choudhury, 2014). Tim O’Reilly identified a list of the differences between Web 1.0 and Web 2.0 (O’Reilly, 2007) (see Figure 1).
Figure 1: Web 1.0 vs. Web 2.0 Examples (O’Reilly, 2007).
Web 2.0 has other attributes such as “wisdom web,” “people-centric web,” and “participative web” with reading the writing capabilities (Aghaei et al., 2012; Choudhury, 2014; Kujur & Chhetri, 2015; Patel, 2013).T With Web 2.0, the user can have flexible web design, updates, collaborative content creation and modification (Aghaei et al., 2012; Patel, 2013). The support for collaboration is one of the major characteristics of Web 2.0, where people can share data (Patel, 2013). Examples of Web 2.0 implementation include a social network such as MySpace, Facebook, Twitter, media sharing such as Youtube (Patel, 2013). Thus, the data for Web 2.0 is generated from all these resources of MySpace, Facebook, Twitter and so force. With Web 2.0, the data is growing very fast and entering a new level of “Petabyte age” (Demirkan & Delen, 2013).
Key Technologies of Web 2.0
Web 2.0 utilized key technologies to allow people to communicate with each other through the new platform on the internet (Aghaei et al., 2012). The key technologies of Web 2.0 include The RSS, Blogs, Mashups, Tags, Folksonomy, and Tag Clouds (Aghaei et al., 2012). Three development approaches to create Web 2.0 applications: Asynchronous JavaScript and XML (AJAX), Flex and Google Web Toolkit (Aghaei et al., 2012).
Web 2.0 Architecture
Web 2.0 has various architecture patterns (Governor, Hinchcliffe, & Nickull, 2009). Three main levels of the Web 2.0 architecture patterns starting from the most concrete to the most abstract which is high-level design pattern (Governor et al., 2009). Some of these Web 2.0 architecture patterns include Service-Oriented Architecture (SOA), Software as a Service (SaaS), Participation-Collaboration, Asynchronous Particle Update, Mashup, Rich User Experience (RUE), the Synchronized Web, Collaborative Tagging, Declarative Living and Tag Gardening, Semantic Web Grounding, Persistent Rights Management, and Structured Information (Governor et al., 2009).
Web 2.0 Performance Bottleneck
In Web 1.0, the Client/Server architecture provided users to access the data through the internet. However, the users had the experience of “wait” (Miller, 2008). As discussed earlier, the client has bottlenecks in addition to the server’s bottleneck. The issue in Web 1.0 is that all communications among computers had to go through the server first (Miller, 2008). Due to the requirement of having every client passes through the server first, the concept of Peer-to-Peer was established to solve this overload and bottleneck on the server side. Web 2.0 works with Peer-to-Peer framework (Aghaei et al., 2012; Patel, 2013). While in Web 1.0, the server has the full responsibility and capabilities to respond to clients, in Web 2.0 using the Peer-to-Peer computing, each computer has the same responsibilities and capabilities as the server (Miller, 2008). This new relationship between computers is referred to as master/slave where the central sever acts as the master and the client computers act as the slave (Miller, 2008). In Peer-to-Peer framework in Web 2.0, each computer servers as a client as well as a server (Miller, 2008).
Peer-To-Peer framework provided the capability of streaming live video from a single source to a large number of receivers or peers over the internet without any special support from the network (Magharei & Rejaie, 2006, 2009). This capability is called P2P streaming mechanism (Magharei & Rejaie, 2006, 2009). There are two main bottlenecks with a P2P streaming mechanism (Magharei & Rejaie, 2006, 2009). The first bottleneck is called the “bandwidth bottleneck,” and the second bottleneck is called “content bottleneck” (Magharei & Rejaie, 2006, 2009). The “bandwidth bottleneck” is experienced by the peer when the aggregate bandwidth available from all other peers is not sufficient to fully utilize the incoming access link bandwidth (Magharei & Rejaie, 2006, 2009). The “content bottleneck” is experienced by the peer when the useful content from other peers is not sufficient to fully utilize the bandwidth available in the network (Magharei & Rejaie, 2006, 2009).
The discussion on the bottleneck in Web 2.0 is not limited to Peer-to-Peer but also to platform computing. In Web 2.0, the user interacts with the web as it is not only read as the case in Web 1.0 but also has the write capabilities. This feature of read-write capabilities can cause a bottleneck with a high concurrent reading and writing operations using a large set of data (Choudhury, 2014). A data-intensive application or very large-scale data transfer can cause a bottleneck, and it can be very costly (Armbrust et al., 2009). To solve this issue is to send disks or even whole computers via overnight delivery services (Armbrust et al., 2009). When the data is moved to the Cloud, the data does not have any bottleneck any longer because the data transfer is within the Cloud such as storing the data in S3 in Amazon Web Services, which can be transferred without any bottleneck to EC2 (Elastic Compute Cloud) (Armbrust et al., 2009). WAN bandwidth can cause a bottleneck, and the intra-cloud networking technology can also have a performance bottleneck (Armbrust et al., 2009). One Gigabit Ethernet (1GbE) reflects a bandwidth that can have a bottleneck because it is not sufficient to process a large set of data using technology such as Map/Reduce. However, in the Cloud Computing, the 10Gigabit Ethernet is used for such aggregation links (Armbrust et al., 2009). Map/Reduce is a processing strategy to divide the operation into two jobs Map and then Reduce using the “filtering-join-aggregation” tasks (Ji, Li, Qiu, Awada, & Li, 2012). When using the classic Hadoop MapReduce, the cluster is not artificially segregated into Map and reduce slots (Krishnan, 2013). Thus, the application jobs are bottlenecked on the Reduce operation which limits the scalability in the job execution (Krishnan, 2013). Because of the scalability bottleneck faced by the traditional Map/Reduce, Yahoo introduced YARN for Yet Another Resource Negotiators to overcome such scalability bottleneck in 2010 (White, 2012).
There are additional performance issues which cannot be predicted. For instance, there is a performance degradation when using Virtual Machines (VMs) which share CPU and main memory in the Cloud Computing platform (Armbrust et al., 2009). Moreover, the bottleneck at the computing platform can be caused when moving a large set of data continuously to a remote CPUs (Foster, Zhao, Raicu, & Lu, 2008). The Input/Output (I/O) operations can also cause a performance degradation issue (Armbrust et al., 2009; Ji et al., 2012). Flash memory is another aspect that can minimize the performance. The scheduling of VMs for High-Performance Computing (HPC) apps is another unpredictable performance issue (Armbrust et al., 2009). The issue of such scheduling for HPC is to ensure that all threads of a program are running concurrently which is not provided by either VMs or the operating systems (Armbrust et al., 2009). Another issue with the computing platform about bottleneck is the availability of the cloud environment is threatened when there is a flooding attack which will affect the available bandwidth, processing power and the memory (Fernandes, Soares, Gomes, Freire, & Inácio, 2014). Thus, to minimize the bottleneck issue when processing a large set of data in the computing platform, the data must be distributed over many computers (Foster et al., 2008; Modi, Patel, Borisaniya, Patel, & Rajarajan, 2013).
Web 3.0 – Semantic Web
Web 3.0 is the third generation of the Web. It was introduced by John Markoff of the New York Times in 2006 (Aghaei et al., 2012). Web 3.0 is known as “Semantic Web” as well as the “Web of Cooperation” (Aghaei et al., 2012), and as “Executable Web (Choudhury, 2014; Kujur & Chhetri, 2015; Patel, 2013). Berners-Lee introduced the concept of Semantic Web in 2001 (T. Berners-Lee, Hendler, & Lassila, 2001). The underlying concept of Web 3.0 is to link, integrate and analyze data from various datasets to obtain new information stream (Aghaei et al., 2012). Web 3.0 has a variety of capabilities (Aghaei et al., 2012). When using Web 3.0, the data management can be improved, the accessibility of the mobile internet can be supported, creativity and innovation are simulated, the satisfaction of the customers is enhanced, and the collaboration in the social web is organized (Aghaei et al., 2012; Choudhury, 2014). Another key factor for Web 3.0 is that the web is no longer understood only by human but also by machines (Aghaei et al., 2012; Choudhury, 2014). In other words, the web is understood by human and machines in Web 3.0, where the machines first understand the web followed by a human (Aghaei et al., 2012; Choudhury, 2014). Web 3.0 supports world wide database and web oriented architecture which was described as a web of document (Patel, 2013). Web 3.0 characteristics include portable personal web, and consolidating dynamic content, lifestream, individuals, RDF, and user engagements (Aghaei et al., 2012; Patel, 2013). Examples of Web 3.0 include Google Map, My Yahoo (Patel, 2013). Since Web 3.0 is described as the mobile and sensor-based era, the majority of the data sources are from mobile and sensor-based devices (Chen, Chiang, & Storey, 2012).
Key Technologies of Web 3.0
While in Web 2.0 the content creativity of users is the target, in Web 3.0 the linked data sets are the target. Web 3.0 is not only for publishing data on the web but also linking related data (Choudhury, 2014). Linked Data principles introduced by Berners-Lee as the rules to publish and connect data on the web in 2007 (Aghaei et al., 2012; Choudhury, 2014). These rules are summarized below:
- URI should be used as Names of Things. HTTP URIs should be used to look up those Names.
- Useful Information should be provided using the standards of RDF, SPARQL by looking up the URIs.
- Links to other URIs should be included to discover more things.
In (T. Berners-Lee et al., 2001) the technology of the Semantic Web included XHTML, SVG, and SMIL and placed on top of the XML layer. XSLT is used for the transformation engines, while XPath and XPointer are used for path and pointer engines (T. Berners-Lee et al., 2001). CSS and XSL are used for the style engines and formatters (T. Berners-Lee et al., 2001).
Web 3.0 Architecture
The Semantic Web framework is a multi-layered architecture. The degree of the structure among objects is based on a model called Resource Description Framework” (RDF) (Aghaei et al., 2012; Patel, 2013). The structure of the semantic data include from the bottom up, the Unicode and URI at the bottom of the framework, followed by the Extensible Markup Language (XML), RDF, RDF Schema, Ontology Web Language (OWL), Logic and Proof and Trust at the top (see Figure 2).
Figure 2: Web 3.0 – Semantic Web Layered Architecture (Patel, 2013).
There are eight categories for Web Semantic identified by (T. Berners-Lee et al., 2001) to describe the relation of Web Semantic with Hypermedia Research. The first category describes the basic node, link and anchor data mode. The second category reflects the typed nodes, links, and anchors. The Conceptual Hypertext is the third category of this relation. Virtual Links and Anchors is the fourth category, while searching and querying is the fifth category. Versioning and Authentication features, Annotation and User Interface Design beyond the navigational hypermedia reflect the last three categories of the relation of Semantic Web with Hypermedia Research (T. Berners-Lee et al., 2001).
Web 3.0 is expected to include four major drivers in accordance with Steve Wheeler as cited in (Chisega-Negrila, 2016). The first driver includes the distributed computing. The second driver includes the extended smart phone technology. The third driver includes the collaborative intelligence. The last driver is the 3D visualization and interaction (Chisega-Negrila, 2016).
Web 3.0 Performance Bottleneck
The result of the research in (Firat & Kuzu, 2011) found that the components of the Semantic Web of XML, RDF and OWL help overcome hypermedia bottlenecks in various areas of the eLearning such as the cognitive overload, disorientation in hypermedia (Firat & Kuzu, 2011). However, Web 3.0 faces the bottleneck of the search in sensor networks (Nicolaidis & Iniewski, 2017), as the use of mobile technology has been increasing (see Figure 3) (Nicolaidis & Iniewski, 2017).
Figure 3: Increasing Use of the Mobile Technology (Nicolaidis & Iniewski, 2017)
The wireless communication in sensor networks is causing the bottleneck with the increasing number of requests (Nicolaidis & Iniewski, 2017). Thus, the time to answer queries gets increased, which result in decreasing the search experience of the users (Nicolaidis & Iniewski, 2017). Thus, the approach of the push-based is used to force sensors to push regularly their new readings to a base station, which decrease the latency to the users’ requests (Nicolaidis & Iniewski, 2017). However, this approach cannot guarantee that the data is up-to-date as it can be outdated (Nicolaidis & Iniewski, 2017). If there are no much changes, the update can be sent when there is a change. However, if the changes are too often, this approach can cause congestion of the wireless channel resulting in delayed or missing messages (Nicolaidis & Iniewski, 2017). Prediction-Model-Based approaches are proposed to reduce the volume of the data when transmitting dynamic sensor data (Nicolaidis & Iniewski, 2017). However, to create an accurately predicted model, a series of sensor readings need to be transmitted (Nicolaidis & Iniewski, 2017). Using the prediction approach, the latency is reduced because the prediction at a based station instead of contacting a sensor over the non-reliable multi-hop connection (Nicolaidis & Iniewski, 2017). Moreover, scaling the systems to more sensors causes another bottleneck which needs to be solved by utilizing the distribution approach (Nicolaidis & Iniewski, 2017).
Moreover, in (Konstantinou, Spanos, Stavrou, & Mitrou, 2010), the contemporary Semantic Web is defined as the counterpart of the Knowledge Acquisition bottleneck where it was too expensive to acquire and encode the large amount of knowledge that is needed for the application (Konstantinou et al., 2010). The annotation of the content in Web Semantic is still an open issue and is regarded as an obstacle for Semantic Web applications which need the considerable volume of data to demonstrate their utility (Konstantinou et al., 2010).
Web 4.0 – Intelligent Web
The rapid increase in the communication using wireless enables another major transition in the Web (Kambil, 2008). This transition enables people to connect with objects anywhere and anytime at the physical world as well as at the virtual world (Kambil, 2008). Web 4.0 is the fourth generation of Web and is known as “web of intelligence connections” (Aghaei et al., 2012) or “Ultra-Intelligent Electronic Agent” (Choudhury, 2014; Kujur & Chhetri, 2015; Patel, 2013). It is read-write, execution, and concurrency web with intelligent interactions (Aghaei et al., 2012; Patel, 2013). Some consider it as “Symbiotic Web” where human and machines can interact in symbiosis fashion (Aghaei et al., 2012; Choudhury, 2014; Kujur & Chhetri, 2015; Patel, 2013) and as “Ubiquitous Web” (Kujur & Chhetri, 2015; Patel, 2013; Weber & Rech, 2009). Using Web 4.0, machines will be intelligent reading the web content and deliver web pages with superior performance at the real-time (Aghaei et al., 2012; Choudhury, 2014). It is also known as WebOS which will act as the “Middleware” which will act as an operating system (Aghaei et al., 2012; Choudhury, 2014). WebOS is expected to resemble or be equivalent to our brain which will highly interact intelligently (Aghaei et al., 2012; Choudhury, 2014). As indicated in (Aghaei et al., 2012) “the web is moving toward using artificial intelligence to become an intelligent web.” Web 4.0 will reflect the integration between people and virtual worlds and objects at the real-time (Kambil, 2008). The Artificial Intelligence technologies are expected to play a role in Web 4.0 (Weber & Rech, 2009).
The major challenges for Web 4.0 generating value that is based on full integration of the physical objects and virtual objects with other contents that are generated by users (Kambil, 2008). This challenge could lead to the next generation of Supervisory Control and Data Acquisition (SCADA) applications (Kambil, 2008). The challenge can also lead to generating value from sources such as “entertainment” which collect information from human and objects (Kambil, 2008). The migration of virtual world to physical is another challenge in Web 4.0 (Patel, 2013). A good example of Web 4.0 is provided by (Patel, 2013), which is to search or Google your home to locate an object such as your car key.
An application of the Web 4.0 is implemented by Rafi Haladjian and Olivier who created the first consumer electronics in Amazon, which can recognize you and provide recommended product and personalized advice (Patel, 2013). The time frame for Web 4.0 is expected to be 2020 – 2030 (Loretz, 2017; Weber & Rech, 2009). Web 4.0 is still in progress.
Web 4.0 and “Internet of Things”
Some like (Loretz, 2017) considers “Internet of Things” as part of Web 3.0 and Web 4.0, while others like (Pulipaka, 2016) categorize it under Web 4.0. Thus, the discussion on the “Internet of Things” from the bottleneck perspective is addressed under the Web 4.0 section of this paper.
As indicated in (Atzori, Iera, & Morabito, 2010) Internet of Things (IoT) is regarded to be “one of the most promising fuels of Big Data expansion” (De Mauro, Greco, & Grimaldi, 2015). IoT seems promising as Google acquired Nest for $3.2 billion in January 2014 (Dalton, 2016). The Nest is a smart hub producer at the forefront of the Internet of Things (Dalton, 2016). This acquiring can tell the importance of the IoT. IoT is becoming powerful because it affects our daily life and the behavior of the users (Atzori et al., 2010). The underlying concept of the IoT is the ubiquitous characteristics that using various devices such as sensors, mobile phones and so forth (Atzori et al., 2010).
As cited in (Batalla & Krawiec, 2014) “Internet of Things (IoT) is global network infrastructure, linking physical and virtual objects through the exploitation of data capture and communication capabilities” (Batalla & Krawiec, 2014). IoT is described by (Batalla & Krawiec, 2014) as “a huge connectivity platform for self-managed objects.” IoT is increasingly growing, and the reasons for such strong growth go to the inexpensive cost of the computing including sensors and the growth of Wi-Fi (Gholap & Asole, 2016; Gubbi, Buyya, Marusic, & Palaniswami, 2013), and 4G-LTE (Gubbi et al., 2013). Other factors include the growth of mobiles, the rise of software developments, the emergence of standardized low-power wireless technologies (Gholap & Asole, 2016).
With the advancement in the Web, from static web pages in Web 1.0 to network web in Web 2.0, to ubiquitous computing web in Web 3.0, the increased requirement for “data-on-demand” using complex, and intuitive queries becomes significant (Gubbi et al., 2013). With IoT, many objects and many things surrounding people will be on the network (Gubbi et al., 2013). The Radio Frequency IDentification (RFID) and the technologies of the sensor network emerge to respond to the IoT network challenges where information and communication systems are embedded in the environment around us invisibly (Gubbi et al., 2013). The computing criterion for the IoT will go beyond the traditional scenarios of the mobile computing which utilize the smartphones and portables (Gubbi et al., 2013). IoT will evolve to connect existing everyday objects and embed intelligence into our environment (Gubbi et al., 2013).
Web 4.0 and IoT Performance Bottleneck
The elements of IoT include the RFID, Wireless Sensor Networks (WSN), Addressing Schemes, Data Storage and Analytics, and Visualization (Gubbi et al., 2013). IoT will require the persistence of the network to channel the traffic of the data ubiquitously. IoT confronts a bottleneck at the interface between the gateway and wireless sensor devices (Gubbi et al., 2013). The bottleneck at the interface is between the Internet and smart object networks of the RFID or WSN subnets (Jin, Gubbi, Marusic, & Palaniswami, 2014). Moreover, the scalability of the address of the device of the existing network must be sustainable (Gubbi et al., 2013). The performance of the network or the device functioning should not be affected by adding networks and devices (Gubbi et al., 2013; Jin et al., 2014). The Uniform Resource Name (URN) system will play a significant role in the development of IoT to overcome these issues (Gubbi et al., 2013).
Moreover, although Cloud can enhance and simplify the communication of IoT, the Cloud can still represent a bottleneck in certain scenarios (Botta, de Donato, Persico, & Pescapé, 2016). As indicated in (Gubbi et al., 2013), the high capacity and large-scale web data generated by IoT and as IoT grows, the Cloud becomes a bottleneck (Gubbi et al., 2013). A framework proposed by (Gubbi et al., 2013) to enable scalability of the cloud to provide the capacity that is required for IoT. While the proposed framework of (Gubbi et al., 2013) enables the separation of the networking, computation, storage and visualization theme, it allows the independent growth in each domain, at the same time enhances each other in an environment that is shared among them (Gubbi et al., 2013).
Web 4.0 and IoT New Challenges
IoT faces additional challenges such as Addressing and Networking Issues (Atzori et al., 2010). The investigation effort has been exerted about the integration of RFID tags into IPv6. Mobile IP is proposed as a solution for the mobility in IoT scenarios (Atzori et al., 2010). Moreover, the DNS (domain name servers), which provide IP address of a host from a certain input name, does not seem to serve the IoT scenarios where communications are among objects and not hosts. Object Name Service (ONS) is proposed as a solution to the DNS issue (Atzori et al., 2010). ONS will associate a reference to a description of the object and the related RFID tag identifier, and it must work in a bidirectional manner (Atzori et al., 2010). For the complex operation of IoT, the Object Code Mapping Service (OCMS) is still an open issue (Atzori et al., 2010). TCP as the Transmission Control Protocol is found inadequate and inefficient for the transmission control of end-to-end in the IoT (Atzori et al., 2010). The TCP issue is still an open issue for IoT (Atzori et al., 2010). Other issues of IoT include Quality of Service, Security, and Privacy.
Web 5.0 – Symbionet Web
Web 5.0 is still in progress and can be regarded as “Symbionet Web” (Loretz, 2017; Patel, 2013) or “Telepathic Web” (Loretz, 2017). In Web 5.0, people will be able to have their own Personal Servers (PS), where they can store and communicate with their personal data using Smart Communicator (SC) such as Smart Phones, Tablets and so forth (Patel, 2013). The Smart Communications will be 3D Virtual World of the Symbionet (Patel, 2013). Web 5.0 will be aware of your emotions and feelings (Kambil, 2008). Objects such as tools such as headset are investigated for emotional interaction (Kambil, 2008). While there is a claim from some companies that they map emotions and feelings, this claim can be hard to imagine because emotions and feelings are complex (Kambil, 2008). However, some technologies are examining the emotions effect (Kambil, 2008). There is an idea that there will “brain implant” which enables the person to communicate with the internet and web by thoughts (Loretz, 2017). The person will be able to open pages just by thoughts (Loretz, 2017). The time frame for Web 5.0 is after 2030 (Loretz, 2017).
Conclusion
This project discussed the Web from the inception of Web 1.0 until the last generation of Web 5.0. The project addressed the main characteristics of each generation and the main sources for generating the large-scale web data. Web 1.0 is known as the “Web of Information Connections” where information is broadcasted by companies for users to read. Web 2.0 is known as the “Web of People Connections” where people connected. Web 3.0 is known as the “Web of Knowledge Connections” where people share knowledge. Web 4.0 is known as the “Web of Intelligence Connections” where Artificial Intelligence is expected to play a role. Web 5.0 is known as the “Symbionet Web” where emotions and feelings are expected to be communicated to the machines, and be part of the Web interactions.
The
project also discussed the key technologies and the underlying architecture of
each Web generation. Moreover, this paper also discussed and analyzed the
performance bottlenecks when accessing the large-scale data for each Web
generation, and the proposed solutions for some of these bottlenecks and the open
issues.
References
Aghaei, S., Nematbakhsh, M. A., & Farsani, H. K. (2012). Evolution of the world wide web: From WEB 1.0 TO WEB 4.0. International Journal of Web & Semantic Technology, 3(1), 1.
Armbrust, M., Fox, A., Griffith, R., Joseph, A. D., Katz, R. H., Konwinski, A., . . . Stoica, I. (2009). Above The Clouds: A Berkeley View of Cloud Computing.
Atzori, L., Iera, A., & Morabito, G. (2010). The internet of things: A survey. Computer networks, 54(15), 2787-2805.
Batalla, J. M., & Krawiec, P. (2014). Conception of ID layer performance at the network level for Internet of Things. Personal and Ubiquitous Computing, 18(2), 465-480.
Berners-Lee, T. (1996). WWW: Past, present, and future. Computer, 29(10), 69-77.
Berners-Lee, T., Hendler, J., & Lassila, O. (2001). The semantic web.
Berners-Lee, T. J. (1992). The world-wide web. Computer networks and ISDN systems, 25(4-5), 454-459.
Botta, A., de Donato, W., Persico, V., & Pescapé, A. (2016). Integration of Cloud Computing and Internet Of Things: a Survey. Future Generation computer systems, 56, 684-700.
Chen, H., Chiang, R. H., & Storey, V. C. (2012). Business Intelligence and Analytics: From Big Data to Big Impact. MIS quarterly, 36(4), 1165-1188.
Chisega-Negrila, A. M. (2016, 2016). IMPACT OF WEB 3.0 ON THE EVOLUTION OF LEARNING, Bucharest.
Choudhury, N. (2014). World Wide Web and its journey from web 1.0 to web 4.0.
Dalton, C. (2016). Brilliant Strategy for Business: How to plan, implement and evaluate strategy at any level of management: Pearson UK.
De Mauro, A., Greco, M., & Grimaldi, M. (2015). What is big data? A consensual definition and a review of key research topics. Paper presented at the AIP Conference Proceedings.
Demirkan, H., & Delen, D. (2013). Leveraging the capabilities of service-oriented decision support systems: Putting analytics and big data in cloud. Decision Support Systems, 55(1), 412-421.
Fernandes, D. A., Soares, L. F., Gomes, J. V., Freire, M. M., & Inácio, P. R. (2014). Security issues in cloud environments: a survey. International Journal of Information Security, 13(2), 113-170. doi:/10.1007/s10207-013-0208-7
Firat, M., & Kuzu, A. (2011). Semantic web for e-learning bottlenecks: disorientation and cognitive overload. International Journal of Web & Semantic Technology, 2(4), 55.
Foster, I., Zhao, Y., Raicu, I., & Lu, S. (2008). Cloud Computing and Grid Computing 360-Degree Compared. Paper presented at the 2008 Grid Computing Environments Workshop.
Gholap, K. K., & Asole, S. (2016). Today’s Impact of Big Data on Cloud. International Journal of Engineering Science, 3748.
Governor, J., Hinchcliffe, D., & Nickull, D. (2009). Web 2.0 Architectures: What entrepreneurs and information architects need to know: ” O’Reilly Media, Inc.”.
Gubbi, J., Buyya, R., Marusic, S., & Palaniswami, M. (2013). Internet of Things (IoT): A vision, architectural elements, and future directions. Future Generation computer systems, 29(7), 1645-1660.
Hu, H., Wen, Y., Chua, T.-S., & Li, X. (2014). Toward scalable systems for big data analytics: A technology tutorial. IEEE Access, 2, 652-687.
Ji, C., Li, Y., Qiu, W., Awada, U., & Li, K. (2012). Big Data Processing in Cloud Computing Environments. Paper presented at the 2012 12th International Symposium on Pervasive Systems, Algorithms and Networks.
Jin, J., Gubbi, J., Marusic, S., & Palaniswami, M. (2014). An information framework for creating a smart city through internet of things. IEEE Internet of Things Journal, 1(2), 112-121.
Kambil, A. (2008). What is your Web 5.0 strategy? Journal of business strategy, 29(6), 56-58.
Konstantinou, N., Spanos, D.-E., Stavrou, P., & Mitrou, N. (2010). Technically approaching the semantic web bottleneck. International Journal of Web Engineering and Technology, 6(1), 83-111.
Krishnan, K. (2013). Data warehousing in the age of big data: Newnes.
Kujur, P., & Chhetri, B. (2015). Evolution of World Wide Web: Journey From Web 1.0 to Web 4.0 IJCST, 6(1).
Loretz, C. (2017). The World Wide Web – From Web 1.0 to Web 5.0 Retrieved from https://carikesocial.wordpress.com/2017/03/15/the-world-wide-web-from-web-1-0-to-web-5-0/.
Magharei, N., & Rejaie, R. (2006). Understanding mesh-based peer-to-peer streaming. Paper presented at the Proceedings of the 2006 international workshop on Network and operating systems support for digital audio and video.
Magharei, N., & Rejaie, R. (2009). Prime: Peer-to-peer receiver-driven mesh-based streaming. IEEE/ACM Transactions on Networking (TON), 17(4), 1052-1065.
Markatos, E. P. (2002). Tracing a large-scale peer to peer system: an hour in the life of gnutella. Paper presented at the Cluster Computing and the Grid, 2002. 2nd IEEE/ACM International Symposium on.
Miller, M. (2008). Cloud Computing, Web-Based Applications That Change the Way You Work and Collaborate Online. Michael Miller.
Modi, C., Patel, D., Borisaniya, B., Patel, A., & Rajarajan, M. (2013). A survey on security issues and solutions at different layers of Cloud computing. The Journal of Supercomputing, 63(2), 561-592.
Mosberger, D., & Jin, T. (1998). httperf—a tool for measuring web server performance. ACM SIGMETRICS Performance Evaluation Review, 26(3), 31-37.
Nicolaidis, I., & Iniewski, K. (2017). Building Sensor Networks: CRC Press.
O’Reilly, T. (2007). What is web 2.0.
Patel, K. (2013). Incremental journey for World Wide Web: introduced with Web 1.0 to recent Web 5.0–a survey paper.
Pulipaka, G.-i. (2016). Resolving large-scale performance bottlenecks in IoT Networks accessing Big Data, Retrieved from https://medium.com/@gp_pulipaka/resolving-large-scale-performance-bottlenecks-in-iot-networks-accessing-big-data-b0e386c58796.
Weber, S., & Rech, J. (2009). An overview and differentiation of the evolutionary steps of the web XY movement: the web before and beyond 2.0. Handbook of Research on Web 2.0, 3.0, and X. 0: Technologies, Business, and Social Applications: Technologies, Business, and Social Applications, 12.
White, T. (2012). Hadoop: The definitive guide: ” O’Reilly Media, Inc.”.
Think and Knowledge Tank 