The Universal Variability Language (UVL) serves as the primary standard for describing variability models in configurable software systems. SAT/#SAT technology and knowledge-compilation tools, which are commonly used for configuration checking, feature analysis, product counting, and generating uniform random samples, require input in the DIMACS format. This paper presents uvl2dimacs , a C++ tool that converts UVL specifications into DIMACS by providing two complementary techniques: a Tseitin transformation, which limits exponential clause growth, and backbone simplification, which shortens and eliminates clauses by identifying fixed literals. An evaluation of 1,533 real-world models from the UVLHub public repository demonstrates the tool’s correctness and effectiveness. Backbone simplification reduces the number of clauses in 99.09% of models (with a median reduction of 40.43%), while the Tseitin transformation achieves clause reduction in only 0.65% of models (but with a median reduction of 83.11% in those cases).

The configuration space of some systems is so large that it cannot be computed. This is the case with the Linux Kernel , which provides more than 18,000 configurable options described across almost 1,700 files in the Kconfig language. As a result, many analyses of these systems rely on sampling their configuration space (e.g., debugging compilation errors, predicting configuration performance, finding the configuration that optimizes specific performance metrics, among others.). The Kernel and other Kconfig -based systems can be sampled pragmatically , using their built-in tool conf to get a sample directly from the Kconfig specification that is approximately random, or idealistically , generating a genuine random sample by first translating the Kconfig files into logic formulas, then using a logic engine to compute the probability that each option value has to appear in a configuration, and finally utilizing these probabilities to generate an authentically random sample. The pros of the idealistic approach are that it ensures the sample is representative of the population, but the cons are that it sets out many challenging problems that have not been solved yet (fundamentally, how to obtain a valid translation into Boolean that covers all the Kconfig language, and how to compute the option value probabilities for very large formulas). This paper introduces a new version of conf called randconfig + , which incorporates a series of improvements that increase the randomness and correctness of pragmatic sampling and also help validate the Boolean translation required for the idealistic approach. randconfig + has been tested on ten versions of the Linux Kernel and twenty additional Kconfig systems. Its compatibility significantly enhances the current landscape, where some systems use a customized conf variant that is maintained independently, while others do not support sampling at all. randconfig + not only offers universal sampling for all Kconfig systems but also simplifies its evolutive maintenance as a single tool rather than an unorganized collection of conf variants.

A Software Product Line ( SPL ) is a family of similar programs. Each program is defined by a unique set of features, called a configuration , that satisfies all feature constraints. “What configuration achieves the best performance for a given workload?” is the SPL Optimization ( SPLO ) challenge. SPLO is daunting: just 80 unconstrained features yield 10 24 unique configurations, which equals the estimated number of stars in the universe. We explain (a) how uniform random sampling and random search algorithms solve SPLO more efficiently and accurately than current machine-learned performance models and (b) how to compute statistical guarantees on the quality of a returned configuration; i.e., it is within x% of optimal with y% confidence.

Abstract Some of the most critical competencies students need to acquire to become control engineers require performing practices under actual industrial conditions. This means that they must not only master the theoretical aspects of the discipline but also acquire skills and attitudes to face unpredictable real-world situations. Software tools such as Matlab/Simulink are widely used to train the design and validation of controllers, but they fail to provide real industrial contexts. Nowadays, there are 3D simulation tools that support recreating industrial environments to a remarkable extent, making them very attractive for university courses. Nevertheless, their application in engineering courses is scarce yet. This paper presents a methodological framework for seizing into competency-based courses one of these simulation tools, called Factory I/O. Our approach was evaluated in a master’s course on Industrial PID Control at Pontifical Catholic University of Valparaíso (PUCV) in Chile. The evaluation comprised the qualitative analysis of students’ grades over four consecutive course editions and the qualitative study of students’ opinion on Factory I/O educational value. The objectives of our evaluation were (i) testing if Factory I/O helped students develop skills hard to practice in academic contexts, such as detecting faults or recognizing the importance of having well-defined operation protocols; (ii) validating our methodology for competency-based courses; and (iii) surveying our students about Matlab/Simulink and Factory I/O strengths/weaknesses to teach control engineering. According to the results, (a) Factory I/O complements Simulink by providing an adequate virtual environment to learn the aforementioned skills; and (b) our methodology supports courses’ continuous improvement through the statistical analysis of students’ achievements at different abstraction levels.

The advent of the Internet of Things has generated loads of data from the devices that are now connected to the Internet. While the majority of the data corresponds to measurements done by these devices, there is a second type of information (the metadata) that provides information about the devices themselves. Most of this metadata is still underused when used at all. On the other hand, the graphical user interfaces that allow operating and/or monitoring the connected devices from a computer or smartphone, are usually programmed from zero. However, the metadata that describes the main properties of the devices (i.e., inputs, outputs, precision, range, etc.) can be used along with smart web design techniques to automatically create these interfaces. This article proposes a framework to achieve this, and presents an application example consisting of an online lab of a servo-motor.

Software systems are becoming increasingly configurable. A paradigmatic example is the Linux kernel, which can be adjusted for a tremendous variety of hardware devices, from mobile phones to supercomputers, thanks to the thousands of configurable features it supports. In principle, many relevant problems on configurable systems, such as completing a partial configuration to get the system instance that consumes the least energy or optimizes any other quality attribute, could be solved through exhaustive analysis of all configurations. However, configuration spaces are typically colossal and cannot be entirely computed in practice. Alternatively, configuration samples can be analyzed to approximate the answers. Generating those samples is not trivial since features usually have inter-dependencies that constrain the configuration space. Therefore, getting a single valid configuration by chance is extremely unlikely. As a result, advanced samplers are being proposed to generate random samples at a reasonable computational cost. However, to date, no sampler can deal with highly configurable complex systems, such as the Linux kernel. This paper proposes a new sampler that does scale for those systems, based on an original theoretical approach called extensible logic groups. The sampler is compared against five other approaches. Results show our tool to be the fastest and most scalable one.

Abstract Many analyses on configurable software systems are intractable when confronted with colossal and highly-constrained configuration spaces. These analyses could instead use statistical inference, where a tractable sample accurately predicts results for the entire space. To do so, the laws of statistical inference requires each member of the population to be equally likely to be included in the sample, i.e., the sampling process needs to be “uniform”. SAT-samplers have been developed to generate uniform random samples at a reasonable computational cost. However, there is a lack of experimental validation over colossal spaces to show whether the samplers indeed produce uniform samples or not. This paper (i) proposes a new sampler named , (ii) presents a new statistical test to verify sampler uniformity, and (iii) reports the evaluation of and five other state-of-the-art samplers: , , , , and . Our experimental results show only satisfies both scalability and uniformity.

2.3 should be "Method 3: Measure the distance between the theoretical variable probabilities with the empirical variable frequencies in a sample", and the title of Section 2.2.4 should be "Method 4: A statistical goodness-of-fit test that compares the theoretical variable probabilities with the empirical variable frequencies in a sample".

Providing computers with the ability to process handwriting is both important and challenging, since many difficulties (e.g., different writing styles, alphabets, languages, etc.) need to be overcome for addressing a variety of problems (text recognition, signature verification, writer identification, word spotting, etc.). This paper reviews the growing literature on off-line handwritten document analysis over the last thirty years. A sample of 5389 articles is examined using bibliometric techniques. Using bibliometric techniques, this paper identifies (i) the most influential articles in the area, (ii) the most productive authors and their collaboration networks, (iii) the countries and institutions that have led research on the topic, (iv) the journals and conferences that have published most papers, and (v) the most relevant research topics (and their related tasks and methodologies) and their evolution over the years.

Variability models are broadly used to specify the configurable features of highly customizable software. In practice, they can be large, defining thousands of features with their dependencies and conflicts. In such cases, visualization techniques and automated analysis support are crucial for understanding the models. This paper contributes to this line of research by presenting a novel, probabilistic foundation for statistical reasoning about variability models. Our approach not only provides a new way to visualize, describe and interpret variability models, but it also supports the improvement of additional state-of-the-art methods for software product lines; for instance, providing exact computations where only approximations were available before, and increasing the sensitivity of existing analysis operations for variability models. We demonstrate the benefits of our approach using real case studies with up to 17,365 features, and written in two different languages (KConfig and feature models).

The Software Product Line approach undertakes the development of complete portfolios of software products as a single, coherent development task. Although there are well-documented examples of cost reduction, shorter development times, and quality improvement achieved by introducing the product line paradigm in industry, the approach is not always the best economic choice for building a family of related systems. To support decision makers, a number of economic models have been proposed. Apparently, existing proposals are rather heterogeneous in terms of their main characteristics and goals. Nevertheless, this paper shows how most models may be defined using a small common lexicon. Translating models to such common lexicon, we compare them in detail, identifying their strengths and weaknesses. As a result, the paper proposes an integrated model that improves the cost estimation accuracy of existing models.

Software Product Lines (SPLs) are families of related software systems that provide different combinations of features. Extensive research and application attest to the significant economical and technological benefits of employing SPL practices. Variability models represent the feature combinations and the properties of the software products of SPLs. Kconfig configuration files from open source projects have been proposed as large and realistic case studies for research on analysis of variability models. However, despite the extensive work on this subject, the seemingly direct approach of translating Kconfig to Binary Decision Diagrams (BDDs) — a representation that has shown significant advantages for complex analysis of variability models — has not been explored. To address this gap, we propose a simple translation scheme which we evaluate with five case studies. Our encouraging results indicate the feasibility of our approach and open up avenues for further research.

Variability models play a key role in software product line engineering as they are used to represent the common and variable features that products may include, and what constraints among the features must be satisfied to guarantee the validity of the products. Valuable analysis operations on variability models can be performed by black box reusing logic engines, such as SAT-solvers and binary decision diagram libraries. Unfortunately, such kind of reuse implies long computation times for operations that need calling the engines many times. To overcome this problem, we propose new algorithms that directly deal with the data structure of a binary decision diagram encoding a variability model. In particular, our algorithms are specifically designed to detect core & dead features, and the impact & exclusion sets of every feature.

Web-based labs are key tools for distance education that help to illustrate scientific phenomena, which require costly or difficult-to-assemble equipment. Easy Java Simulations (EJS) is an authoring tool that speeds up the creation of these kind of labs. An excellent proof of the EJS potential is the open source physics (OSP) repository, which hosts hundreds of free EJS labs. Learning management systems, such as Moodle, provide social contexts where students interact with each other. The work described in this paper looks for the synergy of both tools, EJS and Moodle, by supporting the deployment of EJS labs into Moodle and thus enriching them with social features (e.g., chat, forums, and videoconference). To test this approach, the authors have created the ball and beam lab, which helps students of automatic control engineering to train different advanced techniques (robust, fuzzy, and reset control), and compare their performance in relation to a conventional proportional-integral-derivative control.

A software product line is an engineering approach to efficient development of software product portfolios. Key to the success of the approach is to identify the common and variable features of the products and the interdependencies between them, which are usually modeled using feature models. Implicitly, such models also include valuable information that can be used by economic models to estimate the payoffs of a product line. Unfortunately, as product lines grow, analyzing large feature models manually becomes impracticable. This paper proposes an algorithm to compute the total number of products that a feature model represents and, for each feature, the number of products that implement it. The inference of both parameters is helpful to describe the standardization/parameterization balance of a product line, detect scope flaws, assess the product line incremental development, and improve the accuracy of economic models. The paper reports experimental evidence that our algorithm has better runtime performance than existing alternative approaches.

In software product line engineering, feature diagrams are a popular means to represent the similarities and differences within a family of related systems. In addition, feature diagrams implicitly model valuable information that can be used in economic models to estimate the cost savings of a product line. In particular, this paper reviews existing proposals on computing the total number of products modeled with a feature diagram and, given a feature, the number of products that implement it. This paper also reviews the economic information that can be estimated when such numbers are known. Thus, this paper contributes by bringing together previously-disparate streams of work: the automated analysis of feature diagrams and economic models for product lines.