A software complexity model of object-oriented systems

A model for the emerging area of software complexity measurement of OO systems is required for the integration of measures defined by various researchers and to provide a framework for continued investigation. We present a model, based in the literature of OO systems and software complexity for structured systems. The model defines the software complexity of OO systems at the variable, method, object, and system levels. At each level, measures are identified that account for the cohesion and coupling aspects of the system. Users of OO techniques perceptions of complexity provide support for the levels and measures.     

A tool for measuring inheritance coupling in object-oriented systems

Analyzing object-oriented systems in order to evaluate their quality gains its importance as the paradigm continues to increase in popularity. Consequently, several object-oriented metrics have been proposed to evaluate different aspects of these systems such as class coupling. In object-oriented design, three types of coupling may exist between classes: inheritance coupling, interaction coupling, and component coupling. This paper presents a tool for measuring inheritance coupling in object-oriented systems.     

A feature-oriented approach for developing reusable product line assets of service-based systems

Service orientation (SO) is a relevant promising candidate for accommodating rapidly changing user needs and expectations. One of the goals of adopting SO is the improvement of reusability, however, the development of service-based system in practice has uncovered several challenging issues, such as how to identify reusable services, how to determine configurations of services that are relevant to users’ current product configuration and context, and how to maintain service validity after configuration changes. In this paper, we propose a method that addresses these issues by adapting a feature-oriented product line engineering approach. The method is notable in that it guides developers to identify reusable services at the right level of granularity and to map users’ context to relevant service configuration, and it also provides a means to check the validity of services at runtime in terms of invariants and pre/post-conditions of services. Moreover, we propose a heterogeneous style based architecture model for developing such systems.     

A component mining approach to incubate Grid services in object-oriented legacy systems

This paper describes an approach for Grid service component mining in object-oriented legacy systems, applying Software clustering, architecture recovery, program slicing and wrapping techniques to decompose a legacy system, analyse the concerned components and integrate them into a Grid environment. The resulting components with core legacy code function in a Grid service framework.     

A method to test concurrent systems using architectural specification

In this paper, we discuss a testing method for integration testing of complex and concurrent systems. Integration testing is considered the least well understood and hence is the most problematic level of testing related to concurrent system development. This is so, because integration testing is not completely unit (or code) neither testing nor it is completely system testing. To achieve this goal of improving integration testing, our proposed method exploits architectural specification of concurrent and distributed systems defined in the high level Petri nets, known as Hierarchical Predicate Transition Nets (HPrTNs). More specifically, our testing method implements the separation of concerns strategy to handle both the essential complexity associated with the front-end software development of inherently concurrent and distributed systems, i.e. architectural specification, and the difficulty and cost associated with the back-end development of these systems, namely, software testing.

A framework for analysis and design of software reference architectures

Context

A software reference architecture is a generic architecture for a class of systems that is used as a foundation for the design of concrete architectures from this class. The generic nature of reference architectures leads to a less defined architecture design and application contexts, which makes the architecture goal definition and architecture design non-trivial steps, rooted in uncertainty.

Objective

The paper presents a structured and comprehensive study on the congruence between context, goals, and design of software reference architectures. It proposes a tool for the design of congruent reference architectures and for the analysis of the level of congruence of existing reference architectures.

Method

We define a framework for congruent reference architectures. The framework is based on state of the art results from literature and practice. We validate our framework and its quality as analytical tool by applying it for the analysis of 24 reference architectures. The conclusions from our analysis are compared to the opinions of experts on these reference architectures documented in literature and dedicated communication.

Results

Our framework consists of a multi-dimensional classification space and of five types of reference architectures that are formed by combining specific values from the multi-dimensional classification space. Reference architectures that can be classified in one of these types have better chances to become a success. The validation of our framework confirms its quality as a tool for the analysis of the congruence of software reference architectures.

Conclusion

This paper facilitates software architects and scientists in the inception, design, and application of congruent software reference architectures. The application of the tool improves the chance for success of a reference architecture.     

A bargaining-specific architecture for supporting automated service agreement negotiation systems

The provision of services is often regulated by means of agreements that must be negotiated beforehand. Automating such negotiations is appealing insofar as it overcomes one of the most often cited shortcomings of human negotiation: slowness. Our analysis of the requirements of automated negotiation systems in open environments suggests that some of them cannot be tackled in a protocol-independent manner, which motivates the need for a protocol-specific architecture. However, current state-of-the-art bargaining architectures fail to address all of these requirements together. Our key contribution is a bargaining architecture that addresses all of the requirements we have identified. The definition of the architecture includes a logical view that identifies the key architectural elements and their interactions, a process view that identifies how the architectural elements can be grouped together into processes, a development view that includes a software framework that provides a reference implementation developers can use to build their own negotiation systems, and a scenarios view by means of which the architecture is illustrated and validated.     

JDiff: A differencing technique and tool for object-oriented programs

During software evolution, information about changes between different versions of a program is useful for a number of software engineering tasks. For example, configuration-management systems can use change information to assess possible conflicts among updates from different users. For another example, in regression testing, knowledge about which parts of a program are unchanged can help in identifying test cases that need not be rerun. For many of these tasks, a purely syntactic differencing may not provide enough information for the task to be performed effectively. This problem is especially relevant in the case of object-oriented software, for which a syntactic change can have subtle and unforeseen effects. In this paper, we present a technique for comparing object-oriented programs that identifies both differences and correspondences between two versions of a program. The technique is based on a representation that handles object-oriented features and, thus, can capture the behavior of object-oriented programs. We also present JDiff, a tool that implements the technique for Java programs. Finally, we present the results of four empirical studies, performed on many versions of two medium-sized subjects, that show the efficiency and effectiveness of the technique when used on real programs.

An object-oriented architecture for knowledge-based production scheduling systems

This paper describes an object-oriented architecture to support decision making in production scheduling environments. An object-oriented world view is used to integrate concepts from discrete event simulation, conventional scheduling logic and artificial intelligence to produce capacity-feasible schedules. The architecture was implemented as a collection of loosely coupled reusable software objects by extending the functionality of software objects from BLOCS/M (Berkeley Library of Objects for Control and Simulation of Manufacturing). Our experience with an industrial prototype is presented.     

CLPL: Providing software infrastructure for the systematic and effective construction of complex collaborative learning systems

Over the last decade, e-Learning and in particular Computer-Supported Collaborative Learning (CSCL) needs have been evolving accordingly with more and more demanding pedagogical and technological requirements. As a result, high customization and flexibility are a must in this context, meaning that collaborative learning practices need to be continuously adapted, adjusted, and personalized to each specific target learning group. These very demanding needs of the CSCL domain represent a great challenge for the research community on software development to satisfy.This contribution presents and evaluates a previous research effort in the form of a generic software infrastructure called Collaborative Learning Purpose Library (CLPL) with the aim of meeting the current and demanding needs found in the CSCL domain. To this end, we experiment with the CLPL in order to offer an advanced reuse-based service-oriented software engineering methodology for developing CSCL applications in an effective and timely fashion. A validation process is provided by reporting on the use of the CLPL platform as the primary resource for the Master's thesis courses at the Open University of Catalonia when developing complex software applications in the CSCL domain.The ultimate aim of the whole research is to yield effective CSCL software systems capable of supporting and enhancing the current on-line collaborative learning practices.     

Empirical comparison of three metrics suites for fault prediction in packages of object-oriented systems: A case study of Eclipse

Packages are important high-level organizational units for large object-oriented systems. Package-level metrics characterize the attributes of packages such as size, complexity, and coupling. There is a need for empirical evidence to support the collection of these metrics and using them as early indicators of some important external software quality attributes. In this paper, three suites of package-level metrics (Martin, MOOD and CK) are evaluated and compared empirically in predicting the number of pre-release faults and the number of post-release faults in packages. Eclipse, one of the largest open source systems, is used as a case study. The results indicate that the prediction models that are based on Martin suite are more accurate than those that are based on MOOD and CK suites across releases of Eclipse.     

一种基于BPEL的通用安全控制模块设计方法

随着面向服务架构(SOA)的提出,软件系统的整合与开发速度将越来越快,但软件系统的安全机制却是每次开发时都需要重新建立,并且随着软件系统日益增多,安全机制的复杂程度将不断提升。提出一种基于商业流程执行语言(BPEL)的通用安全控制模块设计方法,以减少相应的权限开发与管理工作,同时还以制造业企业资源计划系统（ERP）与电子商务系统账户整合为例说明权限模块的运行机制。     

An object-oriented framework for modeling and designing intelligent training systems

The use of a software engineering approach in the design and development of Intelligent Training/teaching Systems (ITS) can increase productivity and improve the quality of the resulting software systems. In this paper, we describe an object-oriented framework for modeling and designing an ITS. This framework is based on software engineering principles. To illustrate our discussion, we consider an ITS—the CAD Demonstrator—which we have designed using this framework. © 1997 John Wiley & Sons, Ltd.     

Documenting after the fact: Recovering architectural design decisions

Software architecture documentation helps people in understanding the software architecture of a system. In practice, software architectures are often documented after the fact, i.e. they are maintained or created after most of the design decisions have been made and implemented. To keep the architecture documentation up-to-date an architect needs to recover and describe these decisions.This paper presents ADDRA, an approach an architect can use for recovering architectural design decisions after the fact. ADDRA uses architectural deltas to provide the architect with clues about these design decisions. This allows the architect to systematically recover and document relevant architectural design decisions. The recovered architectural design decisions improve the documentation of the architecture, which increases traceability, communication, and general understanding of a system.     

一种软件体系结构设计决策的建模工具

体系结构设计在整个软件生命周期中起到关键作用,而设计知识的蒸发会导致系统演化花费代价高、涉众之间交流出现障碍、体系结构制品的复用受到限制等问题,为此需要在软件体系结构层次对设计决策进行显式化的建模.基于一种以决策为中心的体系结构设计方法,实现了一个软件体系结构设计决策的建模工具.该工具帮助架构师对体系结构设计中的问题、方案、决策、理由等核心概念进行建模,完成从需求到体系结构的设计过程,并实现了自动化的候选体系结构方案的合成和部分设计理由的捕捉.该工具还提供了体系结构设计模型与设计决策之间的相互追踪性,以及帮助实现体系结构设计过程中设计决策知识的复用.     

A method to elicit architecturally sensitive usability requirements: its integration into a software development process

In the Human-Computer Interaction (HCI) community, software usability has primarily been concerned with the presentation of information, more precisely with the user interface. However, some usability problems can prove costly to fix if the changes require modifications that reach beyond the presentation layer, namely those that cannot be easily accommodated by the software architecture. Taking into account some usability requirements earlier in the software development cycle, specifically prior to the architectural design phase, can reduce the cost of these modifications. There is a scarcity of methods and guidelines with the scope to direct users in eliciting the usability requirements that can impact the software architecture. This paper proposes a usability-driven adaptation of the quality attribute workshop (QAW) to assist software development organizations in discovering and documenting usability requirements. It shows how this method can be integrated into a software development process, by discussing how the existing software framework workflows can be adjusted to take this new activity into consideration. A preliminary exercise was conducted to help discern the utility and the limits of the proposed method. Participants with different levels of knowledge of usability and comprehension of the system being developed found the method constructive, as it guided them in identifying the architecturally relevant usability requirements. It also helped determine the usability aspects that would not necessarily have been defined if this technique had not been employed.     

A graph mining approach for detecting identical design structures in object-oriented design models

The object-oriented approach has been the most popular software design methodology for the past twenty-five years. Several design patterns and principles are defined to improve the design quality of object-oriented software systems. In addition, designers can use unique design motifs that are designed for the specific application domains. Another commonly used technique is cloning and modifying some parts of the software while creating new modules. Therefore, object-oriented programs can include many identical design structures. This work proposes a sub-graph mining-based approach for detecting identical design structures in object-oriented systems. By identifying and analyzing these structures, we can obtain useful information about the design, such as commonly-used design patterns, most frequent design defects, domain-specific patterns, and reused design clones, which could help developers to improve their knowledge about the software architecture. Furthermore, problematic parts of frequent identical design structures are appropriate refactoring opportunities because they affect multiple areas of the architecture. Experiments with several open-source and industrial projects show that we can successfully find many identical design structures within a project (intra-project) and between different projects (inter-project). We observe that usually most of the detected identical structures are an implementation of common design patterns; however, we also detect various anti-patterns, domain-specific patterns, reused design parts and design-level clones.