In software ecosystems, partner management concerns establishing and maintaining meaningful relationships with partners to improve ecosystem health. At the same time, software ecosystem orchestrators have insufficient insight into partner management tools. Because of this, they fail in attracting and maintaining partnerships with software producing organizations, ultimately hindering their ability

Lifted (family-based) static analysis based on abstract interpretation is capable of analyzing all variants of a program family (or any other configurable software system), simultaneously, in a single run without generating any of the variants explicitly. The elements of the underlying lifted domain are tuples, which maintain one property per system variant. Still, explicit property enumeration in

Many empirical software engineering studies have employed feature selection algorithms to exclude the irrelevant and redundant features from the datasets with the aim to improve prediction accuracy achieved with machine learning-based estimation models as well as their generalizability. However, little has been done to investigate how consistently these feature selection algorithms produce features/metrics

We argue that there is a link between implicit computational complexity theory and reversible computation. We introduce inherently reversible programming languages which capture the complexity classes etime and . Furthermore, we discuss and analyze higher-order versions of our reversible programming languages.

We investigate collections of reversible gates closed under parallel and serial composition, with and without borrow and ancilla closure. In order to better understand the structure of these collections of reversible gates, we investigate the lattice of closed sets and the maximal members of this lattice, that is, collections that are not all gates, but the addition of a single new gate will allow

Maintaining large and complex software is a significant task in IT industry. One reason for that is the development of code smells which are design flaws that lead to future bugs and errors. Code smells can be treated with regular refactoring, and their detection is the first step in the software maintenance process. Detecting code smells with machine learning algorithms eliminate the need of extensive

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

Two new function translations and a novel bounded search transformation-based synthesis approach that finds a reversible circuit implementation for a given 3-valued reversible function are presented. Methods for simplifying the circuit post-synthesis and quantum circuit implementation constraints are also considered. Experimental results for all 2-input 3-valued functions show the effectiveness of

This paper introduces KinZ, an Azure Kinect toolkit for Python and Matlab. This toolkit encapsulates the Azure Kinect's main functionality in an easy-to-use class with high-level methods. This software is written mostly in C/C++ with a pybind interface for Python and Mex functions for Matlab. It provides access to color, depth, infrared cameras, a mapping between cameras, colored point clouds, IMU

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

The design of fault-free hybrid control systems, which combine discrete and continuous behavior, is a challenging task. Their hybrid behavior and further factors make their design and verification challenging: These systems can consist of multiple interacting services, and commonly used design languages, like MATLAB/Simulink do not directly allow for the verification of hybrid behavior. Furthermore

This paper presents Alloy4Fun, a web application that enables online editing and sharing of Alloy models and instances (including dynamic ones developed with the Electrum extension), to be used mainly in an educational context. By introducing secret paragraphs and commands in the models, Alloy4Fun allows the distribution and automated assessment of simple specification challenges, a mechanism that

This article presents PAMELA, an annotation-based Java modeling framework. PAMELA provides a smooth integration between model and code and enables Java developers to handle software development both at conceptual level and at source-code level, without code transformation and/or generation, avoiding round-trip-related issues.

Replicated databases are attractive for managing the data of distributed applications. To achieve high availability, low latency, and high throughput for such applications, consistency has to be weakened. This comes at a price: it is harder to prove application correctness. In this paper, we describe a new and powerful specification and verification technique for highly available applications together

Reflective algorithms are algorithms that can modify their own behaviour. Recently a behavioural theory of reflective algorithms has been developed, which shows that they are captured by reflective abstract state machines (rASMs). Reflective ASMs exploit extended states that include an updatable representation of the ASM signature and rules to be executed by the machine in that state. Updates to the

For Finite State Machines (FSMs) a rich testing theory has been developed to discover aspects of their behavior and ensure their correct functioning. Although this theory has been frequently used, e.g. to check conformance of protocol implementations, its applicability is limited by restrictions of FSMs, in which inputs and outputs alternate, and outputs are determined by the previous input and state

This paper presents a formal approach to program derivation using break and continue statements within a loop. We define the break and continue semantics under the framework of weakest precondition. The underpinning theory centers around a miraculous statement re-discovered to model those jump statements in a novel manner. Our focus is on introducing break and continue within a loop to derive a program

Context: Reusability estimation of a software component is beneficial in constructing a library of reusable components. The inherent characteristics of the functional paradigm in principle support reuse better than other paradigms. In this paper, we consider the reusability of functions written in the Haskell programming language, which is a functional programming language. Objective: We aim to develop

Umple is an open-source software modeling tool and compiler. It incorporates textual language constructs for UML modeling, including associations and state machines. It includes traits, aspects, and mixins for separation of concerns. It supports embedding methods written in many object-oriented languages, enabling it to generate complete multilingual systems. It provides comprehensive analysis of models

Complex cyber-physical systems can be difficult to analyze for resource adequacy (e.g., bandwidth and buffer size) at the concept development stage since relevant models are hard to create. During this period, details about the functions to be executed or the platforms in the architecture are partially unknown. This is especially true for Integrated Modular Avionics (IMA) systems, for which life-cycles

Code review is the process of inspecting code changes by a developer who is not involved in the development of the changeset. One of the initial and important steps of code review process is selecting code reviewer(s) for a given code change. To maximize the benefits of the code review process, the appropriate selection of the reviewer is essential. Code reviewer recommendation has been an active research

The ever-growing size of programs and their continuous evolution require building fast and efficient analyzers. Here we focus on the static ones, in particular on type systems, for both checking and inference. Just as programs change by incrementally changing or inserting pieces of code, called diffs, also type systems should be incremental and re-type the diffs, only. An algorithmic schema is proposed

Distributions of open source software packages dedicated to specific programming languages facilitate software development by allowing software projects to depend on the functionality provided by such reusable packages. The health of a software project can be affected by the maturity of the packages on which it depends. The version numbers of the used package releases provide an indication of their

A characterizing set (CS) for a deterministic finite state machine (FSM) M is a set of input sequences that, between them, separate (distinguish) all of the states of M. CSs are used within several test generation techniques that return test suites with guaranteed fault detection power. The number of input sequences in a CS directly affects the cost of applying the resultant test suite. In this paper

A polymorphic subtyping relation, which relates more general types to more specific ones, is at the core of many modern functional languages. As those languages start moving towards dependently typed programming a natural question is how can polymorphic subtyping be adapted to such settings. This paper presents the dependent implicitly polymorphic calculus (λI∀): a simple dependently typed calculus

Docker is one of the most popular containerization technologies. A Docker container can be saved into an image including all environmental packages required to run it, such as system and third-party packages from language-specific package repositories. Relying on its modularity, an image can be shared and included in other images to simplify the way of building and packaging new software. However,

The growing trend to use multi-core processors to get more performance is increasingly present in safety-critical systems. Synchronous dataflow programming is naturally well-suited to parallel execution, thanks to the fact that all data dependencies are always explicit. MiniSIGNAL is a multi-task code generation tool for the synchronous dataflow language SIGNAL. The existing MiniSIGNAL code generation

Automatic test input generation (ATG) is a major topic in software engineering, analysis and security. In this paper, we bridge the gap between state-of-the-art white-box ATG techniques, especially Dynamic Symbolic Execution, and the diversity of test objectives that they may be used to cover in practice, including many of those defined by common source-code coverage criteria. We define a new coverage

Social media generate a massive amount of information each day. This information is usually generated by people and may be used for many studies. Social media mining is a growing discipline inside data mining, and the results have proven to be quite revealing. Getting the data to work with might seem to be the easiest task in the process, but it can be very challenging for people without programming

We define a new verification method, called RT-MOBS, for checking real-time requirements based on Time Petri nets (TPN). Our approach supports requirements specified using a very expressive pattern language, the Property Specification Language (PSL) of Autili, Grusnke et al., and relies on marking observers' verification. RT-MOBS has many distinctive features, such as a focus on performances, a compositional

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

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

Sciit is a distributed issue tracker. Distributed issue tracking eliminates much of the friction that is otherwise necessitated by separately maintaining source code in a source control management system (SCM) and task information in an issue tracker. Sciit goes beyond the state of the art in distributed issue tracking by treating issues as first class change control items, represented as fragments

Logging is an important feature of a software system to record run-time information. Detailed logging allows developers to collect run-time information in situations where they cannot use an interactive debugger, such as continuous integration and web application server cases. However, extensive logging leads to larger execution traces because few instructions can be repeated many times. This paper

Avionics is one of the fields in which verification methods have been pioneered and brought about a new level of reliability to systems used in safety-critical environments. Tragedies, like the 2015 insider attack on a German airplane, in which all 150 people on board died, show that safety and security crucially depend not only on the well-functioning of systems but also on the way humans interact

Programmable logic controllers (PLCs) are essentially domain-specific computers that are widely used in the industrial field. These industrial devices are usually required to be of high reliability, and program bugs can lead to catastrophes. However, there are few automated testing tools for PLC programs. This paper proposes a framework, named STAutoTester, for automatically generating test cases for

The synchronous language SIGNAL is a formal specification formalism for developing safety-critical real-time systems. It is a multi-clocked data-flow modeling language suitable for specifying deterministic concurrent behaviors. Its model of computation and communication very well matches recent trends to utilize multi-core processors for executing real-time systems, by taking advantage of its concurrent

We propose to leverage epistemic uncertainty about constraint satisfaction of a reinforcement learner in safety critical domains. We introduce a framework for specification of requirements for reinforcement learners in constrained settings, including confidence about results. We show that an agent's confidence in constraint satisfaction provides a useful signal for balancing optimization and safety

Human activity recognition plays an important role especially in medical applications. This paper proposes a formal approach to model such activities, taking into account possible variations in human behavior. Starting from an activity description enriched with event occurrence probabilities, we translate it into a corresponding formal model based on discrete-time Markov chains (DTMCs). We use the

Context Bio-inspired feature selection algorithms got the attention of the researchers in the domain of Software Development Effort Estimations (SDEE) because they can improve the prediction accuracy of existing estimation techniques, such as machine learning methods. Objective This paper aims to analyze different feature selection algorithms and assess the role they can play to increase the accuracy

Software maintenance and evolution involves critical activities for the success of software projects. To support such activities and keep code up-to-date and error-free, software communities make use of issue trackers, i.e., tools for signaling, handling, and addressing the issues occurring in software systems. However, in popular projects, tens or hundreds of issue reports are daily submitted. In

Bug prediction aims at locating defective source code components relying on machine learning models. Although some previous work showed that selecting the machine-learning classifier is crucial, the results are contrasting. Therefore, several ensemble techniques, i.e., approaches able to mix the output of different classifiers, have been proposed. In this paper, we present a benchmark study in which

Compatibility is a crucial problem that is encountered while constructing new software by reusing and composing existing components. A set of software components is called compatible if their composition preserves certain properties, such as deadlock freedom. However, checking compatibility for systems communicating asynchronously is an undecidable problem, and asynchronous communication is a common

Runtime verification (RV) is an approach to verification consisting in dynamically checking that the event traces generated by single runs of a system under scrutiny (SUS) are compliant with the formal specification of its expected correct behavior. RML (Runtime Monitoring Language) is a simple but powerful Domain Specific Language (DSL) for RV which is able to express non context-free properties.

This paper compares a large set of programming languages regarding their efficiency, including from an energetic point-of-view. Indeed, we seek to establish and analyze different rankings for programming languages based on their energy efficiency. The goal of being able to rank programming languages based on their energy efficiency is both recent, and certainly deserves further studies. We have taken

The C programming language is well-known to have a large amount of underspecified behavior that often results in non-determinism even of sequential programs. In many application areas, not necessarily safety-critical ones, this is highly undesirable. A number of approaches and tools that statically analyze such behavior have been suggested, but they suffer from a high number of false positives and

A big problem in a computer-based systems (CBSs) development organization is how to improve the immigration of a newbie (a new hire to the organization or a mover within the organization) into a CBS development project of the organization that is already in progress. The newbie, who is ignorant of the domain of the CBS, must be brought to the same awareness of the domain that the project veterans have

Context: Predicting software project effort from Use Case Points (UCP) method is increasingly used among researchers and practitioners. However, unlike other effort estimation domains, this area of interest has not been systematically reviewed. Aims: There is a need for a systemic literature review to provide directions and supports for this research area of effort estimation. Specifically, the objective

Context Requirements elicitation is a crucial phase in the software development life cycle. During requirements elicitation sessions, requirements engineers capture software requirements, and motivate stakeholders to express needs and expected software functionalities. In this context, there is a lack of extensive empirical research reporting the extent to which elicitation sessions can be influenced

The development of the Internet of Things (IoT) came with the manufacturing of a huge amount of smart things equipped with sensors for making them aware of their environment, and with network connection for allowing remote interaction with them. However, most smart things still lack enough autonomy and context-awareness, hindering them from being people-friendly and actually useful for their users'

The Clock Constraint Specification Language (CCSL) is a clock-based specification language for real-time embedded systems. With logical clocks defined as first-class citizens, CCSL provides a natural way for describing clock constraints in synchronous systems — a classical model of concurrency for real-time embedded systems. In this paper, we propose a clock-based dynamic logic called CCSL Dynamic

For large-scale distributed systems that need to adapt to a changing environment, conducting a reconfiguration is a challenging task. In particular, efficient reconfigurations require the coordination of multiple tasks with complex dependencies. We present Concerto, a model used to manage the lifecycle of software components and coordinate their reconfiguration operations. Concerto promotes efficiency

Collecting statistics from graph-based data is an increasingly studied topic in the data mining community. We argue that they can have great value in the coordination of dynamic IoT systems as well, especially to support complex coordination strategies related to distributed situation recognition. Thanks to a mapping to the field calculus, a distribution coordination model proposed for collective adaptive

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

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

Priority is an important concept in Business Process Management (BPM), useful in the context of workflow patterns such as, e.g., cancelable and compensable tasks within business transactions. Unfortunately, the presence of priority in workflows makes them difficult to be analyzed formally by automated validation and verification tools. In the past, we demonstrated that the Reo coordination language

Software and data analytics solutions support improving development processes and the quality of the software produced in Agile Software Development (ASD). However, decision makers in software teams (e.g., product owner, project manager) are demanding powerful tools providing evidence data that support their strategic decision-making processes. In this paper, we present and provide access to QaSD,

Equivalence checking is an established technique for automatically verifying that two behavioural models (Labelled Transition Systems, LTSs) are equivalent from the point of view of an external observer. When these models are not equivalent, the checker returns a Boolean result with a counterexample, which is a sequence of actions leading to a state where the equivalence relation is not satisfied.

We present a tool chain for model-driven development of asynchronous message-passing applications. The key features of the tool allow designers to identify misbehaviour leading to unsound communications, to provide counterexamples, and to suggest possible corrections as well as to project global specifications to local models in order to generate executable implementations.

Although many research efforts have been spent on the theory and implementation of data-based coordination languages, not much effort has been devoted to constructing programming environments to analyze and reason over programs written in these languages. This paper proposes a workbench for describing concurrent systems using a Linda-like language, for animating them and for reasoning over them using