This work takes as a starting point a collection of patterns for engineering software for the cloud and tries to find how they are regarded and adopted by professionals. Existing literature assesses the adoption of cloud computing with a focus on business and technological aspects and falls short in grasping a holistic view of the underlying approaches. Other authors delve into how independent patterns can be discovered (mined) and verified, but do not provide insights on their adoption. We investigate (1) the relevance of the patterns for professional software developers, (2) the extent to which product and company characteristics influence their adoption, and (3) how adopting some patterns might correlate with the likelihood of adopting others. For this purpose, we survey practitioners using an online questionnaire (n = 102). Among other findings, we conclude that most companies use these patterns, with the overwhelming majority (97 percent) using at least one. We observe that the mean pattern adoption tends to increase as companies mature, namely when varying theproduct operation complexity,active monthly users, andcompany size. Finally, we search for correlations in the adoption of specific patterns and attempt to infer causation, providing further clues on how some practices depend or influence the adoption of others. We conclude that the adoption of some practices correlates with specific company and product characteristics, and find relationships between the patterns that were not covered by the original pattern language and which might deserve further investigation.

Automated Program Repair (APR) is an area of research focused on the automatic generation of bug-fixing patches. Current APR approaches present some limitations, namely overfitted patches and low maintainability of the generated code. Several works are tackling this problem by attempting to come up with algorithms producing higher quality fixes. In this experience paper, we explore an alternative. We believe that by using existing low-cost APR techniques, fast enough to provide real-time feedback, and encouraging the developer to work together with the APR inside the IDE, will allow them to immediately discard proposed fixes deemed inappropriate or prone to reduce maintainability. Most developers are familiar with real-time syntactic code suggestions, usually provided as code completion mechanisms. What we propose are semantic code suggestions, such as code fixes, which are seldom automatic and rarely real-time. To test our hypothesis, we implemented a Visual Studio Code extension (named pAPRika), which leverages unit tests as specifications and generates code variations to repair bugs in JavaScript. We conducted a preliminary empirical study with 16 participants in a crossover design. Our results provide evidence that, although incorporating APR in the IDE improves the speed of repairing faulty programs, some developers are too eager to accept patches, disregarding maintenance concerns.

The continuous spreading of the Internet-of-Things across application domains, aided by the continuous growth on the number of devices and systems that are Internet-connected, created both a rise in the complexity of these systems and made noticeable a lack of human resources with the expertise to design, develop and maintain them. Recent works try to mitigate these issues by creating solutions that abstract the complexity of the systems, such as using visual programming languages. Node-RED, as one of the most common solutions for the visual development IoT systems, stills has several limitations, such as the lack of observability and inadequate debugging mechanisms. In this work, we address some of these limitations by enhancing Node-RED with new features that improve the user's system development, debugging, and understanding tasks. We proceed to empirically evaluate the impact of these enhancements, concluding that, overall, such enhancements reduce the development time and the number of failed attempts to deploy the system.

In this work, we propose a method for extending Node-RED to allow the automatic decomposition and partitioning of the system towards higher decentralization. We provide a custom firmware for constrained devices to expose their resources, as well as new nodes and modifications in the Node-RED engine that allow automatic orchestration of tasks. The firmware is responsible for low-level management of health and capabilities, as well as executing MicroPython scripts on demand. Node-RED then takes advantage of this firmware by (1) providing a device registry allowing devices to announce themselves, (2) generating MicroPython code from dynamic analysis of flow and nodes, and (3) automatically (re-)assigning nodes to devices based on pre-specified properties and priorities. A mechanism to automatically detect abnormal run-time conditions and provide dynamic self-adaptation was also explored. Our solution was tested using synthetic home automation scenarios, where several experiments were conducted with both virtual and physical devices. We then exhaustively measured each scenario to allow further understanding of our proposal and how it impacts the system’s resiliency, efficiency, and elasticity.

Any software system that has a considerable growing number of features will suffer from essential complexity, which makes the understanding of the software artifacts increasingly costly and time-consuming. A common approach for reducing the software understanding complexity is to use software visualizations techniques. There are already several approaches for visualizing software, as well as for extracting the information needed for those visualizations. This paper presents a novel approach to tackle the software complexity, delving into the common approaches for extracting information about software artifacts and common software visualization metaphors, allowing users to dive into the software system in a live way using virtual reality (VR). Experiments were carried out in order to validate the correct extraction of metadata from the software artifact and the corresponding VR visualization. With this work, we intend to present a starting point towards a Live Software Development approach.

Cloud computing has emerged as the de facto approach for providing services over the Internet. Although having increased popularity, challenges arise in the management of such environments, especially when the cloud service providers are constantly evolving their services and technology stack in order to maintain position in a demanding market. This usually leads to a combination of different services, each one managed individually, not providing a big picture of the architecture. In essence, the end state will be too many resources under management in an overwhelming heterogeneous environment. An infrastructure that has considerable growth will not be able to avoid its increasing complexity. Thus, this papers introduces liveness as an attempt to increase the feedback-loop to the developer in the management of cloud architectures. This aims to ease the process of developing and integrating cloud-based systems, by giving the possibility to understand the system and manage it in an interactive and immersive experience, thus perceiving how the infrastructure reacts to change. This approach allows the real-time visualization of a cloud infrastructure composed of a set of Amazon Web Services resources, using visual city metaphors.

The IoT area has grown significantly in the last few years and is expected to reach a gigantic amount of 50 billion devices by 2020. The appearance of serverless architectures, specifically highlighting FaaS, raises the question of the suitability of using them in IoT environments. Combining IoT with a serverless architectural design can effective when trying to make use of local processing power that exists in a local network of IoT devices and creating a fog layer that leverages computational capabilities that are closer to the end-user. In this approach, which is placed between the device and the serverless function, when a device requests for the execution of a serverless function will decide based on previous metrics of execution if the serverless function should be executed locally, in the fog layer of a local network of IoT devices, or if it should be executed remotely, in one of the available cloud servers. Therefore, this approach allows dynamically allocating functions to the most suitable layer.

Falling is a very serious problem for our society, as it affects one out of three older adults. Currently, this is a well-known problem and therefore multiple ICT-based solutions for falls management exist. In addition, a small part of them are said to help preventing falls, but most of the reviewed solutions doesn't seem to have their focus in reducing specific fall risk factors like loss of muscle mass or a poor balance. The proposed ICT-based fall prevention solution is based on an existing fall prevention exercise programme specifically designed for the Portuguese population. It takes advantage of the smartphone processing capabilities as well as its built-in inertial sensors to evaluate the movements performed during the execution of specific exercises. Using only a simple smartphone it is possible to provide a friendly and inexpensive solution capable of increasing seniors' adherence to fall prevention exercises as well as raise their motivation to properly execute the exercises in their home environment.

An Adaptive Object Model (AOM) is a common architectural style for systems in which classes, attributes, relationships and behaviors of applications are represented as metadata, allowing them to be changed at runtime not only by programmers, but also by end users. Frequently, behavior is added to AOM systems by increasingly adding expressiveness to the model. However, this approach can result in a full blown programming language, which is not desirable. This pattern describes a solution for adding behavior to AOM systems by using metadata to identify points in the application where behavior can be dynamically added. This solution may limit the expressive power of the model, but can also simplify it, since points of extension are well defined in the system.

Meta-architectures, also known as reflective architectures, are a specific type of software architectures that are able to inspect their own structure and behavior, and dynamically adapt at runtime, thus responding to new user requirements or changes in their environment. In object-oriented programming, these architectures rely on a small set of core concepts that provide them the means to describe themselves, thus becoming "closed". These three core patterns can be found in almost every object-oriented meta-architecture: Everything is a Thing, Closing the Roof, and Bootstrapping. By delving into the inherent problems they try to solve, and the forces that shape those problems, a developer will improve his ability to adequately make architectural and design choices to build and evolve systems with high-adaptability needs.

Adaptive object models, though a well-known architectural pattern, is seldomly used in software projects where, due to their nature, would highly benefit from it. Characteristics such as complexity, reduced literature and case-studies, lack of reusable framework components, and fundamental issues as those regarding runtime evolution, drive developers away. By overcoming these barriers with a set of patterns, tools and applications, and addressing pending research problems, adaptive object models can dramatically alter the way developers design their software. This paper presents a survey in the field, describes the preliminary contributions and outlines the ongoing doctoral work.