Abstract
Nowadays users access the Web differently from what they used to in the past, the devices we use to fetch applications from the Web are not the same as the slow desktop computers that we owned twenty years ago. The Web can be accessed by devices with different sizes and capabilities, ranging from desktop to laptop computers, or even from tablets to phones. More recently, also smart and embedded devices, such as smart televisions, smart watches or parts of smart cars, are able to communicate with remote Web servers through the Web. The average number of Web-enabled devices owned by a single user has also increased and the connected user usually access the Web with multiple devices concurrently.
Web applications are traditionally designed having in mind a server-centric architecture, whereby the whole persistent data, dynamic state and logic of the application are stored and executed on the Web server. The endpoint client device running the Web browser traditionally only renders pre-computed views fetched from the server. As more data, state and computations are shifted to the client, it becomes more challenging to run Web applications across multiple devices while ensuring they can synchronize their state and react in real-time to changes of the set of available devices.
In this symposium we define how we apply the liquid software paradigm to the design of liquid Web applications and we identify and address the challenges of creating multi-device liquid user experiences. We discuss about how much is important to research on liquid software running on the Web. We also present our prototype framework called Liquid.js for Polymer, whose goal is to simplify the creation of liquid Web applications.
You have full access to this open access chapter, Download conference paper PDF
Similar content being viewed by others
Keywords
1 Introduction
In the era of multiple device ownership [1], software applications are no longer ran strictly on a single device [6]. The liquid software [23] metaphor [25] associates the behavior of a fluid, which can adapt to the shape of its own container, to software that can be deployed and can operate seamlessly across multiple devices owned by one or multiple users. Liquid software needs to adapt to the capabilities of a single device (e.g. responsive) and it must be able to adapt to the set of devices running the application.
The metaphor focuses on the expected liquid user experience when the users interact with applications deployed on multiple devices, in particular liquid software can: 1. adapt the user interface to the set of devices being concurrently used to run the application; 2. seamlessly migrate [21] the running application, or some part of it (e.g. individual components of the whole application), across multiple devices; 3. synchronize the state of the application distributed across all paired devices; 4. offload computations to neighbour paired devices in order to increase the overall performance of the application.
Web applications were traditionally developed following a thin client architecture whereby most of the logic and the entire persistent state of the application would be executed and stored on a central Web server [4]. Because of the different drivers in the design choices, traditional Web software architectures would offer only partial support for the liquid user experience [11]. However as the Web evolves, and as the Web technology standards increase in number and variety, we can evolve from traditional to new architectures suited for liquid software. For example, thanks to new communication protocols defined in the WebRTC standard, we can revisit the architectural design decision of traditional Web architectures and systematically study and design architectures driven by different software quality drivers.
2 Motivation
The development of liquid applications with high deployability, that can correctly operate and adapt their behavior in accordance to their deployment context on multiple devices, requires to address these issues at the design time. Liquid software deals with the following use cases scenarios [17]:
-
Sequential Use: a single user runs an application on different devices at different times. The users can stop working on a device and resume their work on a new one. The application needs to be responsive and adapt to both devices and it needs to be able to resume the work accomplished by the user on the first device and display it in the new one.
-
Simultaneous Use: a single user can access the application from several devices concurrently. The application needs to adapt to the set of devices, which can dynamically change over time, i.e. the users can connect to the application with new devices or can disconnect some of the devices. The devices can display a distributed view of the application user interface instead of just copying and adapting the user interface to each device. In the case of a distributed user interface, each device has a distinct role in the application [20].
-
Collaborative Use: several users run the same application on their devices. The collaborative use case scenario can be either sequential or simultaneous.
All the scenarios share the same challenges in adapting the user interface to different devices and in synchronizing the data and state of the execution between them. The data and state synchronization is fundamental in the implementation of liquid software [23] because the devices and users need to be aware of the results of their actions previously or simultaneously done in other devices.
The liquid software ecosystem should allow the connection of heterogeneous devices and overcome the native software ecosystem boundaries. In this way, the developers need to implement the application once, which could then adapt itself and run on all kind of connected devices [7]. We realize the liquid software ecosystem by leveraging on the Web ecosystem, where applications are deployed on demand and through Responsive Web Design [22] are adapted to fit on the local device displays. Properties such as openness and freedom from proprietary features make the Web a natural choice over native applications that are bound to a particular operating system, manufacturer, or vendor-specific ecosystem [24].
Different solutions have been developed and researched during the past years on how liquid applications could be built, starting from server-centric approaches like the platform Joust developed in 1999 [19]. However, as the number of connected devices grows, a centralized approach is not enough and we need to switch to decentralized solutions and techniques, such as the Fluid computing middleware [5]. In the past years HTML5 standards led the Web to what Anthes called the Web Revolution [2]. The Web now is more developer-friendly and any device able to run a Web browser can run the same application on top of it even if the devices are completely different from one another. Thanks to the Web, liquid applications can automatically run across heterogeneous device environments by using frameworks like the Cross-Device [20] or Liquid.js for Polymer [9]. Even though most current Web applications have a strongly centralized architecture, we are quickly heading back towards the decentralized Web [3]. Shifting to a decentralized or distributed paradigm changes the way we are using the Web [18].
3 Research Questions
The objective of this research is to propose a way for developers to efficiently upgrade solid Web applications allowing them to become liquid. For this reason we are building a prototype framework that allows the creation of new liquid applications and the upgrading of already existing applications. By building such framework we aim to: – Show that it is possible to upgrade solid applications with all liquid features without the need to completely redesign and build the whole software again. Since the solid behavior of the software should be unaffected, we aim to add the liquid behavior of the software around the application itself, successfully decoupling the liquid functionalities from the solid behavior of the software. – Evaluate the overhead of the added liquid behavior on top of the solid application. From the developer’s point of view, the added liquid behavior of the software should not affect the non-functional quality attributes of the solid application (such as performance, scalability, ...). However, since it is not possible to upgrade a software without affecting any of its qualities, we aim to study the trade-offs so that the execution of the application remains unaffected. From the user’s perspective the Liquid User Experience should be as performant as the environment allows. The liquid software should minimize latency in the synchronization between devices, while also trying to minimize bandwidth and memory usage.
The goal of research is to answer the following research questions: – RQ. 1: How can we allow Web developers to design liquid software and liquid User Experiences? Liquid Web applications are complex software solutions able to interact with multiple devices simultaneously. The complexity of these interactions is transparently hidden behind the liquid User Experience and requires real-time message passing and data synchronization among all the connected devices in order to seamlessly move applications among them. Liquid Web software can be designed following different quality attribute drivers and the design can be reflected into a multitude of different software architectures depending on the design alternatives that are selected during the design phase. What are the design alternatives related to liquid Web applications? What are the implication of such choices? – RQ. 2: Can we abstract liquid Web applications away from the current strongly centralized deployment approaches? The vast majority of Web applications implementing a liquid User Experience rely on centralized architectures and deployment, however interactions between the devices do not necessarily need to relay on a Web server and can happen directly between them. From the user perspective, this approach can preserve privacy, since the user data and all user interactions can be modeled to be synchronized independently from a centralized Web server deployed in the Cloud outside the user’s control. What are the trade-off of this choice? – RQ. 3: How can we make the liquid User Experience of a Web application automatically adapt to the set of connected devices? Developers of liquid software should provide to the user a mechanism for populating all of their devices with pieces of the application they are running. For this reasons we must provide to the developers the tools for developing automatic complementary views. This allows the developers to have a certain degree of control on how the application is migrated across the devices, instead of exclusively let the user decide how the application deployment configuration will evolve over time. A misuse of the manual liquid User Experience may lead to non-intuitive deployment configurations which contradict with the developer expectations and intent. – RQ. 4: How can we take advantage of all resources provided by the connected devices? Any connected device has access to at least a screen, a data storage and a CPU. While the Liquid User Experience takes advantage of all the screens and the decentralized synchronization can take advantage of all the provided data storages, we need to further develop a mechanism for efficiently exploit the CPUs of all connected devices in the liquid software environment. Without such a mechanism all the devices computes the same operation multiple times, even if it would be better to compute the operation in a single device and then broadcast the result.
4 Contributions
So far we have published and presented papers relative both to the design of liquid architectures and to Liquid.js for Polymer: – we modeled the design space of liquid software [15, 16] where we discussed the implications and the relative design decisions of liquid software; – we studied the architectures of liquid applications and derived the maturity model for liquid architectures [11]. In the maturity model we describe the evolution of liquid applications in the Web and abstract their design from the technologies employed in the system, moreover we describe the driver quality attributes associated to each level of the maturity model. – We have several contributions related to Liquid.js for Polymer. In [10] we show how we design the migration of Web components between devices, in [9] we discuss the design of the distributed state in the framework, and in [8] we discuss how to handle child liquid components instantiated inside parent liquid components. We presented the Liquid.js API in [13], the decentralized view adaptation in [12] and the complementary view adaptation in [14].
References
Anderson, M.: Technology device ownership: 2015 (2015). http://www.pewinternet.org/2015/10/29/technology-device-ownership-2015/
Anthes, G.: HTML5 leads a web revolution. Commun. ACM 55(7), 16–17 (2012)
Berners-Lee, T.: Re-Decentralizing the Web - Some Strategic Questions. Keynote Address at Decentralized Web Summit (2016)
Berners-Lee, T., Fischetti, M., Foreword By-Dertouzos, M.L.: Weaving the Web: The Original Design and Ultimate Destiny of the World Wide Web by its Inventor. HarperInformation (2000)
Bourges-Waldegg, D., Duponchel, Y., Graf, M., Moser, M.: The fluid computing middleware: bringing application fluidity to the mobile internet. In: Proceedings of the IEEE International Symposium on Applications and the Internet (SAINT 2005), pp. 54–63 (2005)
Di Geronimo, L., Husmann, M., Norrie, M.C.: Surveying personal device ecosystems with cross-device applications in mind. In: Proceedings of the 5th ACM International Symposium on Pervasive Displays, pp. 220–227. ACM (2016)
Feiner, S., Shamash, A.: Hybrid user interfaces: breeding virtually bigger interfaces for physically smaller computers. In: Proceedings of the 4th Annual ACM Symposium on User Interface Software and Technology, pp. 9–17. ACM (1991)
Gallidabino, A.: Migrating and pairing recursive stateful components between multiple devices with Liquid.js for polymer. In: Bozzon, A., Cudre-Maroux, P., Pautasso, C. (eds.) ICWE 2016. LNCS, vol. 9671, pp. 555–558. Springer, Cham (2016). https://doi.org/10.1007/978-3-319-38791-8_47
Gallidabino, A., Pautasso, C.: Deploying stateful web components on multiple devices with Liquid.js for polymer. In: Proceedings of Component-Based Software Engineering (CBSE2016), pp. 85–90. IEEE (2016)
Gallidabino, A., Pautasso, C.: The Liquid.js framework for migrating and cloning stateful web components across multiple devices. In: Proceedings of the 25th International Conference on the World Wide Web (WWW 2016), Demonstrations, pp. 183–186 (2016)
Gallidabino, A., Pautasso, C.: Maturity model for liquid web architectures. In: Cabot, J., De Virgilio, R., Torlone, R. (eds.) ICWE 2017. LNCS, vol. 10360, pp. 206–224. Springer, Cham (2017). https://doi.org/10.1007/978-3-319-60131-1_12
Gallidabino, A., Pautasso, C.: Decentralized computation offloading on the edge with liquid WebWorkers. In: Mikkonen, T., Klamma, R., Hernández, J. (eds.) ICWE 2018. LNCS, vol. 10845, pp. 145–161. Springer, Cham (2018). https://doi.org/10.1007/978-3-319-91662-0_11
Gallidabino, A., Pautasso, C.: The liquid user experience API. In: Companion of the The Web Conference 2018 on The Web Conference 2018 (TheWebConf2018), pp. 767–774 (2018)
Gallidabino, A., Pautasso, C.: Multi-device adaptation with liquid media queries. In: Bakaev, M. (ed.) 18th International Conference On Web Engineering (ICWE 2019). LNCS, vol. 11946, pp. 474–489. Springer (2019)
Gallidabino, A., et al.: On the architecture of liquid software: technology alternatives and design space. In: Proceedings of WICSA, pp. 122–127. IEEE (2016)
Gallidabino, A., Pautasso, C., Mikkonen, T., Systa, K., Voutilainen, J.P., Taivalsaari, A.: Architecting liquid software. J. Web Eng. 16(5&6), 433–470 (2017)
Google: The new multi-screen world: Understanding cross-platform consumer behavior (2012). http://services.google.com/fh/files/misc/multiscreenworld_final.pdf
Grundy, J., Wang, X., Hosking, J.: Building multi-device, component-based, thin-client groupware: issues and experiences. In: Australian Computer Science Communications, vol. 24, pp. 71–80. Australian Computer Society, Inc. (2002)
Hartman, J.J., Bigot, P., Bridges, P., Montz, B., Piltz, R., Spatscheck, O., Proebsting, T., Peterson, L.L., Bavier, A., et al.: Joust: a platform for liquid software. Computer 32(4), 50–56 (1999)
Husmann, M., Marcacci Rossi, N., Norrie, M.C.: Usage analysis of cross-device web applications. In: Proceedings 5th ACM International Symposium on Pervasive Displays, pp. 212–219. ACM (2016)
Luff, P., Heath, C.: Mobility in collaboration. In: Proceedings of the 1998 ACM Conference on Computer Supported Cooperative Work, pp. 305–314. ACM (1998)
Marcotte, E.: Responsive Web Design. Editions Eyrolles (2011)
Mikkonen, T., Systä, K., Pautasso, C.: Towards liquid web applications. In: Cimiano, P., Frasincar, F., Houben, G.-J., Schwabe, D. (eds.) ICWE 2015. LNCS, vol. 9114, pp. 134–143. Springer, Cham (2015). https://doi.org/10.1007/978-3-319-19890-3_10
Mikkonen, T., Taivalsaari, A.: Cloud computing and its impact on mobile software development: two roads diverged. J. Syst. Softw. 86(9), 2318–2320 (2013)
Taivalsaari, A., Mikkonen, T., Systa, K.: Liquid software manifesto: the era of multiple device ownership and its implications for software architecture. In: 38th Computer Software and Applications Conference (COMPSAC2014), pp. 338–343 (2014)
Author information
Authors and Affiliations
Corresponding author
Editor information
Editors and Affiliations
Rights and permissions
Copyright information
© 2019 Springer Nature Switzerland AG
About this paper
Cite this paper
Gallidabino, A. (2019). Liquid Web Architectures. In: Bakaev, M., Frasincar, F., Ko, IY. (eds) Web Engineering. ICWE 2019. Lecture Notes in Computer Science(), vol 11496. Springer, Cham. https://doi.org/10.1007/978-3-030-19274-7_45
Download citation
DOI: https://doi.org/10.1007/978-3-030-19274-7_45
Published:
Publisher Name: Springer, Cham
Print ISBN: 978-3-030-19273-0
Online ISBN: 978-3-030-19274-7
eBook Packages: Computer ScienceComputer Science (R0)