Today, even small devices – from mobile phones to industrial robots – are internet-connected, are capable of running software and are situated close to end-users or applications, rendering the overall systems induced software-intensive. Commonly understood by evocative terms such as Industry 4.0 or as said to be exhibiting smart functionalities, they are becoming ubiquitous and are increasingly integrated in daily life and are increasingly engineered with autonomy in mind.

The major hurdle to engineering such systems is the inherent complexity of their software, as software is the principal factor defining their overall behavior. This complexity manifests both at design as well as at runtime. At design time, software may be required to be designed and developed for heterogeneous platforms and stacks while ensuring interoperability. Software components may furthermore implement particular types of computation (such as verification or AI functionalities), often in a distributed manner. This is something which needs to be accommodated in both design and runtime cycles – a typical example case is Internet of Things applications, where technological advances have enabled even miniscule devices to run software; as such, a continuum from devices to cloud arises. At runtime, such systems are exposed to changes in different contexts derived from changes in environment, software configuration, execution infrastructure, or other unforeseen issues.

Paradigms and approaches from software engineering and programming languages have shown to be highly effective for such designs – however traditional methods and techniques face challenges from this new domain. Examples range from model-based engineering and code generation to tackle heterogeneity, to verification techniques employed at runtime for requirements validation or AI used to devise control actions. All those require the backing of sound engineering techniques in order to build and operate scalable, usable and efficient applications and systems that operate in a way that is beneficial to individuals, society and the environment. This Shonan meeting aims to investigate wide themes within software engineering for dependable ubiquitous systems, including:

• Software-defined Everything. Software is used to abstract and automate management and control of computational, networking, storage, or hard-ware resources of various devices. Applications involve various software stacks and exhibit different complexities, with multiple software components being deployed in diverse infrastructures and contexts being a central theme: components may be deployed on (or migrated to) different hosts, ranging from resource-constrained or domain-specific devices to powerful cloud servers. Architecting and developing such systems reliably is a major challenge. Software-defined everything here involves active management of the system by (possibly autonomous) software agents, which set in motion actions to satisfy system objectives. Attributes such as locality, variability in the environment, and distribution of computation (manifested as uncertainty at runtime) pose challenges, calling for additional management and control closer to the software components’ operating architectural layer. A further open problem is how to instrument requirements verification and control at runtime for systems that are diverse, are expected to scale (e.g., to avoid resource saturation or central points of failure), ensure conformance to new requirements (e.g., privacy, responsiveness), or are highly dynamic.
• Programming Models for Ubiquitous Computation. One critical problem in exploring ubiquitous and pervasive systems for greater societal benefits is the lack of a fundamental basis of widely accepted programming models for such systems. The ubiquitous computing scenario brings many new problems such as coping with the limited processing power of mobile devices, frequent disconnections, interoperation among different computing devices, the migration of code and tasks between heterogeneous devices, etc. It requires programming languages and models that can support mobility, interoperability, adaptation, and context awareness.
• Ethics for autonomous and intelligent systems. As deployment of autonomous and intelligent systems becomes increasingly pervasive, we need to establish societal and policy guidelines in order for such systems to remain human-centric and ensure that they serve humanity’s values and foundational ethical principles. The self-adaptive systems community has tackled mechanisms for attainment of technical goals; autonomous and intelligent systems however raise issues beyond simply addressing technical problems. These systems must be developed and should operate in a way that is beneficial to society and the environment.

The meeting aims at experts from software engineering, programming models, and internet technologies in the context of ubiquitous computing, and will be structured in three kinds of sessions.

• In the introductory session, each participant will briefly introduce oneself and present current ideas and research themes of interest. This will be followed by
• Presentations by selected attendees, intended to kickstart discussions on specific themes. The organisers will ensure that presentations are structured towards specific topics so that follow-up discussions involving mixed groups of participants can emerge. Finally,
• Break-out groups will be formed, to interactively discuss and develop specific topics. The topics will be discovered at the meeting, though the organizers will prepare some beforehand to bootstrap discussion. Proposed themes will revolve around:
  • What language features and models are needed to support hosting platforms’ technical specification and configuration details (e.g., their capabilities), and how can deployment and provisioning can be achieved across geographically dispersed, heterogeneous infrastructures?
  • How can control, coordination and self-healing be instrumented in software for ubiquitous systems? How to integrate regulation for ethical behavior in such a framework?
  • How can business logic be managed and abstracted from infrastructures’ capabilities?
  • Do non-traditional types of computation such as AI workflows or verification suggest novel programming and system models?
  • What are critical factors and attributes manifested at runtime that pose challenges?
  • How can we monitor runtime aspects and unforeseen as well as emergent system behaviors that might hinder dependability (or be against set ethical values), and devise potential counteractions in a selfadaptive manner?
  • In what form should programming support be manifested for ubiquitous software systems? Conceptual frameworks, middleware, novel programming models?
  • How can ethical concerns be embedded in the engineering of autonomous technologies, e.g., in the context of self-adaptive systems?

Discussions will be documented, so that at the end workshop findings can be distilled, open problems are identified and future actions can be proposed.