Abstract
Internet-of-Things (IoT) systems have spread among different application domains, from home automation to industrial manufacturing processes. The rushed development by competing vendors to meet the market demand of IoT solutions, the lack of interoperability standards, and the overall lack of a defined set of best practices have resulted in a highly complex, heterogeneous, and frangible ecosystem. Several works have been pushing towards visual programming solutions to abstract the underlying complexity and help humans reason about it. As these solutions begin to meet widespread adoption, their building blocks usually do not consider reliability issues. Node-RED, being one of the most popular tools, also lacks such mechanisms, either built-in or via extensions. In this work we present SHEN (Self-Healing Extensions for Node-RED) which provides 17 nodes that collectively enable the implementation of self-healing strategies within this visual framework. We proceed to demonstrate the feasibility and effectiveness of the approach using real devices and fault injection techniques.

Abstract
The current complexity of IoT systems and devices is a barrier to reach a healthy ecosystem, mainly due to technological fragmentation and inherent heterogeneity. Meanwhile, the field has scarcely adopted any engineering practices currently employed in other types of large-scale systems. Although many researchers and practitioners are aware of the current state of affairs and strive to address these problems, compromises have been hard to reach, making them settle for sub-optimal solutions. This paper surveys the current state of the art in designing and constructing IoT systems from the software engineering perspective, without overlooking hardware concerns, revealing current trends and research directions.

Abstract
The widespread use of Internet-of-Things (IoT) across different application domains leads to an increased concern regarding their dependability, especially as the number of potentially mission-critical systems becomes considerable. Fault-tolerance has been used to reduce the impact of faults in systems, and their adoption in IoT is becoming a necessity. This work focuses on how to exercise fault-tolerance mechanisms by deliberately provoking its malfunction. We start by describing a proof-of-concept fault-injection add-on to a commonly used publish/subscribe broker. We then present several experiments mimicking real-world IoT scenarios, focusing on injecting faults in systems with (and without) active self-healing mechanisms and comparing their behavior to the baseline without faults. We observe evidence that fault-injection can be used to (a) exercise in-place fault-tolerance apparatus, and (b) detect when these mechanisms are not performing nominally, providing insights into enhancing in-place fault-tolerance techniques.

Abstract
The quantity and complexity that end-users are increasingly demanding from their applications and devices makes it impractical for a software developer to "foresee" every possible combination and explore every valid alternative. One solution is to empower end-users with tools that allows them to explore their necessities in a collaborative framework, where novices and experts can co-exist and share. We believe that such a tool could not only reduce the number of "small", specific-tailored applications, but also foster discovery and experimentation.

Abstract
Nowadays, the usage of graphical user interfaces (GUIs) in order to ease the interaction with software applications is preferred over command line interfaces. Despite recent advances in software testing, GUIs are still tested in a complete ad-hoc, manual fashion, with little support from (industrial) testing tools. Automating the process of testing GUIs has additional challenges when compared to command-line applications. This paper presents an approach for GUI (semi-automated) testing which uses knowledge of the common behaviour of a GUI. To do so, the most common aspects in a GUI are identified and then a suite of test cases is automatically generated and executed. To validate our approach, we have run it against well known web-based applications, such as GMail. © 2010 IEEE.

Abstract
Programing paradigms define how to think and design while creating software. Object-Oriented and Functional paradigms are two of the most adopted for synthesizing it. Modern languages, attempting to provide higher abstractions, are increasingly supporting native multi-paradigm programming styles. The Object-functional approach still uses classes for information and high-level structure, but allows algorithms to be implemented functionally. New challenges now exist and there is a general lack of knowledge on best practices for adopting this paradigm. This research proposes the systematic usage of software patterns to capture these new recurring problems and their solutions, though not discarding the identification of new algorithms and designs. We will use Scala as a base language, and will attempt to validate our hypothesis through multiple methodologies, including quasi-experiments and case studies. We expect to provide a basis for improvement for programming languages (through pattern absorption) and for software engineering professionals.