Reusability in software engineering

This paper surveys recent work concerning reusability in software engineering. The current directions in software reusability are discussed, and the two major approaches of reusable building blocks and reusable patterns studied. An extensive bibliography, parts of which are annotated, is included

A Logic-based Framework for Software Construction

AbstractThis paper describes a framework for assisting the automatic construction of programs from separately designed and compiled modules. The framework has facilities to automatically extract many important items of information from source codes. It has also facilities to deduce new items from old ones. The framework also supports multiple versions, static, and dynamic selections of appropriate components. It supports graphical displays for system's components and their relationships

Static and dynamic structure in design patterns

technical reportDesign patterns are a valuable mechanism for emphasizing structure, capturing design expertise, and facilitating restructuring of software systems. Patterns are typically applied in the context of an object-oriented language and are implemented so that the pattern participants correspond to object instances that are created and connected at run-time. This paper describes a complementary realization of design patterns, in which the pattern participants are statically instantiated and connected components. Our approach separates the static parts of the software design from the dynamic parts of the system behavior. This separation makes the software design more amenable to analysis, enabling more effective and domain specific detection of system design errors, prediction of run-time behavior, and more effective optimization. This technique is applicable to imperative, functional, and object-oriented languages: we have extended C, Scheme, and Java with our component model. In this paper, we illustrate this approach in the context of the OSKit, a collection of operating system components written in C

A Repository for a CARE Environment

Repositories in CASE hold information about the development process and the structure of developing software. The migration or reuse of CASE repositories for CARE (Computer Aided Re-Engineering) is not adequate for the reengineering process. The main reasons for its inadequacy are the emptiness of such repositories and the nature of the process itself. In the following report we will define a CARE architecture, from the reengineering point of view, and derive a structure of a repository appropriate to the reengineering process

A flexible model for dynamic linking in Java and C#

Dynamic linking supports flexible code deployment, allowing partially linked code to link further code on the fly, as needed. Thus, end-users enjoy the advantage of automatically receiving any updates, without any need for any explicit actions on their side, such as re-compilation, or re-linking. On the down side, two executions of a program may link in different versions of code, which in some cases causes subtle errors, and may mystify end-users. Dynamic linking in Java and C# are similar: the same linking phases are involved, soundness is based on similar ideas, and executions which do not throw linking errors give the same result. They are, however, not identical: the linking phases are combined differently, and take place in different order. Consequently, linking errors may be detected at different times by Java and C# runtime systems. We develop a non-deterministic model, which describes the behaviour of both Java and C# program executions. The nondeterminism allows us to describe the design space, to distill the similarities between the two languages, and to use one proof of soundness for both. We also prove that all execution strategies are equivalent with respect to terminating executions that do not throw link errors: they give the same results

Graph-based system configuration

We present an optimization problem that arises in the context of system-design and the refinement of high-level specifications. We present a graph-based formalization of the problem, thus defining a new optimization problem, which we call MINIMUM CONFIGURATION. We prove MINIMUM CONFIGURATION to be NP-hard and also hard to approximate, i.e. not to be in APX. These results are obtained by reduction from graph coloring and SHORTEST PATH WITH FORBIDDEN PAIRS. We show how to apply the introduced concepts to the application domain and propose a way to identify subclasses in the input space, for which MINIMUM CONFIGURATION can be solved efficiently

Sustainable Development through Holistic Multi-Paradigmatic Integrated Modeling and Decision Making

Sustainability, sustainable development, and transformation is about balancing the economic, environmental and social aspects of organisations and their operations. Existing systems do not comprehensively support sustainable transformation nor do they allow decision makers to explore interrelationships and influences between the sustainability dimensions. This leads to silo based decision making where vision and strategies are not mapped to execution, and sustainability modelling processes are uncoordinated, lack holism, are biased and myopic. One of the critical challenges is the lack of processes and systems that allow the integration of models belonging to disparate paradigms in a holistic manner. To overcome these problems this research proposes a holistic, multi-paradigmatic, integrated modelling and decision making (HOMIMD) approach for sustainable development and transformation. We apply the HOMIMD processes, and requirements to a warehouse management problem and leverage optimization (AIMMS), systems dynamics (iThink), and data mining (SPSS Modeler) approaches, techniques, and systems to solve the problem

Inter-module code analysis techniques for software maintenance

The research described in this thesis addresses itself to the problem of maintaining large, undocumented systems written in languages that contain a module construct. Emphasis is placed on developing techniques for analysing the code of these systems, thereby helping a maintenance programmer to understand a system. Techniques for improving the structure of a system are presented. These techniques help make the code of a system easier to understand. All the code analysis techniques described in this thesis involve reasoning with, and manipulating, graphical representations of a system. To help with these graph manipulations, a set of graph operations are developed that allow a maintenance programmer to combine graphs to create a bigger graph, and to extract subgraphs from a given graph that satisfy specified constraints. A relational database schema is developed to represent the information needed for inter-module code analysis. Pointers are given as to how this database can be used for inter-module code analysis

An Architecture for Integrating Concurrency Control into Environment Frameworks

Research in layered and componentized systems shows the benefit of dividing the responsibility of services into separate components. It is still an unresolved issue, however, how a system can be created from a set of existing (independently developed) components. This issue of integration is of immense concern to software architects since a proper solution would reduce duplicate implementation efforts and promote component reuse. In this paper we take a step towards this goal within the domain of software development environments (SDEs) by showing how to integrate an external concurrency control component, called Pern, with environment frameworks. We discuss two experiments where we integrated Pern with Oz, a multi-site, decentralized process centered environment, and Process WEAVER, a commercial process server. We introduce an architecture for retrofitting an external concurrency control component into an environment