一种基于层次聚类的软件架构恢复方法

针对软件聚类侧重相似度测度而欠缺考虑实体和特征的特性的问题,提出一种基于层次聚类的软件架构恢复方法(HCSAR)。该方法有针对性地选取实体和特征,提出特征的多重加权策略,采用信息丢失度作为相似度测度,选取和设计软件聚类的客观和主观评估准则。与目前效果较好的软件聚类方法相比,HCSAR在聚类中期能生成更多的簇,主观判定数更低,能够通过调整关注点获得不同的聚类结果,使用设计的评估准则分析聚类结果还能有效辅助系统划分。     

A learning-based module extraction method for object-oriented systems

Developers apply object-oriented (OO) design principles to produce modular, reusable software. Therefore, service-specific groups of related software classes called modules arise in OO systems. Extracting the modules is critical for better software comprehension, efficient architecture recovery, determination of service candidates to migrate legacy software to a service-oriented architecture, and transportation of such services to cloud-based distributed systems. In this study, we propose a novel approach to automatic module extraction to identify services in OO software systems. In our approach, first we create a weighted and directed graph of the software system in which vertices and edges represent the classes and their relations, respectively. Then, we apply a clustering algorithm over the graph to extract the modules. We calculate the weight of an edge by considering its probability of being within a module or between modules. To estimate these positional probabilities, we propose a machine-learning-based classification system that we train with data gathered from a real-world OO reference system. We have implemented an automatic module extraction tool and evaluated the proposed approach on several open-source and industrial projects. The experimental results show that the proposed approach generates highly accurate decompositions that are close to authoritative module structures and outperforms existing methods.     

Weighing lexical information for software clustering in the context of architecture recovery

In this paper, we present a software clustering approach that leverages the information conveyed by the zone in which each lexeme appears in the classes of object oriented systems. We define six zones in the source code: Class Name, Attribute Name, Method Name, Parameter Name, Comment, and Source Code Statement. These zones may convey information with different levels of relevance, and so their contribution should be differently weighed according to the software system under study. To this aim, we define a probabilistic model of the lexemes distribution whose parameters are automatically estimated by the Expectation-Maximization algorithm. The weights of the zones are then exploited to compute similarities among source code classes, which are then grouped by a k-Medoid clustering algorithm. To assess the validity of our solution in the software architecture recovery field, we applied our approach to 19 software systems from different application domains. We observed that the use of our probabilistic model and the defined zones improves the quality of clustering results so that they are close to a theoretical upper bound we have proved.     

Software-as-a-service （SaaS）： perspectives and challenges

Software-as-a-service （SaaS） has received significant attention recently as one of three principal components of cloud computing, and it often deals with applications that run on top of a platform-as-a-service （PaaS） that in turn runs on top of infrastructure-as-a-service （IaaS）. This paper provides an overview of SaaS including its architecture and major technical issues such as customization, multi-tenancy architecture, redun- dancy and recovery mechanisms, and scalability. Specifically, a SaaS system can have architecture relating to a database-oriented approach, middleware-oriented approach, service-oriented approach, or PaaS-oriented ap- proach. Various SaaS customization strategies can be used from light customization with manual coding to heavy customization where the SaaS system and its underlying PaaS systems are customized together. Multi-tenancy architecture is an important feature of a SaaS and various trade-offs including security isolation, performance, and engineering effort need to be considered. It is important for a SaaS system to have multi-level redundancy and recovery mechanisms, and the SaaS system needs to coordinate these with the underlying PaaS system. Finally, SaaS scalability mechanisms include a multi-level architecture with load balancers, automated data migration, and software design strategies.     

插件技术在控制系统中的应用

对一种构件复用技术的总线、接口和插件的构造进行了详细的描述，并采用该插件技术实现了控制系统中对多种不同设备的支持，方便了设备的管理，延长了软件的生命周期。     

Efficient software clustering technique using an adaptive and preventive dendrogram cutting approach

ContextSoftware clustering is a key technique that is used in reverse engineering to recover a high-level abstraction of the software in the case of limited resources. Very limited research has explicitly discussed the problem of finding the optimum set of clusters in the design and how to penalize for the formation of singleton clusters during clustering.ObjectiveThis paper attempts to enhance the existing agglomerative clustering algorithms by introducing a complementary mechanism. To solve the architecture recovery problem, the proposed approach focuses on minimizing redundant effort and penalizing for the formation of singleton clusters during clustering while maintaining the integrity of the results.MethodAn automated solution for cutting a dendrogram that is based on least-squares regression is presented in order to find the best cut level. A dendrogram is a tree diagram that shows the taxonomic relationships of clusters of software entities. Moreover, a factor to penalize clusters that will form singletons is introduced in this paper. Simulations were performed on two open-source projects. The proposed approach was compared against the exhaustive and highest gap dendrogram cutting methods, as well as two well-known cluster validity indices, namely, Dunn’s index and the Davies-Bouldin index.ResultsWhen comparing our clustering results against the original package diagram, our approach achieved an average accuracy rate of 90.07% from two simulations after the utility classes were removed. The utility classes in the source code affect the accuracy of the software clustering, owing to its omnipresent behavior. The proposed approach also successfully penalized the formation of singleton clusters during clustering.ConclusionThe evaluation indicates that the proposed approach can enhance the quality of the clustering results by guiding software maintainers through the cutting point selection process. The proposed approach can be used as a complementary mechanism to improve the effectiveness of existing clustering algorithms.     

Integration of a flat holonic form in an HLA environment

Managers need to create and sustain internal systems and controls to ensure that their customer focused strategies are being implemented. Companies are currently in a spiral of permanent optimization. Accordingly, many companies turn to their core activity. In this framework, one notices the development of the concept of “industrial partnership”. In this context and to control the customer–supplier relationships (CSR), we proposed a self-organized control model in which all partner entities (customers/suppliers) negotiate to guarantee good quality connections between customers and suppliers. This means meeting customer expectations as closely as possible and respecting supplier capacities. In this proposal, self-organized control is characterized more precisely by an organizational architecture of the flat holonic form type. This flat holonic form is based on the concept of autonomous control entity (ACE). The holonic architecture, the behaviour of an ACE, the interaction mechanisms between ACEs and the self-evaluation supplier process are presented, and then the modelling of ACEs using discrete event system specification (DEVS) is described. An implementation of the simulation of such a system was done via a distributed simulation environment high level architecture (HLA). A case study illustrating the proposed approach is presented.     

Protection of heterogeneous architectures on FPGAs: An approach based on hardware firewalls

Embedded systems are parts of our daily life and used in many fields. They can be found in smartphones or in modern cars including GPS, light/rain sensors and other electronic assistance mechanisms. These systems may handle sensitive data (such as credit card numbers, critical information about the host system and so on) which must be protected against external attacks as these data may be transmitted through a communication link where attackers can connect to extract sensitive information or inject malicious code within the system. This work presents an approach to protect communications in multiprocessor architectures. This approach is based on hardware security enhancements acting as firewalls. These firewalls filter all data going through the system communication bus and an additional flexible cryptographic block aims to protect external memory from attacks. Benefits of our approach are demonstrated using a case study and some custom software applications implemented in a Field-Programmable Gate Array (FPGA). Firewalls implemented in the target architecture allow getting a low-latency security layer with flexible cryptographic features. To illustrate the benefit of such a solution, implementations are discussed for different MPSoCs implemented on Xilinx Virtex-6 FPGAs. Results demonstrate a reduction up to 33% in terms of latency overhead compared to existing efforts.     

Towards Software Architecture and Mechanisms for Improving Runtime Variability of Internetware System

As an emerging software paradigm, Internetware is proposed to handle openness, dynamism of software systems in the context of Internet, which implies that such software systems typically have runtime variability that can be improved dynamically to handle various or even unexpected changes of requirements and open environment. Though many progresses of Internetware software technologies have been made to support the adaptation, evolution, context-awareness, etc. of Internetware, how to construct Internetware systems with the ability to improve their runtime variability is still a great challenge in the literature of software engineering. In this paper, we propose software architecture and mechanisms for Internetware systems to support the improvement of their runtime variability by combining software variability and autonomic computing techniques. The Internetware system is organized as three levels that are consist of variable autonomic elements and Internetware entities, and architecture of these software entities is defined and discussed respectively. Moreover, we put forward a series of runtime mechanisms based on these levels, including module selection, intermediator and horizontal management, to realize operations upon the variation points and variants in software architectures and thus achieve the improvement of runtime variability. We develop a sample of Personal Data Resource Network to depict the requirements and scenario of improving runtime variability, and further study the case based on our proposed approach to show its effectiveness and applicability.     

Modeling and simulating software acquisition process architectures

In this paper, we describe our efforts to support the modeling and simulation of processes associated with software system acquisition activities. Software acquisition is generally a multi-organization endeavor concerned with the funding, management, engineering, system integration, deployment and long-term support of large software systems. We first describe our approach supporting the modeling and simulation of software acquisition processes using a software process architecture (SPA). We then introduce how we support the distribution, concurrent execution and interoperation of multiple software process simulations using the high-level architecture (HLA) and run-time infrastructure (RTI) to address the complexity of software acquisition process architectures. To illustrate this, we provide examples from the design and prototyping of a Web-based environment that supports the modeling and simulation of acquisition process architectures. This environment thus serves as a new kind of software process test-bed that can demonstrate and support experiments incorporating multiple software process simulation systems that interoperate in a distributed and concurrent manner across a network.     

What your plug-in test suites really test: an integration perspective on test suite understanding

Software architectures such as plug-in and service-oriented architectures enable developers to build extensible software products, whose functionality can be enriched by adding or configuring components. A well-known example of such an architecture is Eclipse, best known for its use to create a series of extensible IDEs. Although such architectures give users and developers a great deal of flexibility to create new products, the complexity of the built systems increases. In order to manage this complexity developers use extensive automated test suites. Unfortunately, current testing tools offer little insight in which of the many possible combinations of components and components configurations are actually tested. The goal of this paper is to remedy this problem. To that end, we interview 25 professional developers on the problems they experience in test suite understanding for plug-in architectures. The findings have been incorporated in five architectural views that provide an extensibility perspective on plug-in-based systems and their test suites. The views combine static and dynamic information on plug-in dependencies, extension initialization, extension and service usage, and the test suites. The views have been implemented in ETSE, the Eclipse Plug-in Test Suite Exploration tool. We evaluate the proposed views by analyzing eGit, Mylyn, and a Mylyn connector.     

Applications of clustering techniques to software partitioning,recovery and restructuring

The artifacts constituting a software system are sometimes unnecessarily coupled with one another or may drift over time. As a result, support of software partitioning, recovery, and restructuring is often necessary. This paper presents studies on applying the numerical taxonomy clustering technique to software applications. The objective is to facilitate those activities just mentioned and to improve design, evaluation and evolution. Numerical taxonomy is mathematically simple and yet it is a useful mechanism for component clustering and software partitioning. The technique can be applied at various levels of abstraction or to different software life-cycle phases. We have applied the technique to: (1) software partitioning at the software architecture design phase; (2) grouping of components based on the source code to recover the software architecture in the reverse engineering process; (3) restructuring of a software to support evolution in the maintenance stage; and (4) improving cohesion and reducing coupling for source code. In this paper, we provide an introduction to the numerical taxonomy, discuss our experiences in applying the approach to various areas, and relate the technique to the context of similar work.     

基于BP神经网络的软件可靠性模型选择

软件可靠性模型是软件可靠性工程研究的一个重要方面.如何在缺乏可靠性数据的情况下,选择合适的软件可靠性模型是对软件可靠性进行量化分析的关键.参照软件可靠性模型评价准则,根据聚类思想,对失效数据编码,采用反向传播神经网络进行聚类计算,从而实现了软件可靠性模型的选择.最后通过仿真实验证明了该方法的正确性和有效性.     

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.     

基于MVC架构的数据挖掘平台的设计与实现

为了增强数据挖掘软件各功能模块的可扩展性和复用性,分析了现有数据挖掘工具的优缺点,并综合考虑数据挖掘过程的实际特点,提出了一个基于MVC架构的数据挖掘平台设计方案.在此基础上,利用Eclipse plug-in,RCP,GEF等技术,实现了一个数据挖掘平台原型系统.该平台遵循CRISP-DM过程标准,在软件架构上实现了低耦合、高复用,为用户提供了一个友好、灵活、易重用、可扩展的数据挖掘应用环境.     

Maintaining Configurations of Evolving Software Systems

Software configuration management ( SCM) is an emerging discipline. An important aspect of realizing SCM is the task of maintaining the configurations of evolving software systems. In this paper, we provide an approach to resolving some of the conceptual and technical problems in maintaining configurations of evolving software systems. The approach provides a formal basis for existing notions of system architecture. The formal properties of this view of configurations provide the underpinnings for a rigorous notion of system integrity, and mechanisms to control the evolution of configurations. This approach is embodied in a language, NuMIL, to describe software system configurations, and a prototype environment to maintain software system configurations. We believe that the approach and the prototype environment offer a firm base to maintain software system configurations and, therefore, to implement SCM.     

用改进的遗传算法实现架构恢复

高层架构恢复对软件维护和软件进化至关重要.把实现架构恢复的聚类问题看作优化问题,通过对常规遗传算法中初始群体产生策略、选择操作方法、交叉概率和变异概率的自适应性等重要参数和关键环节的改进,设计并实现了混合遗传聚类算法(hybrid genetic clustering algorithm,简称HGCA).同时也对该算法的有效性和综合性能进行了实验分析,结果表明,该算法对初始群体的产生有较好的约束作用.与传统遗传算法相比,它的群体性能和收敛性能都较优,且收敛精度高.同时,基于MoJo度量模型的相似性度量值充分说明了HGCA算法对架构恢复的正确性和有效性.     

Exploring architecture blueprints for prioritizing critical code anomalies: Experiences and tool support

The manifestation of code anomalies in software systems often indicates symptoms of architecture degradation. Several approaches have been proposed to detect such anomalies in the source code. However, most of them fail to assist developers in prioritizing anomalies harmful to the software architecture of a system. This article presents an investigation on how developers, when supported by architecture blueprints, are able to prioritize architecturally relevant code anomalies. First, we performed a controlled experiment where participants explored both blueprints and source code to reveal architecturally relevant code anomalies. Although the use of blueprints has the potential to improve code anomaly prioritization, the participants often made several mistakes. We found these mistakes might occur because developers miss relationships between implementation and blueprint elements when they prioritize anomalies in an ad hoc manner. Furthermore, the time spent on the prioritization process was considerably high. Aiming to improve the accuracy and effectiveness of the process, we provided means to automate the prioritization process. In particular, we explored 3 prioritization criteria, which establish different ways of relating the blueprint elements with code anomalies. These criteria were implemented in the JSpIRIT tool. The approach was evaluated in the context of 2 applications with satisfactory precision results.