The abstraction-first approach to data abstraction and algorithms

Experience in industry suggests that reuse does not happen without retraining. However, since reuse is meant to simplify programming, this paper argues the case for re-ordering a traditional data structures and algorithms course, using an object-oriented language, so that it starts from abstraction and reuse, and postpones coding from scratch as far as possible. The intention is that reuse should be learnt before other strategies, so coding from scratch does not have to be unlearnt before reuse seems natural. The paper presents experience with a restructured abstraction-first course, and proposes that an essential tool for such a strategy is a set of scaled-down libraries and frameworks, designed for teaching. Compared with a Modula-2-based course and an earlier C++-based course in which concepts were presented in a different order, more ground was covered, without a major change in the students’ results (grades).     

Opening up design science: The challenge of designing for reuse and joint development

The purpose of this paper is to advance design science by developing a framework for research on reuse and the relationship between external IT artifacts and their users. A design science approach to IS research needs to grapple with the fact that a number of relevant, economically attractive, external IT artifacts cannot be designed from scratch nor meaningfully evaluated based on the current state of development, and so design science research will struggle with incomplete cycles of design, relevance, and rigor. We suggest a strategic research agenda that integrates the design of the relationship between an external IT artifact and the user by considering the impact artifacts exert on users. Three dimensions derived from adaptive structuration theory inform our framework on three levels of design granularity (middle management, top management, and entrepreneur): agenda considers the dynamic properties of technological objects, adaptability refers to the functional affordance of external artifacts in development, and auspice captures the symbolic expression and scope for interpretation. We derive implications for research design.     

Enhancing class commutability in the deployment of design patterns

A design pattern provides a structure to facilitate program changes with respect to a design concern. For example, the State pattern manages object behaviour in different internal states of objects. It allows new internal states of an object to be supported with the reuse of the object context. The deployment of a design pattern in a software program comprises a set of classes following the structure of the pattern. Within the set, classes that implement the managed concern of the pattern are commuted to new ones when changes related to the concern occur. However, commutation efforts can be tedious if these classes are accessed arbitrarily throughout the software. To confine the commutation efforts, these classes should be properly encapsulated. This paper proposes design restrictions in pattern deployments to achieve proper encapsulation. The approach is illustrated by a pattern-based program that supports appointment scheduling of multiple users. Preliminary experiments show that our approach facilitates program changes subject to multiple design concerns.     

Generic screen representations for future-proof systems,is it possible?: There is more to a GUI than meets the eye

BackgroundFuture-proof EHR systems must be capable of interpreting information structures for medical concepts that were not available at the build-time of the system. The two-model approach of CEN 13606/openEHR using archetypes achieves this by separating generic clinical knowledge from domain-related knowledge. The presentation of this information can either itself be generic, or require design time awareness of the domain knowledge being employed.ObjectiveTo develop a Graphical User Interface (GUI) that would be capable of displaying previously unencountered clinical data structures in a meaningful way.MethodsThrough “reasoning by analogy” we defined an approach for the representation and implementation of “presentational knowledge”. A proof-of-concept implementation was built to validate its implementability and to test for unanticipated issues.ResultsA two-model approach to specifying and generating a screen representation for archetype-based information, inspired by the two-model approach of archetypes, was developed. There is a separation between software-related display knowledge and domain-related display knowledge and the toolkit is designed with the reuse of components in mind.ConclusionsThe approach leads to a flexible GUI that can adapt not only to information structures that had not been predefined within the receiving system, but also to novel ways of displaying the information. We also found that, ideally, the openEHR Archetype Definition Language should receive minor adjustments to allow for generic binding.     

A non-invasive object-oriented tool for software testing

A non-invasive approach for capture and playback (C&P) can be a very useful tool for testing applications endowed of a graphic user interface in local and/or distributed environments, and in general for testing applications without modifying their run-time environment. In the software lifecycle, the phases ofC&P are performed after the application design. Since these are close to the delivery deadline, the time needed for application testing is considered as a high, and frequently unacceptable, cost. In this paper, a new approach for non-invasiveC&P testing techniques is proposed. This is strongly based on the object-oriented paradigm at both hardware and software levels. In particular, a new board for image grabbing and pattern matching, and a new object-oriented language for specifying the tests have been defined. The main goals of this new approach are (i) the reduction of testing time by supporting the reuse of tests (coded by using a specific language) at each level of abstraction, and (ii) the anticipation of the capture-phase of testing with the system design.     

Generative software product line development using variability-aware design patterns

Software Product Lines (SPLs) are an approach to reuse in-the-large that models a set of closely related software systems in terms of commonalities and variabilities. Design patterns are best practices for addressing recurring design problems in object-oriented source code. In the practice of implementing SPL, instances of certain design patterns are employed to handle variability, which makes these “variability-aware design patterns” a best practice for SPL design. However, currently there is no dedicated method for proactively developing SPLs using design patterns suitable for realizing variable functionality. In this paper, we present a method to perform generative SPL development with design patterns. We use role models to capture design patterns and their relation to a variability model. We further allow mapping of individual design pattern roles to (parts of) implementation elements to be generated (e.g., classes, methods) and check the conformance of the realization with the specification of the pattern. We provide definitions for the variability-aware versions of the design patterns Observer, Strategy, Template Method and Composite. Furthermore, we support generation of realizations in Java, C++ and UML class diagrams utilizing annotative, compositional and transformational variability realization mechanisms. Hence, we support proactive development of SPLs using design patterns to apply best practices for the realization of variability. We realize our concepts within the Eclipse IDE and demonstrate them within a case study.     

Designing enterprise integration solutions: effectively

The design of large and complex enterprise integration solutions is a difficult task. It can require solutions that are unique because of constraints from the current set of legacy applications. Design knowledge for enterprise integration solutions is, therefore, difficult to articulate and reuse. In particular, the nature and form of knowledge for conceptual design of integration solutions is difficult to pin down. In this paper, we investigate whether design knowledge for enterprise integration in the form of patterns can be reused to develop systems integration solutions, and whether such reuse leads to more effective design outcomes. The research follows design science guidelines in which we describe a research artifact, and evaluate it to assess whether it meets the intended goals. The results indicate that approaches to facilitate reuse of conceptual design knowledge are feasible in the domain of enterprise integration, and that such reuse does, in fact, lead to more effective design solutions.     

The SDL pattern approach – a reuse-driven SDL design methodology

There are several SDL methodologies that offer full system life-cycle support. Only few of them consider software reuse, not to mention high-level reuse of architecture and design. However, software reuse is a proven software engineering paradigm leading to high quality and reduced development effort. Experience made it apparent that – beyond the more traditional reuse of code – especially high-level reuse of architecture and design (as in the case of design patterns or frameworks) has the potential of achieving more systematic and widespread reuse. This paper presents the SDL pattern approach, a design methodology for distributed systems which integrates SDL-based system development with the pattern paradigm. It supports reuse of design knowledge modeled as SDL patterns and concentrates on the design phase of SDL-based system development. In order to get full life-cycle support, the pattern-based design process can be integrated within existing SDL methodologies.     

Fault-tolerant and real-time scheduling for mixed-criticality systems

The design and analysis of real-time scheduling algorithms for safety-critical systems is a challenging problem due to the temporal dependencies among different design constraints. This paper considers scheduling sporadic tasks with three interrelated design constraints: (i) meeting the hard deadlines of application tasks, (ii) providing fault tolerance by executing backups, and (iii) respecting the criticality of each task to facilitate system’s certification. First, a new approach to model mixed-criticality systems from the perspective of fault tolerance is proposed. Second, a uniprocessor fixed-priority scheduling algorithm, called fault-tolerant mixed-criticality (FTMC) scheduling, is designed for the proposed model. The FTMC algorithm executes backups to recover from task errors caused by hardware or software faults. Third, a sufficient schedulability test is derived, when satisfied for a (mixed-criticality) task set, guarantees that all deadlines are met even if backups are executed to recover from errors. Finally, evaluations illustrate the effectiveness of the proposed test.     

Passive testing of communicating systems with timeouts

ContextThe design of complex systems demands methodologies to analyze its correct behaviour. It is usual that a correct behaviour is determined by the compliance with temporal requirements. Currently, testing is the most used technology to validate the correctness of systems. Although several techniques that take into account time aspects have been proposed, most of them require the tester interacts with the system. However, if this is not possible, it is necessary to apply a passive testing approach where the tester monitors the behaviour of the system.ObjectiveThe aim of this paper is to propose a methodology to perform passive testing on communicating systems in which the behaviour of their components must fulfill temporal restrictions associated with both performance and delays/timeouts.MethodOur framework uses algorithms for checking traces collected from the systems against invariants which formally represent the most relevant properties that must be fulfilled by the system. In order to support the feasibility of the methodology, we have performed an empirical study on a complex system for automatic recognition of images based on a pipeline architecture. We have analyzed the correctness of the system’s behaviour with respect to a set of invariants. Finally, an experiment, based on mutations of the system, was conducted to study the level of detection of a set of invariants.ResultsDifferent errors were detected and fixed along the development of the system by means of the proposed methodology. The results of the experiments with the mutated versions of the system indicated that the designed set of invariants was more effective in finding errors associated to temporal aspects than those related to communication among components.ConclusionThe proposed technique has been shown to be very useful for analyzing complex timed systems, and find errors when the tester has no control over their behaviour.     

Automated composition and execution of web-based simulation systems through knowledge designing and reasoning

Modeling and simulation (M&S) techniques can be used to improve cooperation among participants by clarifying the various design aspects of a devised system. Whenever an M&S system with specific functions is required, redesigning it from scratch is time and resource intensive. Thus, an approach to reuse or reconfigure existing systems with functions similar to the required ones is a potential alternative to overcome such problems. This paper proposes a method to build composite systems providing specific M&S functions through the web. The method proposed herein offers an integrated process that includes web-based reuse of existing systems, analysis of the requirements of a composite system, derivation of the logical execution order of element systems, and interconnection of the input–output interfaces between linked constituent systems. This approach provides the required tools by dynamically reconfiguring the element systems at the requested locations. The experimental results demonstrate that the proposed procedure can provide automatic generation of the required M&S system (e.g., missile-interception simulation system) and deliver the system to the target location of the cooperative work through the web.     

Event-B patterns and their tool support

Event-B has given developers the opportunity to construct models of complex systems that are correct-by-construction. However, there is no systematic approach, especially in terms of reuse, which could help with the construction of these models. We introduce the notion of design patterns within the framework of Event-B to shorten this gap. Our approach preserves the correctness of the models, which is critical in formal methods and also reduces the proving effort. Within our approach, an Event-B design pattern is just another model devoted to the formalisation of a typical sub-problem. As a result, we can use patterns to construct a model which can subsequently be used as a pattern to construct a larger model. We also present the interaction between developers and the tool support within the associated RODIN Platform of Event-B. The approach has been applied successfully to some medium-size industrial case studies.     

MOD2-SCM: A model-driven product line for software configuration management systems

ContextSoftware Configuration Management (SCM) is the discipline of controlling the evolution of large and complex software systems. Over the years many different SCM systems sharing similar concepts have been implemented from scratch. Since these concepts usually are hard-wired into the respective program code, reuse is hardly possible.ObjectiveOur objective is to create a model-driven product line for SCM systems. By explicitly describing the different concepts using models, reuse can be performed on the modeling level. Since models are executable, the need for manual programming is eliminated. Furthermore, by providing a library of loosely coupled modules, we intend to support flexible composition of SCM systems.MethodWe developed a method and a tool set for model-driven software product line engineering which we applied to the SCM domain. For domain analysis, we applied the FORM method, resulting in a layered feature model for SCM systems. Furthermore, we developed an executable object-oriented domain model which was annotated with features from the feature model. A specific SCM system is configured by selecting features from the feature model and elements of the domain model realizing these features.ResultsDue to the orthogonality of both feature model and domain model, a very large number of SCM systems may be configured. We tested our approach by creating instances of the product line which mimic wide-spread systems such as CVS, GIT, Mercurial, and Subversion.ConclusionThe experiences gained from this project demonstrate the feasibility of our approach to model-driven software product line engineering. Furthermore, our work advances the state of the art in the domain of SCM systems since it support the modular composition of SCM systems at the model rather than the code level.     

Proof system representations of degrees of disjoint NP-pairs

Let D be a set of many-one degrees of disjoint NP-pairs. We define a proof system representation of D to be a set of propositional proof systems P such that each degree in D contains the canonical NP-pair of a corresponding proof system in P and the degree structure of D is reflected by the simulation order among the corresponding proof systems in P. We also define a nesting representation of D to be a set of NP-pairs S such that each degree in D contains a representative NP-pair in S and the degree structure of D is reflected by the inclusion relations among their representative NP-pairs in S. We show that proof system and nesting representations both exist for D if the lower span of each degree in D overlaps with D on a finite set only. In particular, a linear chain of many-one degrees of NP-pairs has both a proof system representation and a nesting representation. This extends a result by Glaßer et al. (2009). We also show that in general D has a proof system representation if it has a nesting representation where all representative NP-pairs share the same set as their first components.     

H∞ Controller design for spectral MIMO models by convex optimization

A new method for robust fixed-order H_∞ controller design by convex optimization for multivariable systems is investigated. Linear Time-Invariant Multi-Input Multi-Output (LTI-MIMO) systems represented by a set of complex values in the frequency domain are considered. It is shown that the Generalized Nyquist Stability criterion can be approximated by a set of convex constraints with respect to the parameters of a multivariable linearly parameterized controller in the Nyquist diagram. The diagonal elements of the controller are tuned to satisfy the desired performances, while simultaneously, the off-diagonal elements are designed to decouple the system. Multimodel uncertainty can be directly considered in the proposed approach by increasing the number of constraints. The simulation examples illustrate the effectiveness of the proposed approach.     

Software reuse in-the-small: automating group rewarding

In this paper we present a model-independent, multi-level, closed loop approach to software reuse that makes tuning of reuse systems mostly automatic, and includes a reward system for development of reusable components. The proposed techniques are shown to be suitable for development in-the-small by fixing some locally measured reuse coefficients for small teams.     

Synthesis of hierarchical systems

In automated synthesis, given a specification, we automatically create a system that is guaranteed to satisfy the specification. In the classical temporal synthesis algorithms, one usually creates a “flat” system “from scratch”. However, real-life software and hardware systems are usually created using preexisting libraries of reusable components, and are not “flat” since repeated sub-systems are described only once.In this work we describe an algorithm for the synthesis of a hierarchical system from a library of hierarchical components, which follows the “bottom-up” approach to system design. Our algorithm works by synthesizing in many rounds, when at each round the system designer provides the specification of the currently desired module, which is then automatically synthesized using the initial library and the previously constructed modules. To ensure that the synthesized module actually takes advantage of the available high-level modules, we guide the algorithm by enforcing certain modularity criteria.We show that the synthesis of a hierarchical system from a library of hierarchical components is Exptime-complete for μ-calculus, and 2Exptime-complete for Ltl, both in the cases of complete and incomplete information. Thus, in all cases, it is not harder than the classical synthesis problem (of synthesizing flat systems “from scratch”), even though the synthesized hierarchical system may be exponentially smaller than a flat one.     

Learning interpretable fuzzy inference systems with FisPro

Fuzzy inference systems (FIS) are likely to play a significant part in system modeling, provided that they remain interpretable following learning from data. The aim of this paper is to set up some guidelines for interpretable FIS learning, based on practical experience with fuzzy modeling in various fields. An open source software system called FisPro has been specifically designed to provide generic tools for interpretable FIS design and learning. It can then be extended with the addition of new contributions. This work presents a global approach to design data-driven FIS that satisfy certain interpretability and accuracy criteria. It includes fuzzy partition generation, rule learning, input space reduction and rule base simplification. The FisPro implementation is discussed and illustrated through several detailed case studies.     

基于体系结构的应用系统族开发方法的研究

对于建筑领域管理系统这样具有共同特性的一组应用系统的开发,如果没有系统性重用的方法,不仅会造成软件资产的大量浪费,而且也使系统的成本和开发周期大大增加。为解决上述问题,该文提出了一套以体系结构为中心的工程化软件开发方法,该方法利用软件产品线开发的思想,将软件产品线工程和应用工程两种开发活动集成到一起,通过族体系结构的重用实现系统性重用。