A Framework for the Maintenance and Evolution of ePolicy-guided Web Applications

In this paper we present an “ePolicy framework” that can be used to develop transactional-based ePolicy-guided Web applications. This framework incorporates a non-proprietary component based architecture, a well-defined standards-based user interface, a structured representation of ePolicies, ePolicy operations and user input data, and incorporates a maintenance management component. Each component is self-contained and can therefore be independently maintained. ePolicies and associated ePolicy operations are not embedded in the system software but are stored centrally in an external store (Policy Repository) and are dynamically loaded as required. Executable code (marshalled from XML) is automatically generated from the ePolicies and the ePolicy operations and used in policy-guided evaluation. The Policy Repository, accessible by suitably privileged components, removes ePolicy duplication and from a maintenance perspective, this approach reduces the possibility of errors being introduced by data duplication. Updates to ePolicies are seamlessly applied the next time an ePolicy is loaded. ePolicies are represented in a standard uniform format and as all components use this uniform format, maintainers do not need to understand or handle multiple data formats. They are represented using a policy hierarchy composed of three layers: meta-ePolicies, ePolicy-groups and ePolicies. Each of the components is designed using Object-Oriented principles. Our ePolicy framework will work in a centralized or distributed environment. We believe that using our framework to develop ePolicy-guided evaluation systems will reduce data maintenance and expedite software evolution

Reducing regression test size by exclusion.

Operational software is constantly evolving. Regression testing is used to identify the unintended consequences of evolutionary changes. As most changes affect only a small proportion of the system, the challenge is to ensure that the regression test set is both safe (all relevant tests are used) and unclusive (only relevant tests are used). Previous approaches to reducing test sets struggle to find safe and inclusive tests by looking only at the changed code. We use decomposition program slicing to safely reduce the size of regression test sets by identifying those parts of a system that could not have been affected by a change; this information will then direct the selection of regression tests by eliminating tests that are not relevant to the change. The technique properly accounts for additions and deletions of code. We extend and use Rothermel and Harrold’s framework for measuring the safety of regression test sets and introduce new safety and precision measures that do not require a priori knowledge of the exact number of modification-revealing tests. We then analytically evaluate and compare our techniques for producing reduced regression test sets

Reducing regression test size by exclusion.

Operational software is constantly evolving. Regression testing is used to identify the unintended consequences of evolutionary changes. As most changes affect only a small proportion of the system, the challenge is to ensure that the regression test set is both safe (all relevant tests are used) and unclusive (only relevant tests are used). Previous approaches to reducing test sets struggle to find safe and inclusive tests by looking only at the changed code. We use decomposition program slicing to safely reduce the size of regression test sets by identifying those parts of a system that could not have been affected by a change; this information will then direct the selection of regression tests by eliminating tests that are not relevant to the change. The technique properly accounts for additions and deletions of code. We extend and use Rothermel and Harrold’s framework for measuring the safety of regression test sets and introduce new safety and precision measures that do not require a priori knowledge of the exact number of modification-revealing tests. We then analytically evaluate and compare our techniques for producing reduced regression test sets

Using real options to select stable Middleware-induced software architectures

The requirements that force decisions towards building distributed system architectures are usually of a non-functional nature. Scalability, openness, heterogeneity, and fault-tolerance are examples of such non-functional requirements. The current trend is to build distributed systems with middleware, which provide the application developer with primitives for managing the complexity of distribution, system resources, and for realising many of the non-functional requirements. As non-functional requirements evolve, the `coupling' between the middleware and architecture becomes the focal point for understanding the stability of the distributed software system architecture in the face of change. It is hypothesised that the choice of a stable distributed software architecture depends on the choice of the underlying middleware and its flexibility in responding to future changes in non-functional requirements. Drawing on a case study that adequately represents a medium-size component-based distributed architecture, it is reported how a likely future change in scalability could impact the architectural structure of two versions, each induced with a distinct middleware: one with CORBA and the other with J2EE. An option-based model is derived to value the flexibility of the induced-architectures and to guide the selection. The hypothesis is verified to be true for the given change. The paper concludes with some observations that could stimulate future research in the area of relating requirements to software architectures

A Case Study in Optimization of Resource Distribution to Cope with Unanticipated Changes in Requirements

It is a known fact that requirements change continuously, and as a consequence, it may be necessary to reschedule development activities so that the new requirements can be addressed in a costeffective manner. Unfortunately, changes in requirements cannot be specified precisely. Moreover, current software development methods do not provide explicit means to adapt development processes with respect to unanticipated changes in requirements. This article first proposes a method based on Markov Decision Theory, which determines the estimated optimal development schedule with respect to probabilistic product demands and resource constraints. Second, a tool is described that is built to support the method. Finally, some experimental results are presented on the applicability of the proposed method

Educational software reflecting two philosophical approaches to ethics education

Ethics education can vary considerably in its instructional strategies based on differences in the theoretical positions underlying the approach to moral development being stressed. Two such approaches are the 'justice' approach as exemplified by Kohlberg's six stages of moral development, and the 'care ethic' approach as exemplified by Gilligan's work on empathy as a base for moral decision-making. Each of these approaches can be demonstrated through different instructional strategies in the ethics education course, but each strategy is often difficult to execute in practice, given time and resource constraints

An ontology of agile aspect oriented software development

Both agile methods and aspect oriented programming (AOP) have emerged in recent years as new paradigms in software development. Both promise to free the process of building software systems from some of the constraints of more traditional approaches. As a software engineering approach on the one hand, and a software development tool on the other, there is the potential for them to be used in conjunction. However, thus far, there has been little interplay between the two. Nevertheless, there is some evidence that there may be untapped synergies that may be exploited, if the appropriate approach is taken to integrating AOP with agile methods. This paper takes an ontological approach to supporting this integration, proposing ontology enabled development based on an analysis of existing ontologies of aspect oriented programming, a proposed ontology of agile methods, and a derived ontology of agile aspect oriented development

Cloud service localisation

The essence of cloud computing is the provision of software and hardware services to a range of users in dierent locations. The aim of cloud service localisation is to facilitate the internationalisation and localisation of cloud services by allowing their adaption to dierent locales. We address the lingual localisation by providing service-level language translation techniques to adopt services to dierent languages and regulatory localisation by providing standards-based mappings to achieve regulatory compliance with regionally varying laws, standards and regulations. The aim is to support and enforce the explicit modelling of aspects particularly relevant to localisation and runtime support consisting of tools and middleware services to automating the deployment based on models of locales, driven by the two localisation dimensions. We focus here on an ontology-based conceptual information model that integrates locale specication in a coherent way