Investigating the Effect of Software Packaging on Modular Structure Stability

In object-oriented development, packages form the basic modular structural components of large-scale software systems. Packaging processes aim to group classes together to provide well-identified functions/services to the rest of the system. In this context, it is widely believed that packaging quality has an influence on the software stability so that it should be useful predictors for modular structural stability. In this paper, we investigate the effect of packaging configurations on the modular structure stability of object-oriented systems. Using genetic algorithms, we conducted a series of experiments to find the relation between the packaging quality and modular structure stability. We conducted experiments on open source systems using an automatic packaging approach recently proposed by the authors. Results show that the stability of releases automatically packaged using that approach was better or at least comparable to those of the corresponding original releases manually packaged by the software developers. Moreover, the different parameters settings of the genetic algorithms used in our experiments play an important role to improve the overall quality. The experimental results suggest that the considered packaging approach is useful for practitioners to develop architecturally stable software systems.     

一种基于中间件的可信软件保护模型

软件的可信性是可信计算的研究热点之一。首先描述了可信计算平台和可信平台模块的基本概念,接着结合安全中间件和可信计算模型,在现有的PC体系结构下,提出了一种具体的基于中间件的可信软件保护模型,着重介绍了新模型的体系结构和系统组成,最后通过实例对软件保护机制进行了详细的说明。新模型具有通用性强和易于实现的特点,对于软件可信性保证的研究以及软件可信保护系统的建立具有一定的意义。     

Function-class decomposition: a hybrid software engineering method

In addition to offering a simple yet powerful method for decomposing a system, function-class decomposition (FCD) produces an architecture that is more supportive than traditional object-oriented decomposition for several software engineering tasks. A hybrid method that integrates structured analysis with an OO approach, FCD identifies classes in parallel with decomposing the system into a hierarchy of functional modules. Recently, developers extended FCD to integrate UML concepts. Useful for partitioning a system for distribution, the FCD hierarchy provides a framework for controlling development in a distributed software engineering environment. It also helps identify and integrate components in component-based development and supports the system life-cycle maintenance phase. Further, FCD addresses many of the initial analysis and design problems inherent in large and complex OO systems. The authors' experience with testing FCD on several applications validates its compatibility with OO methodologies and modeling techniques     

基于依赖关系的模块变更概率度量：一个实验分析

模块变更预测对于面向对象软件的开发和维护工作具有重要意义。针对软件的模块变更预测问题,首先在软件类之间依赖关系的基础上提出了一种轻量级的模块变更概率计算方法,然后利用Logistic回归模型对Eclipse 2.0系统进行了实验分析。实验结果表明：一方面,基于依赖关系的模块变更概率度量捕获了与传统面向对象度量不同的信息;另一方面,当与传统的面向对象度量一起使用时,它们能够在统计意义上显著地提高模块变更预测的准确性。     

A Hybrid Set of Complexity Metrics for Large-Scale Object-Oriented Software Systems

Large-scale object-oriented (OO) software systems have recently been found to share global network characteristics such as small world and scale free, which go beyond the scope of traditional software measurement and assessment methodologies. To measure the complexity at various levels of granularity, namely graph, class (and object) and source code, we propose a hierarchical set of metrics in terms of coupling and cohesion — the most important characteristics of software, and analyze a sample of 12 open-source OO software systems to empirically validate the set. Experimental results of the correlations between cross-level metrics indicate that the graph measures of our set complement traditional software metrics well from the viewpoint of network thinking, and provide more effective information about fault-prone classes in practice.     

Learning from optimization: A case study with Apache Ant

ContextSoftware architecture degrades when changes violating the design-time architectural intents are imposed on the software throughout its life cycle. Such phenomenon is called architecture erosion. When changes are not controlled, erosion makes maintenance harder and negatively affects software evolution.ObjectiveTo study the effects of architecture erosion on a large software project and determine whether search-based module clustering might reduce the conceptual distance between the current architecture and the design-time one.MethodTo run an exploratory study with Apache Ant. First, we characterize Ant’s evolution in terms of size, change dispersion, cohesion, and coupling metrics, highlighting the potential introduction of architecture and code-level problems that might affect the cost of changing the system. Then, we reorganize the distribution of Ant’s classes using a heuristic search approach, intending to re-emerge its design-time architecture.ResultsIn characterizing the system, we observed that its original, simple design was lost due to maintenance and the addition of new features. In optimizing its architecture, we found that current models used to drive search-based software module clustering produce complex designs, which maximize the characteristics driving optimization while producing class distributions that would hardly be acceptable to developers maintaining Ant.ConclusionThe structural perspective promoted by the coupling and cohesion metrics precludes observing the adequate software module clustering from the perspective of software engineers when considering a large open source system. Our analysis adds evidence to the criticism of the dogma of driving design towards high cohesion and low coupling, at the same time observing the need for better models to drive design decisions. Apart from that, we see SBSE as a learning tool, allowing researchers to test Software Engineering models in extreme situations that would not be easily found in software projects.     

Semi-automated architectural abstraction specifications for supporting software evolution

In this paper we present an approach for supporting the semi-automated architectural abstraction of architectural models throughout the software life-cycle. It addresses the problem that the design and implementation of a software system often drift apart as software systems evolve, leading to architectural knowledge evaporation. Our approach provides concepts and tool support for the semi-automatic abstraction of architecture component and connector views from implemented systems and keeping the abstracted architecture models up-to-date during software evolution. In particular, we propose architecture abstraction concepts that are supported through a domain-specific language (DSL). Our main focus is on providing architectural abstraction specifications in the DSL that only need to be changed, if the architecture changes, but can tolerate non-architectural changes in the underlying source code. Once the software architect has defined an architectural abstraction in the DSL, we can automatically generate architectural component views from the source code using model-driven development (MDD) techniques and check whether architectural design constraints are fulfilled by these models. Our approach supports the automatic generation of traceability links between source code elements and architectural abstractions using MDD techniques to enable software architects to easily link between components and the source code elements that realize them. It enables software architects to compare different versions of the generated architectural component view with each other. We evaluate our research results by studying the evolution of architectural abstractions in different consecutive versions of five open source systems and by analyzing the performance of our approach in these cases.     

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.     

Coupling metrics for ontology-based system

Measuring system coupling is a commonly accepted software engineering practice associated with producing high-quality software products. Coupling metrics traditionally measure data passed across a module interface to determine couplings between modules in a given system. XML has become common in Internet-based application domains such as business-to-business and business-to-consumer applications, and has formed a basis for service-oriented architectures such as Web services and the Semantic Web. We therefore need new coupling metrics that address these systems' unique requirements. We propose a set of coupling metrics for ontology-based systems represented in OWL: the number of external classes (NEC), reference to external classes (REC), and referenced includes (RI). To collect these metrics, we use a standard XML-based parser. This research reflects a new type of coupling measurement for system development that defines coupling metrics based on ontology data and its structure.     

Customizing system software using OO frameworks

Today's applications have exploded in their diversity, but most operating systems are still general-purpose and inefficient. One of the benefits of using an OO approach is the ability to modify very small details of an operating system, which makes it easy to tailor the system to the application. My experience indicates that optimizing an operating system for the general case can result in mediocre performance for specialized applications, especially parallel applications. Therefore, I envision a customizable operating system built from components that will allow an optimal match between application behavior and hardware architecture. I propose an object-oriented operating system in which design frameworks support alternative implementations of key systems software services     

A language-independent approach to the extraction of dependencies between source code entities

ContextSoftware networks are directed graphs of static dependencies between source code entities (functions, classes, modules, etc.). These structures can be used to investigate the complexity and evolution of large-scale software systems and to compute metrics associated with software design. The extraction of software networks is also the first step in reverse engineering activities.ObjectiveThe aim of this paper is to present SNEIPL, a novel approach to the extraction of software networks that is based on a language-independent, enriched concrete syntax tree representation of the source code.MethodThe applicability of the approach is demonstrated by the extraction of software networks representing real-world, medium to large software systems written in different languages which belong to different programming paradigms. To investigate the completeness and correctness of the approach, class collaboration networks (CCNs) extracted from real-world Java software systems are compared to CCNs obtained by other tools. Namely, we used Dependency Finder which extracts entity-level dependencies from Java bytecode, and Doxygen which realizes language-independent fuzzy parsing approach to dependency extraction. We also compared SNEIPL to fact extractors present in language-independent reverse engineering tools.ResultsOur approach to dependency extraction is validated on six real-world medium to large-scale software systems written in Java, Modula-2, and Delphi. The results of the comparative analysis involving ten Java software systems show that the networks formed by SNEIPL are highly similar to those formed by Dependency Finder and more precise than the comparable networks formed with the help of Doxygen. Regarding the comparison with language-independent reverse engineering tools, SNEIPL provides both language-independent extraction and representation of fact bases.ConclusionSNEIPL is a language-independent extractor of software networks and consequently enables language-independent network-based analysis of software systems, computation of design software metrics, and extraction of fact bases for reverse engineering activities.     

Emulating an operating system on top of another

In this paper, we present the design of an operating-system emulator. This software interface provides the services of one operating system (Oberon) on a machine running a different operating system (Macintosh), by mapping the functions of the first onto equivalent calls to the second. The construction of this emulator proceeded in four distinct phases, documented here through examples from each of these phases. We believe that our four-phase approach can be beneficial whenever a larger software system needs to be adapted from one architecture onto another. In conclusion, we relate some of the lessons learned and propose guidelines for similar engineering projects.     

基于Web服务的软件复用研究

软件复用技术是提高软件开发效率的重要方法,介绍了软件复用技术和Web Service的开放体系结构,提出了基于Web服务的软件复用方法,并针对如何确定Web服务的功能模块粒度提出了相应的解决方案。通过实际应用,证明了该解决方案能够有效地提高项目开发效率。     

Class movement and re-location: An empirical study of Java inheritance evolution

Inheritance is a fundamental feature of the Object-Oriented (OO) paradigm. It is used to promote extensibility and reuse in OO systems. Understanding how systems evolve, and specifically, trends in the movement and re-location of classes in OO hierarchies can help us understand and predict future maintenance effort. In this paper, we explore how and where new classes were added as well as where existing classes were deleted or moved across inheritance hierarchies from multiple versions of four Java systems. We observed first, that in one of the studied systems the same set of classes was continuously moved across the inheritance hierarchy. Second, in the same system, the most frequent changes were restricted to just one sub-part of the overall system. Third, that a maximum of three levels may be a threshold when using inheritance in a system; beyond this level very little activity was observed, supporting earlier theories that, beyond three levels, complexity becomes overwhelming. We also found evidence of ‘collapsing’ hierarchies to bring classes up to shallower levels. Finally, we found that larger classes and highly coupled classes were more frequently moved than smaller and less coupled classes. Statistical evidence supported the view that larger classes and highly coupled classes were less cohesive than smaller classes and lowly coupled classes and were thus more suitable candidates for being moved (within an hierarchy).     

A practical study of semi-automatic OSI protocol implementation

Communication protocols form a language which can be recognized by extended finite automata, and compiler generating tools can help with its implementation. This paper presents a project for implementing the ISO OSI layers which are most relevant to LANs. Taking advantage of modular and repetitive OSI architecture, a layer implementation model is proposed, introducing sharp distinctions between protocol layer-dependent and independent modules, so that the implementation effort can be largely reduced. It is also shown that layer-dependent modules can be generated automatically by using software tools developed for compiler construction. It is assumed that the protocols to be implemented have already been verified and validated in their abstract forms using other techniques, since these aspects are not covered by the method proposed. Measures of program sizes and execution speeds obtained following the approach proposed are reported; they show that most of the layer code can be produced by automatic tools and the overall software complexity enables the OSI architecture to be implemented for single-board microcomputers.     

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.     

电力企业信息统计系统逻辑构架研究与实现

软件构架在对可靠性、可移植性、安全性等性能要求比较高的软件开发过程中起着重要的作用.构架的好坏直接关系到系统的成功与否.根据实际需求,在设计中采用了模块视图分层风格,把系统的责任分解成小模块,使变更被隔离在一个模块内,大大提高了软件复用率,符合企业信息化的发展要求.     

On the evaluation of the Bunch search-based software modularization algorithm

The first part of this paper describes an automatic reverse engineering process to infer subsystem abstractions that are useful for a variety of software maintenance activities. This process is based on clustering the graph representing the modules and module-level dependencies found in the source code into abstract structures not in the source code called subsystems. The clustering process uses evolutionary algorithms to search through the enormous set of possible graph partitions, and is guided by a fitness function designed to measure the quality of individual graph partitions. The second part of this paper focuses on evaluating the results produced by our clustering technique. Our previous research has shown through both qualitative and quantitative studies that our clustering technique produces good results quickly and consistently. In this part of the paper we study the underlying structure of the search space of several open source systems. We also report on some interesting findings our analysis uncovered by comparing random graphs to graphs representing real software systems.     

面向模式的分布式软件构架可视化建模

主要阐述了面向模式的分布式软件构架的概念、原理和常用构架模式的特点。重点研究了提出的面向模式的软件构架建模语言、可视化建模工具的设计原理、功能及特点等,并以一个具体应用实例展示了该建模工具的实用性。     

An intelligent intrusion detection system (IDS) for anomaly and misuse detection in computer networks

In this paper, we propose a novel Intrusion Detection System (IDS) architecture utilizing both anomaly and misuse detection approaches. This hybrid Intrusion Detection System architecture consists of an anomaly detection module, a misuse detection module and a decision support system combining the results of these two detection modules. The proposed anomaly detection module uses a Self-Organizing Map (SOM) structure to model normal behavior. Deviation from the normal behavior is classified as an attack. The proposed misuse detection module uses J.48 decision tree algorithm to classify various types of attacks. The principle interest of this work is to benchmark the performance of the proposed hybrid IDS architecture by using KDD Cup 99 Data Set, the benchmark dataset used by IDS researchers. A rule-based Decision Support System (DSS) is also developed for interpreting the results of both anomaly and misuse detection modules. Simulation results of both anomaly and misuse detection modules based on the KDD 99 Data Set are given. It is observed that the proposed hybrid approach gives better performance over individual approaches.