Search

This issue contains extended versions of selected papers from the 9th International Symposium on Formal Aspects of Component Software (FACS'12).

This paper presents a practical solution for identifying tenant data interference defects when migrating single-tenant legacy code to multi-tenant components or multi-tenant microservices. The paper explains the concepts of multi-tenant components and microservices, elaborates a formal definition of the multi-tenancy data interference problem based on information flow control theory, and presents a practical method to identify potential defects by analysing the code statically. The method has been implemented as a prototype developer support tool for PHP code. The implemented support tool prototype demonstrates the method's effectiveness for supporting the transformation of single-tenant legacy source code into multi-tenant components or microservices. It could also be used to confirm that multi-tenant components or microservices are free of data interference defects. The prototype implementation has been validated in a case study with code from the open-source enterprise application SugarCRM. Results indicate that the developed approach significantly increases the efficiency of multi-tenancy transformation in larger code bases by pointing out potential defects.

Action planning deals with the problem of finding a sequence of actions transferring the world from a given state to a desired (goal) state. This problem is important in various areas such as robotics, manufacturing, transportation, autonomic computing, computer games, etc. Action planning is a form of a reachability problem in a huge state space so it is critical to efficiently represent world states and actions (transitions between states). In this paper we present a modeling framework for planning problems based on tabled logic programming that exploits a planner module in the Picat language. In particular, we suggest techniques for structured representation of states and for including control knowledge in the description of actions. We demonstrate these techniques using the complex planning domain Cave Diving from the International Planning Competition. Experimentally, we show properties of the model for different search approaches and we compare the performance of the proposed approach with state-of-the-art automated planners. The focus of this paper is on providing guidelines for manual modeling of planning domains rather than on automated reformulation of models.

In spite of the progress that has been made over the last ten years in the research fields of software evolution and quality assessment, developers still do not take full advantage of the benefits of new assessment techniques that have been proposed by researchers. Beyond social factors, we believe that there are at least two main elements that contribute to this lack of adoption: (i) the insufficient integration of existing techniques in mainstream IDEs and (ii) the lack of support for a continuous (daily) usage of QA tools. In this context this paper introduces inCode, an Eclipse plugin aimed at transforming quality assessment and code inspections from a standalone activity, into a continuous process, fully integrated in the development life-cycle. But inCode not only assesses continuously the quality of Java systems; it also assists developers in taking restructuring decisions, and even supports them in triggering non-standard, complex refactorings. This paper introduces inCode's differentiating features, it presents the design goals that shaped our construction decisions, and describes a controlled experiment designed to validate the usability of the tool. The experiment has indicated that developers using inCode are more efficient in refactoring design fragments affected by design flaws.

Software architectures are subject to several types of change during the software lifecycle (e.g. adding requirements, correcting bugs, enhancing performance). The variety of these changes makes architecture evolution management complex because all architecture descriptions must remain consistent after change. To do so, whatever part of the architectural description they affect, the effects of change have to be propagated to the other parts. The goal of this paper is to provide support for evolving component-based architectures at multiple abstraction levels. Architecture descriptions follow an architectural model named Dedal, the three description levels of which correspond to the three main development steps - specification, implementation and deployment. This paper formalizes an evolution management model that generates evolution plans according to a given architecture change request, thus preserving consistency of architecture descriptions and coherence between them. The approach is implemented as an Eclipse-based tool and validated with three evolution scenarios of a Home Automation Software example. The paper presents a formal approach for managing component-based architecture evolution at multiple abstraction levels.The approach covers the full component-based software development process thanks to the Dedal architectural model.It enables software verification and validation through the generation of B formal specifications from diagrammatic models.It generates reliable evolution plans that prevent architecture inconsistencies.The approach is implemented and experimented on three different evolution scenarios.

Throughout the lifecycle of software products, changes arise. The repercussions of these changes increase in more advanced stages of the development process. The aspect-oriented proposal is a software development paradigm that provides principles to manage changes. However, the current proposals for the development of the early stages of software do not provide an effective means for functional changes and updates. This paper presents a knowledge modeling methodology in the aspect-oriented context focused on the early stages of the software development. This methodology aims to ease the software evolution through a standardized knowledge representation, a multidimensional organization, and an appropriate advanced separation of concerns. The proposal of a conceptual modeling of early-aspect provides the means for an organization of multidimensional knowledge. The use of ontological techniques under the principles of knowledge-engineering allows specification of early knowledge. This paper presents a case study developed using the methodology and is used as a base to evaluate the methodology, comparing the efficiency in the changes against classic approaches. The results show that it is possible to ease the changes with the proposal presented in this paper. A modeling that eases changes in the early stages of the software product lifecycle, improves the quality of the process.The aspect-oriented proposal is a software development paradigm that provides principles to manage changes.The knowledge-engineering proposal allows the knowledge specification in the first stages of the software development.Our methodology allows an organized modeling of the early-knowledge in order to ease its changes most efficiently.

The design of complex systems involves several design models supporting different analysis techniques for validation and verification purposes. These activities lead to the definition of heterogeneous modelling languages and analysis techniques. In this setting, meeting certification standards becomes a key issue in system engineering. Reducing heterogeneity due to the presence of different modelling languages can be addressed by providing an integrated framework in which modelling languages and techniques are formalised. In such a framework, checking the global correctness of heterogeneous models of a complex critical system becomes possible in many cases. The work presented in this paper addresses the problem of integrated verification of system design models in the context of transportation systems, in particular railway systems. It has been achieved in context of the B-PERFect project of RATP (Parisian Public Transport Operator and Maintainer) aiming at applying formal verification using the PERF approach on the integrated safety-critical models of embedded software related to railway domain expressed in a single unifying modelling language: HLL. This paper addresses the particular case of the B method. It presents a certified translation of B formal models to HLL models. The proposed approach uses Isabelle/HOL as a unified logical framework to describe the formal semantics and to formalise the transformation relation between both modelling languages. The developed Isabelle/HOL models are proved in order to guarantee the correctness of our translation process. Moreover, we have also used weak-bisimulation relation to check the correctness of each translation step. We also show that, when models are translated into this unified modelling language, it becomes possible to handle the verification of properties expressed across different models. The overall approach is illustrated through a case study issued from a railway software system: on-board localisation function. Furthermore, it discusses the integrated verification at system level.

International audience; Many frameworks exist for programmers to develop and deploy Big Data applications such as Hadoop Map/Reduce and Apache Spark. However, very little debugging support is currently provided in those frameworks. When an error occurs, developers are lost in trying to understand what has happened from the information provided in log files. Recently, new solutions allow developers to record & replay the application execution, but replaying is not always affordable when hours of computation need to be re-executed. In this paper, we present an online approach that allows developers to debug Big Data applications in isolation by moving the debugging session to an external process when a halting point is reached. We introduce IDRA MR , our prototype implementation in Pharo. IDRA MR centralizes the debugging of parallel applications by introducing novel debugging concepts, such as composite debugging events, and the ability to dynamically update both the code of the debugged application and the same configuration of the running framework. We validate our approach by debugging both application and configuration failures for two driving scenarios. The scenarios are implemented and executed using Port, our Map/Reduce framework for Pharo, also introduced in this paper.

Modern software systems are distributed, concurrent, mobile, and often involve the composition of heterogeneous components and of stand-alone services. Theoretical models, languages and tools for coordinating, composing and adapting services are hence required. They can indeed simplify the development of complex distributed service-based systems, enable functional correctness proofs and improve reusability and maintainability of such systems. This Special Issue (SI) is dedicated to Foundations of Coordination Languages and Self-adaptive Systems. This SI is a follow-up of the FOCLASA workshop that we organized at the 15th International Conference on Software Engineering and Formal Methods (SEFM 2017), held in Trento, Italy on September 4-8, 2017. The workshop received 16 full paper submissions. After a careful reviewing process, the international Program Committee decided to select seven papers for presentation during the workshop and inclusion in the FOCLASA'17 proceedings. From these papers, the six best papers were selected and invited for an extended version to this special issue. All the submissions went through a rigorous peer review process; four papers were finally accepted and are included in this special issue. These papers provide key insights on different aspects of coordination languages and self-adaptive systems.

General theories of software engineering must balance between providing full understanding of a single case and providing partial understanding of many cases. In this paper we argue that for theories to be useful in practice, they should give sufficient understanding of a sufficiently large class of cases, without having to be universal or complete. We provide six strategies for developing such theories of the middle range. In lab-to-lab strategies, theories of laboratory phenomena are developed and generalized to other laboratory phenomena. This is a characteristic strategy for basic science. In lab-to-field strategies, theories are developed of artifacts that first operate under idealized laboratory conditions, which are then scaled up until they can operate under uncontrolled field conditions. This is the characteristic strategy for the engineering sciences. In case-based strategies, we generalize about components of real-world cases, that are supposed to exhibit less variation than the cases as a whole. In sample-based strategies, we generalize about the aggregate behavior of samples of cases, which can exhibit patterns not visible at the case level. We discuss three examples of sample-based strategies. Throughout the paper, we use examples of theories and generalization strategies from software engineering to illustrate our analysis. The paper concludes with a discussion of related work and implications for empirical software engineering research.

This paper introduces the Special Issue on Component-Based Software Engineering and Software Architecture, which contains extended versions of a selection of the best papers presented at the CompArch 2012 conference, held in June 2012, in Bertinoro, Italy.

Software drives today's world. Daily needs like electricity supply, transportation , groceries, are all empowered by software, and not to mention communication and emails. This dependency will only increase, given innovations like the Internet-of-things, 3D printing, self-driving cars and drones. Therefore, software correctness is more important than ever: nobody wants drones to drop on our heads, autonomous cars to crash, or intrudes to enter our house via Internet-of-things devices. Hence, rigorous verification and testing is of paramount importance , as a technique to assess and improve the quality of software systems. This is exactly the topic of the Software Verification and Testing (SVT) track of the ACM Symposium on Applied Computing. This special issue of the Journal on Science of Computer Programming arose from the SVT track at the 30 th ACM Symposium on Applied Computing, held in Salamanca, Spain on April 13-17, 2015. The track received 60 full paper submissions. After a careful reviewing process, the international Program Committee decided to select 14 papers for presentation during the symposium and inclusion in the SAC'15 proceedings. From these 14 papers, the six best papers were selected and invited for an extended version to this special issue. These extended papers went again through a rigorous peer review process; five papers were finally accepted and are included in this special issue. The papers included here provide key insights on different formal verification and testing approaches.

Refactoring is a well-established practice that aims at improving the internal structure of a software system without changing its external behavior. Existing literature provides evidence of how and why developers perform refactoring in practice. In this paper, we continue on this line of research by performing a large-scale empirical analysis of refactoring practices in 200 open source systems. Specifically, we analyze the change history of these systems at commit level to investigate: (i) whether developers perform refactoring operations and, if so, which are more diffused and (ii) when refactoring operations are applied, and (iii) which are the main developer-oriented factors leading to refactoring. Based on our results, future research can focus on enabling automatic support for less frequent refactorings and on recommending refactorings based on the developer's workload, project's maturity and developer's commitment to the project.

Object-oriented programming is widely used in both the industry and the education areas. The most-common model of object-oriented programming is the class-based one. However, popular languages not implementing this model are gaining traction as time goes by. This alternative model is the prototype-based one, with one key characteristic: there are no classes. In this paper, a visual tool is proposed as a vehicle for learning the prototype-based object-oriented programming, present, for instance, in Self, Lua, or JavaScript. This software has been in use for three years in a subject of the Computer Science Engineering degree, at the University of Vigo.

Data-intensive Web applications are usually developed by means of specific Web application frameworks, which provide, among other features, the proper tools to automate redundant tasks, e.g. the implementation of CRUD operations. However, although Model-Driven Web Engineering (MDWE) approaches have defined specific languages and tools to significantly reduce development efforts, the provision of such automation tools has been traditionally neglected. This paper presents AutoCRUD, a WebRatio plug-in automating the generation of CRUD operations in OMG Interacting Flow Modelling Language (IFML). It has been developed as a joint effort by academia and industry to assess its validity in a real scenario.

Cloud applications typically integrate multiple components, each needing a virtualised runtime environment that provides the required software support (e.g., operating system, libraries). This paper shows how TOSCA and Docker can effectively support the orchestration of multi-component applications, even when their runtime specification is incomplete. More precisely, we first introduce a TOSCA-based representation of multi-component applications, and we illustrate how such representation can be exploited to specify only the application-specific components. We then present TosKeriser , a tool for automatically completing TOSCA application specifications, which can automatically discover the Docker-based runtime environments that provide the software support needed by the application components. We also show how we fruitfully exploited TosKeriser in two concrete case studies. Finally, we discuss how the specifications completed by TosKeriser can be automatically orchestrated by already existing TOSCA engines.

In the last years we are observing a growing interest in verification of business process models that, despite their lack of formal characterization, are widely adopted in industry and academia. To this aim, a formalization of the execution semantics of business process modeling languages is essential. In this paper, we focus on the OMG standard BPMN 2.0. Specifically, we provide a direct formalization of its semantics in terms of Labeled Transition Systems. This approach permits to avoid possible miss-interpretations, due to the usage of the natural language in the standard specification, and to overcome issues due to the mapping of BPMN to other formal languages, which are equipped with their own semantics. Our operational semantics is given for a relevant subset of BPMN elements focusing on the capability to model collaborations among organizations via message exchange. One of its distinctive aspects is the suitability to model business processes with arbitrary topology. This allows designers to freely specify their processes according to the reality, without the limitation of defining well-structured models. The provided formalization is also implemented by exploiting the capabilities of Maude. This implementation takes a collaboration model as an input and, explores all the model executions. By relying on it, automatic verification of properties related to collaborations has been carried out via the Maude model checker. We illustrate the benefits of our approach by means of a simple, yet realistic, running example concerning a travel booking scenario.

VirtuosoNextTM is a distributed real-time operating system (RTOS) featuring a generic programming model dubbed Interacting Entities. This paper focuses on these interactions, implemented as so-called Hubs. Hubs act as synchronisation and communication mechanisms between the application tasks and implement the services provided by the kernel. While the kernel provides the most basic services, each carefully designed, tested and optimised, tasks are limited to this handful of basic hubs, leaving the development of more complex mechanisms up to application specific implementations. This work presents a toolset that supports the building of new services compositionally, using notions borrowed from the Reo coordination language, on which the developer can delegate coordination-related duties. This toolset uses a formal compositional semantics for hubs that captures dataflow and time, formalising the behaviour of existing hubs, and allowing the definition of new ones. Furthermore, it enables the analysis and verification of hubs under our automata interpretation, including time-sensitive behaviour via the Uppaal model checker, usable on http://arcatools.org/hubs . We illustrate the proposed tools and methods by verifying key properties on different interaction scenarios between tasks and a composed hub.

Self-Admitted Technical Debt (SATD) is a metaphorical concept to describe the self-documented addition of technical debt to a software project in the form of source code comments. SATD can linger in projects and degrade source-code quality, but it can also be more visible than unintentionally added or undocumented technical debt. Understanding the implications of adding SATD to a software project is important because developers can benefit from a better understanding of the quality trade-offs they are making. However, empirical studies, analyzing the survivability and removal of SATD comments, are challenged by potential code changes or SATD comment updates that may interfere with properly tracking their appearance, existence, and removal. In this paper, we propose SATDBailiff, a tool that uses an existing state-of-the-art SATD detection tool, to identify SATD in method comments, then properly track their lifespan. SATDBailiff is given as input links to open source projects, and its output is a list of all identified SATDs, and for each detected SATD, SATDBailiff reports all its associated changes, including any updates to its text, all the way to reporting its removal. The goal of SATDBailiff is to aid researchers and practitioners in better tracking SATDs instances, and providing them with a reliable tool that can be easily extended. SATDBailiff was validated using a dataset of previously detected and manually validated SATD instances. SATDBailiff is publicly available as an open source, along with the manual analysis of SATD instances associated with its validation, on the project website. 1

With the advent of HTML 5, we can now develop rich web apps in Javascript that rival classical standalone apps. Nevertheless, developing in Javascript is still challenging and error prone because of the language's ambiguous semantics and quirks. In this paper, we advocate that the popular solution of using another language with better semantics and constructs is not enough. Developers should be provided with an IDE that eases the integration of Javascript libraries and enables testing an application across the many available Javascript interpreters. We introduce PharoJS,1 an infrastructure that allows Test-Driven Development (TDD) in Pharo Smalltalk of applications that ultimately run on a Javascript interpreter. PharoJS makes it possible to run interactive tests within the Pharo IDE, so as to fully exploit the debugging and development environment, while UI and libraries reside on the Javascript side. © 2018 Elsevier B.V.

Since their invention, Petri nets have provided modelling and analysis methods to support the design of correct, reliable and robust systems. This motivated our work to develop PetriDotNet , a Petri net editor and analysis tool. In this paper we overview the supported modelling formalisms and the analysis methods included in PetriDotNet . Next, we present eight different industrial case studies, demonstrating the wide variety of scenarios where Petri nets and PetriDotNet can help the design, development and analysis of industrial systems. Our original goal with PetriDotNet was to provide an educational tool to our students, however our efforts led to a framework being able to serve both academic and industrial needs.

PAMOJA is a Java-based component framework for Grammar-Aware Engineering (GAE) in an Integrated Development Environment (IDE). The PAMOJA system is being developed to explore the possibility of Component-Based Software Development (CBSD) in the grammarware field. Our main goal is to develop a coherent set of small GAE components, where each component is dedicated to a single well-defined task. The components should fit into a general-purpose framework like NetBeans or Eclipse and it should be possible to manipulate them inside the IDE just like any other component. This paper describes the PAMOJA architecture supporting this development style. We illustrate its use with the aid of examples, and present a case of composing new components at a higher level from the existing GAE components. For this case, we use a hybrid text/structure editor application as an example. This case study serves as a proof of concept of our approach.

Analysing security in the architecture design of modern software systems is a challenging task. Emerging technologies utilised in building software systems may pose security threats, so software engineers need to consider both the structure and behaviour of architectural styles that employ these supporting technologies. This paper presents an automated approach to security analysis that helps to identify security characteristics at the architectural level. Key techniques used by our approach include the use of metrics, vulnerability identification and attack scenarios. Our modelling is expressive in defining architectural styles and security characteristics. Our analysis approach gives insightful results that allow software engineers to trace through the design to find parts of the system that may be impacted by attacks. We have developed an analysis tool that allows user to seamlessly model the software architecture design and analyse security. The evaluation has been conducted to assess the accuracy and performance of our approach. The results show that our analysis approach performs reasonably well to analyse the security in the architectural design.

Nowadays mobile applications that require the interaction and collaboration of two or more users simultaneously are becoming more and more frequent, that is why to ensure high quality of these products, testers are adopting test automation techniques that can optimize their quality assurance process. In previous work we presented Kraken , a publicly available cross-device testing tool that enables a tester to write, run, and validate test scenarios that involve the interaction of two or more devices using APKs as input along with test scripts wrote using the Gherkin syntax. In this paper, we will extend on Kraken previous and new functionalities such as random GUI events, fake string generation and state XML snapshots of a displayed view.

Context Context-aware service-based applications development has been considered among the most studied research fields in the last decade. The objective was to accompany the rapid technology evolution of mobile computing devices by providing customized services able to interact with different contextual situations of a pervasive environment. For this purpose, many research works have advocated Model-Driven Development (MDD) for building context-aware service-based applications. However, the proposed approaches have presented specific methodologies without using development standards, which may be followed by developers. In addition, most of them have ignored the dynamic adaptation aspect at runtime that should characterize such kind of applications and no adaptation strategy was considered in their proposals. Objective The current paper aims to propose a generic model-driven approach for context-aware service-based applications engineering with a software development methodology including a reconfiguration loop to achieve the dynamic adaptation of these applications. Method This approach focuses on the combination of MDD and Aspect Oriented Modelling (AOM) to take advantage of their benefits. AOM encapsulates different context-awareness logics separately in aspect models called ContextAspect that can be easily woven into the service's business logic according to the changing context over time. The proposed development methodology includes four phases (modelling, composition, transformation and adaptation) which act in conformance with the MDA technology. Results The main results gained by using the present approach are the possibility to combine the MDA technology with the aspect-oriented paradigm in a generic development methodology for context-aware service-based applications, and the handling of their dynamic adaptation at execution time according to the changes in the context. Conclusion The development of context-aware applications is a complex, cumbersome, and time-consuming task. However, the experience reached by implementing the proposed methodology leads us to believe that the involvement of MDD and AOM is significantly beneficial to overcome some recognised shortcomings of several existing approaches and to make this task simpler, easier and faster.

Much of Software Engineering research needs to provide an implementation as proof-of-concept. Often such implementations are created as exploratory prototypes without polished user interfaces, making it difficult to (1) run user studies to validate the tool's contribution, (2) validate the author's claim by fellow scientists, and (3) demonstrate the utility and value of the research contribution to any interested parties. However, turning an exploratory prototype into a "proper" tool for end-users often entails great effort. Heavyweight mainstream frameworks such as Eclipse do not address this issue; their steep learning curves constitute substantial entry barriers to such ecosystems.In this paper, we present the Model Analyzer/Checker (MACH), a stand-alone tool with a command-line interpreter. MACH integrates a set of research prototypes for analyzing UML models. By choosing a simple command line interpreter rather than (costly) graphical user interface, we achieved the core goal of quickly deploying research results to a broader audience while keeping the required effort to an absolute minimum. We analyze MACH as a case study of how requirements and constraints in an academic environment influence design decisions in software tool development. We argue that our approach while perhaps unconventional, serves its purpose with a remarkable cost-benefit ratio.

Context: Software measurement is a fundamental practice to support process improvement and project management, since it provides useful data for decision making at both organizational and project levels. Due to the nature of software measurement activities, the use of computational supporting tools is essential. Software measurement can be performed in the context of various software processes and these processes generally have different supporting tools. Thus, it is common to use several tools to allow collecting data regarding the processes. Tools are usually developed at different time, by different teams and without concern for integration. As a result, organizations have to deal with integration issues to enable communication between tools and to properly support the measurement process. A key factor for integration is that tools share a common understanding regarding the meaning of the exchanged terms and services. In other words, it is important to deal with integration not only at the syntactic level, but also at the semantic level. Among the instruments used to address semantics, ontologies have been acknowledged as an important means to address semantic integration. Objective: This paper presents the Ontology-Based Approach for Measurement Systems Integration (OBA-MSI), an approach that uses ontologies as a basis to integrate tools aiming at supporting the software measurement process. Method: OBA-MSI was developed following the Design Science Research paradigm. To evaluate OBA-MSI, we carried out a case study in which we used the approach to integrate tools for a real software development organization. After that, we applied a survey to get feedback from users of the integrated solution. Results: The users stated that the integrated solution obtained from applying OBA-MSI properly supported the software measurement process and added value to the organization, providing more benefits than using the tools in isolation. Conclusions: The use of OBA-MSI to aid tools integration helps deal with semantic conflicts and contributes to obtain a proper support to the software measurement process.

Today, PHP is one of the most popular programming languages, and is commonly used in the open source community and in industry to build large application frameworks and web applications. In this paper, we discuss our ongoing work on PHP AiR, a framework for PHP Analysis in Rascal. PHP AiR is focused especially on program analysis and empirical software engineering, and is being used actively and effectively in work on evaluating PHP feature usage and system evolution, on program analysis for refactoring and security validation, and on source code metrics. We describe the requirements and design decisions for PHP AiR, summarize current research using PHP AiR, discuss lessons learned, and briefly sketch future work. We describe a framework in Rascal for PHP software engineering research, PHP AiR.We report results of using PHP AiR for empirical studies and program analysis.We examine the design decisions and tradeoffs encountered building PHP AiR.

MAZE is an extension of the Object-Z specification language supporting the specification and development of multi-agent systems (MAS). Following recommendations from the agent-oriented software engineering community, it supports three distinct levels of abstraction: (i) the macro level which focusses on the system's overall, global behaviour, independently of how the agents of the system operate and interact, (ii) the meso level which focusses on agent interactions, and (iii) the micro level which focusses on the operation of individual agents. Object-Z's high-level support for component-based specification, which is well suited to modelling MAS, is complemented in MAZE with support for action refinement to facilitate the top-down development process from the macro to micro level, and with a number of syntactic conventions aimed at abstractly specifying the low-level mechanisms required for dealing with asynchronous communication and timing constraints at the micro level. The latter are shorthands for existing Object-Z notation and so require no redefinition of Object-Z's semantics. In this paper, we provide an overview of MAZE and illustrate its use on a non-trivial case study: a swarm robotic algorithm for self-assembly.

An in-depth analysis of the problems detected in several technological ecosystems.An architectural pattern to improve the development of eLearning ecosystems.A formalization of the architectural pattern using BPMN and SoaML.We demonstrate the effectiveness of our proposed pattern on a real context. Knowledge management within companies and institutions is one of the main problems when defining and developing new solutions to improve information systems. Currently, information systems have evolved into technological ecosystems that are a set of different components related to each other through information flows in a physical environment that supports these flows, where users are part of the ecosystem. Particularly, during the last several years, the Open Source software has been used to develop these technological solutions. The aim of this paper is to formalize an architectural pattern to support the right description and implementation of eLearning ecosystems. The theoretical basis has been provided in previous works by using a comparative analysis of the Strengths, Weaknesses, Opportunities and Threats of several real case studies developed in different contexts. The problems detected through the previous analysis have been modelled using the Business Process Model and Notation. Next, the pattern has been formalized with the Service-oriented architecture Modelling Language. Finally, the pattern has been tested in a real context, namely, an institutional development for the Spanish Public Administration, which has demonstrated that the pattern works properly. As a result, we have obtained a set of Business Process Model and Notation diagrams that provide a high abstraction level for the main detected problems in eLearning ecosystems. We have also obtained an architectural pattern composed of several layers and a set of external elements that provides a solution to these problems.

An ever-increasing demand for information systems in the last few decades brought many new opportunities but also presented new challenges for companies in the landscape of doing business globally. In these terms, software systems need to adapt almost instantaneously to new requirements, opportunities, and customer expectations. Process-aware systems have become integral part in business information system solutions, finding their place at different locations. This paper presents a workflow engine - NewWave , created with the goal to enable an extensible workflow management system, to facilitate easy specification and implementation of application business logic with focus on simplicity and immediate feedback. Through seamless integration with Pharo applications, libraries, tools, and leveraging Pharo's live environment, the NewWave enables users to create dynamically adaptable process models to facilitate the flexible adaptation of business logic.

This paper presents CHOReVOLUTION, a platform for the tool-assisted realization and execution of distributed applications. CHOReVOLUTION specifically targets service-oriented systems specified through service choreographies. It offers an Integrated Development and Runtime Environment (IDRE) organized into three layers, namely, front-end, back-end, and cloud. It comprises a wizard-aided development environment and a system monitoring console in the front-end layer, and a back-end for managing the deployment and execution of the choreographed system on the cloud. We describe the IDRE by using an industrial use case in the domain of Smart Mobility & Tourism, and finally we provide details on its experimental evaluation.

In some cases it may be useful to represent a problem in many logical domains, since they provide different perspectives for addressing formal verification. However, the maintenance of multiple representations in separate domains can be expensive if there is neither automated assistance nor a clear formal relation between these domains. We have addressed this problem in the context of Model-Driven Engineering (MDE). We defined solid foundations of a theoretical environment for formal verification using heterogeneous verification approaches. The environment is based on the Theory of Institutions which provides a sound basis for representing MDE elements and a way for specifying translations from these elements to other domains used for verification. In this paper we present how this environment can be supported in practice within the Heterogeneous Tool Set ( Hets ). Hets supports heterogeneous specifications and provides capabilities for monitoring the overall correctness of a heterogeneous proof. We first extend the theoretical environment with the inclusion of an institution for the Object Constraint Language (OCL), and then we define semantic-preserving translations from the OCL-constrained MDE elements to a core language of Hets . With this we can verify basic properties of our specification, and then use the existent connections between logical domains within Hets for broadening the spectrum of domains in which complementary verification properties can be addressed.

Asynchronous Actor-based programming has gained increasing attention as a model of concurrency and distribution. The Abstract Behavioral Specification (ABS) language is an actor-based programming language that has been developed for both the modeling and formal analysis of distributed systems. In ABS, actors are modeled as concurrent objects that communicate by asynchronous method calls. Return values are also communicated asynchronously via return statements and so-called futures. Many modern distributed software applications require a form of continuous interaction between their components which consists of streaming data from a server to its clients. In this paper, we extend the ABS language in order to support the streaming of data. We introduce the notion of “future-based data streams” by augmenting the syntax, type system, and operational semantics of ABS. As a proof of concept, we further discuss a prototype implementation for supporting future-based data streams on top of ABS, and discuss the impact of the use of these data streams in ABS on the performance in the implementation of a distributed application for the generation of social networks.

Multi-party interactions in Web Service (WS) composition are hard to managed and difficult to design and verify, especially while end-to-end information flow security (IFS) must be respected. Usually, IFS is guaranteed for a data originator and ultimate recipient WS, however inter-organizational service compositions involve partners that do not necessarily share the same level of security, especially for data they do not generate nor process themselves. In this paper, we focus on the non-interference property and we present a correct-by-construction approach to build orchestrated WSs with multi-party interactions. A key ingredient of this approach is to present the system composition at an abstract level as a component-based model where the IFS verification and the system configuration are considered at early stage. When this configuration is validated, that is, no security leak is detected, we automatically generate orchestrator components that handle IFS. Afterwards, we generate accordingly BPEL processes where the IFS constraints are enforced as security WS-policies in the BPEL description of services. We develop a set of tools that automate the approach and we validate the effectiveness of our approach with well known Web service use cases.

Complex sensing, processing and control applications running on distributed platforms are difficult to design, develop, analyze, integrate, deploy and operate, especially if resource constraints, fault tolerance and security issues are to be addressed. While technology exists today for engineering distributed, real-time component-based applications, many problems remain unsolved by existing tools. Model-driven development techniques are powerful, but there are very few existing and complete tool chains that offer an end-to-end solution to developers, from design to deployment. There is a need for an integrated model-driven development environment that addresses all phases of application lifecycle including design, development, verification, analysis, integration, deployment, operation and maintenance, with supporting automation in every phase. Arguably, a centerpiece of such a model-driven environment is the modeling language. To that end, this paper presents a wide-spectrum architecture design language called DREMS ML that itself is an integrated collection of individual domain-specific sub-languages. We claim that the language promotes "correct-by-construction" software development and integration by supporting each individual phase of the application lifecycle. Using a case study, we demonstrate how the design of DREMS ML impacts the development of embedded systems. We describe an architecture design language for distributed platforms.We describe a software component model for complex, distributed applications.We describe how all implementation and deployment artifacts can be generated.Our language supports design, development, analysis, deployment and maintenance.

In this work we report on our experiences on developing and commercializing Goanna, a source code analyzer for detecting software bugs and security vulnerabilities in C/C++ code. Goanna is based on formal software analysis techniques such as model checking, static analysis and SMT solving. The commercial version of Goanna is currently deployed in a wide range of organizations around the world. Moreover, the underlying technology is licensed to an independent software vendor with tens of thousands of customers, making it possibly one of the largest deployments of automated formal methods technology. This paper explains some of the challenges as well as the positive results that we encountered in the technology transfer process. In particular, we provide some background on the design decisions and techniques to deal with large industrial code bases, we highlight engineering challenges and eorts that are typically outside of a more academic setting, and we address core aspects of the bigger picture for transferring formal techniques into commercial products, namely, the adoption of such technology and the value for purchasing organizations. While we provide a particular focus on Goanna and our experience with that underlying technology, we believe that many of those aspects hold true for the wider eld of formal analysis and verication technology

Refactoring is a process for improving the internal characteristics and design of software while preserving its external behaviour. Refactoring has been suggested as a positive influence on the long-term quality and maintainability of software and, as a result, we might expect benefits of a lower future change or fault propensity by refactoring software. Conversely, many studies show a correlation between change and future faults; so application of a refactoring may in itself increase future fault propensity, negating any benefit of the refactoring. In this paper, we determine whether the refactoring process reaps future maintenance benefits and, as a consequence, results in software with a lower propensity for both faults and change. We studied a large, commercial software system over a twelve-month period and identified a set of refactored classes during the middle four months of the study; a bespoke tool was used to detect occurrences of fifteen types of refactoring. We then examined the fault- and change-proneness of the same set of refactored classes in the four months prior to, during, and after the period of refactoring to determine if change or fault activity was reduced either during or after the period of refactoring studied. We also compared these trends with remaining classes in the system that had not been refactored over the same periods. Results revealed that refactored classes experienced a lower change-proneness in the period after refactoring and were significantly less fault-prone during and after the period of refactoring, even when accounting for the effects of change. The study therefore presents concrete evidence of the benefits of refactoring in these two senses. Refactored classes became less change-prone compared to classes prior to refactoring.The refactoring process thus benefits the long term maintenance of classes.Refactored classes became less fault-prone compared classes prior to refactoring.2/3 of changes made were made to production classes; 1/3 were made to test classes.The benefits of refactoring classes are not negated by an increase in future change effort.

Software engineering is complex and success depends on many inter-related factors. Theory Based Software Engineering (TBSE) is about providing a practical way for software teams to understand the relationships and the influence of these factors to thereby adapt the way they work. This paper proposes an approach to TBSE based on Essence, a software engineering kernel distilled by the SEMAT (Software Engineering Method and Theory) initiative. Essence supports TBSE by providing a domain model that is useful for organizing and relating software engineering factors. Essence also helps make recommended practices precise and actionable to software teams. We provide a step-by-step application of our approach on an industrial software process improvement case study. The case study achieved 21% productivity gains and 58% decrease in defects. But more importantly than these results, it demonstrates the value of Essence in supporting TBSE.

The contribution of this paper to a general theory of software engineering is twofold: it presents the model system concept, and it integrates the software engineering design process into a decisio ...

One of the reasons for the lack of rigor in software engineering compared to physical and behavioral sciences is that the theories that underpin our work, both as software engineers and as software engineering researchers, have not been given enough attention. To provide a step forward towards greater rigor, a framework has been created with which to explore theories of software engineering and software engineering research. This framework provides a simple theory modeling language and model calculus to explore informally described theories and to generate the results of composing modeled theories. To illustrate and evaluate this framework, a general theory about software engineering is presented and then two simple theories, D and E, are proposed as the basis for laying out a unified theoretical foundation for software engineering and software engineering research. Software Engineering consists of two logical parts: design, and empirical evaluation (both terms used in their broadest senses). Theory D is the theoretical basis for the design part, and theory E is the theoretical basis for empirical evaluation. These two theories are then composed in various ways to lay out a space (a taxonomy, or ontology if you will) for software engineering and software engineering research. Finally, it is claimed that software engineering and software engineering research (both fully integrated with empirical evaluations) are models (in the logical sense) for these atomic and composed theories. To further evaluate the framework, examples are provided of modeling (implicit) theories found in a number of software engineering (theory) papers. The results of this research are: 1) a scientific elegance in creating larger more complex theories out of simpler theories, 2) an elegant way of explaining the complexity of software engineering and software engineering research, and 3) a theory modeling language and model calculus for composing the resulting theoretical models.

AltaRica is a language used to describe safety critical systems that has become a de-facto European industrial standard for Model-Based Safety Assessment (MBSA). However, even the most mature tool for the support for MBSA of AltaRica models, i.e. Dassault's OCAS, has several limitations. The most important ones are its inability to perform many analyses exhaustively, severe scalability issues, and the lack of model checking techniques for temporal properties. In this paper we present a novel approach for the analysis of AltaRica models, based on a translation into an extended version of the model checker NuSMV. The translation relies on a novel formal characterization of the Dataflow dialect of AltaRica used in OCAS. The translation is formally defined, and its correctness is proved. Based on this formal characterization, a toolset has been developed and integrated within OCAS, thus enabling functional verification and safety assessment with the state of the art techniques of NuSMV. The whole approach is validated by an experimental evaluation on a set of industrial case studies, which demonstrates the advantages of the proposed technique over the currently available tools.

Due to the heterogeneity of different platforms, it is an expensive endeavor to provide a mobile application (app) for several of them. Cross-platform development approaches can solve this problem. Existing cross-platform approaches have severe limitations and typically work on a low-level of abstraction. Our model-driven cross-platform approach MD2 focuses on the domain of business apps and, hence, reaches a high-level of abstraction while maintaining a platform-specific look and feel. A textual model written in an MVC-based DSL is automatically transformed into native apps for Android and iOS. The present paper focuses on new extensions of MD2, namely device-specific layout, extended control structures, and offline computing. We present the model-driven approach MD2 for cross-platform development.MD2 addresses business apps at a high level of abstraction.MD2 reaches a platform-specific look and feel without compromising performance.A textual model is automatically transformed into native apps for Android and iOS.We focus on extensions: device-specific layout and extended control structures.

In a well designed software system, units of related functionality are organized into modules and classes, which are in turn arranged into inheritance trees, package hierarchies, components, libraries, frameworks, and services. The trade-offs between simplicity versus flexibility and power are carefully considered, and interfaces are designed that expose the key functional properties of a component while hiding much of the complexity of the implementation details. However, over time the design integrity of a well-engineered system tends to decay as new features are added, as new quality attributes are emphasized, and as old architectural knowledge is lost when experienced development personnel shift to new jobs. Consequently, as developers and as users we often find ourselves looking at a piece of functionality or other design artifact and wondering, "Why is this here?" That is, we would like to examine the provenance of an artifact to understand its history and why it is where it is within the current design of the system. In this brief paper, we sketch some of the dimensions of the broad problem of extracting and reasoning about the provenance of software development artifacts. As a motivating example, we also describe some recent related work that uses hashing to quickly and accurately identify version information of embedded Java libraries. We motivate the need to model for software artifact provenance.We sketch the dimensions of the problem space, and discuss its analysis.We describe an example, using hashing to identify library version information.

Writing documentation about software internals is rarely considered a rewarding activity. It is highly time-consuming and the resulting documentation is fragile when the software is continuously evolving in a multi-developer setting. Unfortunately, traditional programming environments poorly support the writing and maintenance of documentation. Consequences are severe as the lack of documentation on software structure negatively impacts the overall quality of the software product. We show that using a controlled natural language with a reasoner and a query engine is a viable technique for verifying the consistency and accuracy of documentation and source code. Using ACE, a state-of-the-art controlled natural language, we present positive results on the comprehensibility and the general feasibility of creating and verifying documentation. As a case study, we used automatic documentation verification to identify and fix severe flaws in the architecture of a non-trivial piece of software. Moreover, a user experiment shows that our language is faster and easier to learn and understand than other formal languages for software documentation. This paper highlights a deficiency in the way documentation is usually written.Using controlled natural language is a viable approach.A prototype as well as its benefits are described.