Search

Space missions need software in order to be aware of the occurrence of geometric events in different phases of their project lifecycle. However, current software packages that provide capabilities to search for geometric events might lack desirable software qualities such as extensibility and reusability, and some conflate the definition of events with the search for the same. In order to improve the state of the art, we propose a framework named Tychonis that, via metamodeling techniques and conscious use of object-oriented design best practices, (i) can integrate with current and future mission software, (ii) enables end-users to extend opportunities and search algorithms without modifying the tools that use the framework, and (iii) promotes the cross-mission reusability of the framework and its extensions. These attributes make it less costly for projects to develop software to search for geometric events. Tychonis is provided as a software library that allows missions to add their own data structures and constructs to the framework, including geometric event types and search algorithms. This is accomplished with Tychonis’ use of the Eclipse Modeling Framework (EMF) to capture its metamodel, which enables the generation of Java classes that represent built-in or user-developed Tychonis constructs. In the present paper, we elaborate on the impetus for the development of Tychonis, present its proposed design and use, and discuss growth opportunities for future consideration., Peer Reviewed, Postprint (author's final draft)

Reference architectures have emerged as an important arti-fact of software engineering, since they provide knowledge and experi-ence about how to design architectures of software systems in a specificdomain, favoring their reuse, and standardization. Describing referencearchitectures still is a great challenge, since knowledge about the domainand the concrete architectures should be described and documented in acoherent, cohesive, unambiguous, and complete way. However, referencearchitectures practical use is difficult due mainly to problems in their de-scriptions. The main goal is evaluate existing approaches for describingRAs, analyzing six key aspects while describing RAs: type, adherence toISO/IEC 42010, applicability, maturity, interoperability, and dynamism.For this, we conducted a systematic mapping and identified 21 primarystudies with approaches to describe reference architectures. We evaluated21 approaches to describe RAs, of which four approaches (S4, S7, S16,S17) adhered to at least half of the ISO/IEC standard, six (S3, S4, S5, S7,S8, and S19) achieved a medium technological readiness level, one (S4)adopted a standard to achieve interoperability among systems, and onlyone (S8) considered the dynamism in the description of RA. We highlightthe need to propose methods for describing RAs, considering the guidesand tools to support the description of RAs., This work was supported in part by CNPq (Grant: 141602/2017-1, 312634/2018-8), FAPESP (Grant: 2018/07437-9, 2018/24173-5, 2017/22107-2, 2017/06195-9), and CoSmart Spanish project (contract TIN2017-83964-R)., Peer Reviewed, Postprint (author's final draft)

Context-aware computing is the ability of Services and applications to adapt and react to context changes. Context modelling is a core feature of context-aware computing. Although a lot of research has been made in the field of context modelling, most of the context-aware computing proposals prefer to design their own customized context model instead of reusing an existing one. The main reason for this behaviour is that current context models present some problems concerning reusability, extensibility and adaptation. To contribute solving these issues, in this paper we present 3LConOnt, a three-level context ontology that can be easily reused, extended and adapted for specific or generic purposes. The proposed context model consolidates the context knowledge already available from a modular perspective yielding a clear schema of knowledge reutilization. To do so, we gathered context knowledge pieces from different ontologies to be integrated into standardized and well-defined levels of abstraction and modules. The proposal has been validated considering: (1) reusability, extensibility and adaptation by instantiating different smart scenarios; (2) consistency and reasoning by triggering queries to the proposed model based on some competence questions; and (3) reusability in existing ontologies by importing the needed module or level of the model. Additionally, we also illustrate its usability in context-aware Services by modelling a context-aware framework architecture for supporting the whole context life cycle: acquisition, modelling, reasoning and distribution., Peer Reviewed, Postprint (author's final draft)

The definition of the context of a system is one of the most relevant activities in the early phases of information systems engineering. It allows system engineers to narrow the system scope, by defining well established system boundaries. In practice, outlining a system context model is complex and cumbersome. In order to support context modeling, in this paper we propose a catalogue of context model elements expressed in i*, which can be reused as building blocks in the construction of context models for new systems. We describe the process used for the identification of a set of actors and dependencies recurrently appearing in several academic and industrial cases, and the process to store them into a catalogue of reusable i* context dependencies., Peer Reviewed, Postprint (author's final draft)

The success of Component-Based Software Development is based on the ability of an implementer team to select, assemble and integrate third-party and other components with own application software, in order to create a software system that satisfies (most of) the customer/clients stated needs in an economic and flexible way. Nowadays, the reuse of Open Source Software (OSS) components available from the Internet is playing a strategic role in the industry. This chapter aims at providing empirical evidence on current industrial OSS selection practices based on semi-structured interviews performed in 17 European organizations. In particular, the study tackles the following activities: 1) initial identification of available OSS components, 2) closer evaluation of the identified components, 3) conclusive decision-making of the chosen ones, and 4) updating of OSS-relevant experience and knowledge for the actual company. For simplicity we have omitted system-wide integration and testing activities. The results of this study ought to be valuable not just for researchers, as a sobering basis in their quest for practical selection methods; but also for practitioners that regularly drive OSS selection processes with potential to learn from other colleagues’ work., Peer Reviewed, Postprint (published version)

Software requirement reuse strategies are necessary to capitalize and reuse knowledge in the requirement engineering phase. The PABRE framework is designed to support requirement reuse through the use of software requirement patterns. It consists of a meta-model that describes the main concepts around the notion of pattern, a method to conduct the elicitation and documentation processes, a catalogue of patterns, and a tool that supports the catalogue’s management and use. In this chapter all these elements are presented in detail making emphasis on the construction, use and evolution of software requirement patterns. Furthermore, the chapter includes the construction of a catalogue of nontechnical software requirement patterns for illustration purposes., Peer Reviewed, Postprint (author's final draft)

Software requirements reuse becomes a fundamental activity for those IT organizations that conduct requirements engineering processes in similar settings. One strategy to implement this reuse is by exploiting a catalogue of software requirement patterns (SRPs). In this tutorial, we provide an introduction to the concept of SRP, summarise several existing approaches, and reflect on the consequences on several requirements engineering processes and activities. We take one of these approaches, the PABRE framework, as exemplar for the tutorial and analyse in more depth the catalogue of SRP that is proposed. We apply the concepts given on a practical exercise., Postprint (author’s final draft)

[Context and motivation] There is considerable flexibility in requirements specifications (both functional and non-functional), as well as in the features of available OSS components. This allows a collaborative matching and negotiation process between stakeholders such as: customers, software contractors and OSS communities, regarding desired requirements versus available and thus reusable OSS components. [Problem] However, inconclusive research exists on such cooperative processes. Not much empirical data exists supporting the conduction of such research based on observation of industrial OSS adoption projects. This paper investigates how functional and non-functional requirement mismatches are handled in practice. [Results] We found two common approaches to handle functional mismatches. The main resolution approach is to get the components changed by the development team, OSS community or commercial vendor. The other resolution approach is to influence requirements, often by postponing requirements. Overall, non-functional requirements are satisfactorily achieved by using OSS components. Last but not least, we found that the customer involvement could enhance functional mismatch resolution while OSS community involvement could improve non-functional mismatch resolution. [Contribution] Our data suggests that the selecting components should be done iteratively with close collaboration with stakeholders. Improvement in requirement mismatch resolution to requirements could be achieved by careful consideration of mismatches size, requirements flexibility and components quality., Peer Reviewed, Postprint (author's final draft)

The success of software development using third party components highly depends on the ability to select a suitable component for the intended application. The evidence shows that there is limited knowledge about current industrial OTS selection practices. As a result, there is often a gap between theory and practice, and the proposed methods for supporting selection are rarely adopted in the industrial practice. This paper's goal is to investigate the actual industrial practice of component selection in order to provide an initial empirical basis that allows the reconciliation of research and industrial endeavors. The study consisted of semi-structured interviews with 23 employees from 20 different software-intensive companies that mostly develop web information system applications. It provides qualitative information that help to further understand these practices, and emphasize some aspects that have been overlooked by researchers. For instance, although the literature claims that component repositories are important for locating reusable components; these are hardly used in industrial practice. Instead, other resources that have not received considerable attention are used with this aim. Practices and potential market niches for software-intensive companies have been also identified. The results are valuable from both the research and the industrial perspectives as they provide a basis for formulating well-substantiated hypotheses and more effective improvement strategies., Peer Reviewed, Postprint (author's final draft)

In previous work, we proposed the use of software quality models for driving the formulation of requirements in the context of software package selection. Now, we report two related projects of construction of software quality models in the domains of document management, entreprise content management and Web content management. These domains may be considered particular cases of a more general category sometimes labeled as content management. The goals of these projects are several. First, to assess the scalability of our methods and artifacts. Second, to investigate the degree of reusability when working on domains so closely related. Third, in relation to the previous one, to gain more knowledge of the adequacy and effectiveness of our notion of software domains taxonomy. Fourth, to evaluate the suitability and usability of our DesCOTS system proposed as tool-support for these activities., Peer Reviewed, Postprint (published version)

Variability modeling and service-orientation are important approaches that address both the flexibility and adaptability required by stakeholders of today’s software systems. Goal-oriented approaches for modeling service-oriented systems and their variability in an integrated manner are needed to address the needs of heterogeneous stakeholders and to develop and evolve these systems. In this paper we propose an approach that complements the i* modeling framework with decision models from orthogonal variability modeling. We illustrate the approach using an example and present options for tool support., Peer Reviewed, Postprint (author's final draft)

The use of Off-The-Shelf software components in Component- Based Development implies many challenges. One of them is the lack of available and well-suited data to support selection of suitable OTS components. This paper proposes a feasible and incremental way to federate and reuse the different efforts for finding, selecting, and maintaining OTS components in a structured way. This is done not only for supporting OTS components selection, but also to overcome reported problems with the integration and maintenance of component repositories. It is based on the “open source collaboration” idea to incrementally build an OTS components reuse infrastructure, enabling automatic support for OTS selection processes., Peer Reviewed, Postprint (author's final draft)

Software product line approaches produce reusable platforms and architectures for products set developed by specific companies. These approaches are strategic in nature requiring coordination, discipline, commonality and communication. The Capability Maturity Model (CMM) contains important guidelines for process improvement, and specifies "what" we must have into account to achieve the disciplined processes (among others things). On the other hand, the agile context is playing an increasingly important role in current software engineering practices, specifying "how" the software practices must be addressed to obtain agile processes. In this paper, we carry out a preliminary analysis for reconciling agility and maturity models in software product line domain, taking advantage of both., Postprint (published version)

Agile methods are proposed nowadays as a way to support software systems procurement. Most of the existing proposals such as eXtreme programming or scrum seem to conceive software procurement as an exercise of software development. However, a great deal of software systems are commercial off-the-shelf (COTS)-based systems, in which the focus changes from bespoke software development to COTS selection and integration. Many proposals for COTS selection have been issued and therefore one may wonder how do they behave from the agile point of view. In this paper, we study the agile principles in the context of COTS selection and we analyze some of the most widespread existing methods. As a result, we identify some practices that would help in making COTS selection processes more agile., Peer Reviewed, Postprint (published version)

In this paper we propose a taxonomy for classifying COTS business applications, i.e. products that are used in the daily functioning of all types of organizations worldwide, such as ERP systems and document management tools. We propose the identification of characterization attributes to arrange the domains which these products belong to, and also we group these domains into categories. We define questions and answers as a means for browsing the taxonomy during COTS selection. We show the need of identifying and recording the relationships among the domains and propose the use of actor-oriented models for expressing these relationships as dependencies. Last, we explore the definition of quality models for the domains, to be used in COTS selection, focusing on their reusability and stepwise definition downwards the hierarchy. (Best Paper Award 2004), Peer Reviewed, Postprint (author's final draft)

Selection of commercial-off-the-shelf software components (COTS components) has a growing importance in software engineering. Unfortunately, selection projects have a high risk of ending up into abandonment or yielding an incorrect selection. The use of some software engineering practices such as the definition of quality models can reduce this risk. We defined a process for COTS components selection based on the use of quality models and we started to apply it in academic and industrial cases. The need of having a tool to support this process arose and, although some tools already exist to partially support the involved activities, none of them was suitable enough. Because of this we developed DesCOTS, a software system that embraces several tools that interact to support the different activities of our process. The system has been designed taking into account not only functional concerns but also nonfunctional aspects such as reusability, interoperability and portability. We present in this paper the different subsystems of DesCOTS and discuss about their applicability., Peer Reviewed, Postprint (published version)

Component-based software development heavily relies on the ability of reusing components from a library with as little effort as possible. Among others, valuable features for reusing from a component library are: adaptability to many contexts, extensibility, abstraction and high level of robustness with respect to changes in some of their components. In this paper we study one of the most widely used component library for Ada 95, the Grady Booch’s one, mainly in relation to these features. Our study focuses on the Container-classes family, which present some drawbacks mainly due to the fact that some parent-classes depend on the concrete form of their children-classes. We propose a solution centred on changing the Containers base class. This new version of the Containers class offers a new concept, namely shortcut, that allows not only to avoid the dependencies between parent-classes and their children classes, but also offers some additional advantages, remarkably improving the efficiency of components., Peer Reviewed, Postprint (author's final draft)

This paper highlights the role of non-functional information when reusing from a component library. We describe a method for selecting appropriate implementations of Ada packages taking non-functional constraints into account; these constraints model the context of reuse. Constraints take the form of queries using an interface description language called NoFun, which is also used to state non-functional information in Ada packages; query results are trees of implementations, following the import relationships between components. We define two different situations when reusing components, depending whether we take the library being searched as closed or extendible. The resulting tree of implementations can be manipulated by the user to solve ambiguities, to state default behaviours, and by the like. As part of the proposal, we face the problem of computing from code the non-functional information that determines the selection process., Peer Reviewed, Postprint (author's final draft)

Systematic formulation of software process models (SPM) is currently a challenging problem in software engineering. We present an approach to define such models that encourages: reuse of both elements and models; modularity and incrementality in model construction; simplicity and naturality of the resulting model; and a high degree of concurrence in their enaction. We focus on model definition, distinguishing as usual its static and dynamic parts. We define the static part by means of formally defined hierarchies introducing the categories of elements that take part in SPM definition. Such hierarchies may be constructed and enlarged according to the requirements of any specific SPM. We present as an example a hierarchy for component programming that takes into account non-functional aspects of software (efficiency, etc.). The dynamic part of the SPM is defined by means of precedence relationships between tasks that take part in the model. These precedence relationships are represented with precedence graphs. Development strategies are defined by encapsulating new precedence relationships in modules, that can be combined and reused., Peer Reviewed, Postprint (published version)

Systematic formulation of software process models is currently a challenging problem in software engineering. We present an approach to define models covering the phases of specification, design, implementation and testing of software systems in the component programming framework, taking into account non-functional aspects of software (efficiency, etc.), automatic reusability of implementations in systems and also prototyping techniques involving both specifications and implementations. Our proposal relies on the identification of a catalogue of tasks that appear during these phases which satisfy some relationships concerning their order of execution. A software process model can be defined as the addition of more relationships over these tasks using a simple, modular process language. We have developed also a formal definition of correctness of a software development with respect to a software process model, based on the formulation of models as graphs., Peer Reviewed, Postprint (published version)