Scalable Techniques for Modeling Software Interconnectivity

The modular design maximizes utility by employing standardized rather than customized components in large-scale systems. From a manufacturing view, this approach contributes to green technology by reducing material waste and enhancing component reusability. Additionally, from an industrial view, it offers significant economic advantages by leveraging economies of scale, making it a highly reasonable strategy. Modularization is generally achieved by selecting a representative design that satisfies all required performance from a predefined set of designs. However, achieving effective modularization in mechanical mechanism systems presents additional challenges. First, mechanisms depend on geometric relationships, and varying loads yield different optimal designs. Second, selecting a single design to cover all conditions for modularization inherently results in an over-specified solution. This results in inevitable performance deviations, which become pronounced as the design scale increases. To address these challenges, a modular mechanism design framework based on surrogate-based design optimization is proposed. Surrogate-based optimization is utilized to obtain optimal design solutions for each condition in large-scale engineering systems. The generated optimal designs are partitioned into multiple groups, each unified by a representative design covering all its conditions. Thus, it leads to a multi-objective optimization (MOO) problem that aims to maximize economies of scale while minimizing performance deviations. Unlike conventional approaches, which primarily rely on intuitive design candidates and simple grouping strategies, the proposed framework generates optimal solutions directly, enabling the selection of optimal layouts. Additionally, it analyzes manufacturing cost parameters to support strategy selection for various design scenarios. This approach enhances maintainability and promotes environmentally sustainable manufacturing.

In large-scale software systems that integrate many components originating from different vendors, the understanding of the functional importance of the components is critical for the dependability of the system. However, in general, gaining such understanding is difficult. Here we describe the application of the combination of dynamic analysis and network analysis to large-scale software systems with the aim to determine methods of classes that are functionally important with respect to a given functionality of the software. We use as a test case the Google Chrome and predict functionally important methods in a weak sense in the context of usage scenarios. We validate the predictions using mutation testing and evaluate the behavior of the software following the mutation change. Our results indicate that network analysis metrics based on measurement of structural integrity can be used to predict methods of classes that are functionally important with respect to a given functionality of the software system.

Since modern software systems are large and complex, appropriate abstractions of their structure are needed to make them more understandable and, thus, easier to maintain. Software clustering techniques are useful to support the creation of these abstractions by producing architectural-level views of a system's structure directly from its source code. This paper examines the Bunch clustering system which, unlike other software clustering tools, uses search techniques to perform clustering. Bunch produces a subsystem decomposition by partitioning a graph of the entities (e.g., classes) and relations (e.g., function calls) in the source code. Bunch uses a fitness function to evaluate the quality of graph partitions and uses search algorithms to find a satisfactory solution. This paper presents a case study to demonstrate how Bunch can be used to create views of the structure of significant software systems. This paper also outlines research to evaluate the software clustering results produced by Bunch.

Feature models are frequently used to capture the knowledge about configurable software systems and product lines. However, feature modeling of large-scale systems is challenging as many models are needed for diverse purposes. For instance, feature models can be used to reflect the perspectives of product management, technical solution architecture, or product configuration. Furthermore, models are required at different levels of granularity. Although numerous approaches and tools are available, it remains hard to define the purpose, scope, and granularity of feature models. In this paper we thus present experiences of developing feature models for two large-scale industrial automation software systems. Specifically, we extended an existing feature modeling tool to support models for different purposes and at multiple levels. We report results on the characteristics and modularity of the feature models, including metrics about model dependencies. We further discuss lessons learned during the modeling process.

The DSP based longitudinal multi-bunch feedback system is being developed at SRRC. Various operation modes are supported for feedback and diagnostic. The feedback system consists of a digital signal processor array to execute feedback algorithm and to provide raw data for diagnostic purposes. Simulation tools are used to aid control rule development. Software components of feedback system include feedback control rules and data acquisition in DSPs, system resources management at VME host, signal analysis and simulation in console. Hardware structure includes of front end and back end electronics, timing circuitry. In order to develop, commissioning and operate longitudinal feedback system efficiently, an integrated software environment has been developed. The commercial off-the-shelf product solution was selected in DSP environment. Network based DSP development environment provide a convenient way to code debug, beam test, and operate the feedback system. System simulate tools on console computer is integrated with SRRC control system which offer a simple way to interface the feedback system. System structure and development status will be summaries in following paragraph.

i»? A. A. Helal, A. A. Heddaya, and B. B. Bhargrava Kluwer Academic Publishers, Boston, 1996, 176 pp. ISBN 0-7923-9800-9, $118.50 Computing in the 1990s has reached the state of distributed computing. A basis of this form of computing is a distributed computing system, which is built on the following three components: (a) personal computers, (b) local and fast wide area networks, and (c) system and application software. By amalgamating computers and networks into one single computing system and providing an appropriate system software, a distributed computing system has created the possibility of sharing information and peripheral resources. Furthermore, these systems improved performance of a computing system and individual users through parallel execution of programs, load balancing and sharing, and replication of programs and data. Distributed computing systems are also characterized by enhanced availability, and increased reliability. Replication is the key to providing high availability, fault tolerance, and enhanced performance in a distributed computing system. As companies move toward systems that are more open and distributed, replication is becoming increasingly important in the ability to provide data and services that are current, correct and available, which is a key factor in maintaining a competitive advantage over rivals. However, replication has also generated some serious challenges. For example, when a replica is updated, how do we propagate such an update to other replicas? If multiple replicas are updated simultaneously and some of the updates conflict one another, how do we resolve the conflict? How do we deal with the situation where a replica is down and then subsequently recovered? How do we deal with network partitions? Not surprisingly, considerable research efforts have been directed towards the solution of these challenges. However, most of the research results are scattered among many journals, conference proceedings, theses, and technical reports. The book by Helal, Heddaya and Bhargava has gathered the best material of these research results and formed a coherent collection that includes definitions, theoretical background, algorithms, annotated bibliographies of commercial and experimental prototype systems, and more than 200 references. This book classifies the entities that can be replicated on a distributed computing system into the following categories: (a) data, (b) process, (c) objects, and (d) messages. After the introduction on the goals and main approaches of replication techniques, the book uses individual chapters to describe major methods for each of the above replication categories. The main focus of this part, however, is on the replication of data. The book also contains two chapters on the replication issues in heterogeneous, mobile, and large-scale systems, and on the future of replication techniques. Apart from the normal chapters, the book contains a rich set of appendices that are very useful for further studies of replication techniques. These appendices include brief descriptions of two dozen commercial and experimental systems that use replication techniques, annotated bibliographies of selected literature on various topics of replication, and an introduction on serializability theory. Each annotated bibliography contains an overview of the specific topic and is written by an invited expert in that field. The combination of the normal chapters and appendices cover the entire spectrum of replication, from definitions, concepts, theories, algorithms, techniques, to systems. The book serves as an excellent introduction and roadmap to the issues of replication. Although it does not provide a detailed description of every replication techniques and systems, the book covers most of the fundamental work that allows the reader to understand the roots of these techniques and systems, and to find the ways to search for the details. This book is a valuable reference book for anyone studying replication techniques or implementing replication systems, specifically, it can be very useful to post-graduate students, practitioners, and beginning researchers of this exciting field. Wanlei Zhou, School of Computing and Mathematics, Deakin University

The emergence of large scale systems provides solutions and poses new challenges to a number of existing problems covering a broad spectrum of applications. Among these problems, we are interested by exploring new approaches to integrate data in large scale systems. For this purpose, we propose a data integration framework that is data-structure-independent, allowing a high level of semantic interoperability. We describe the methods used in our framework to build an index regrouping all the clusters published data descriptions that are designed to fit the structure of a large scale system. This framework focuses on the properties of large scale systems such as multi-level heterogeneity and high degree of dynamicity and evolution.

Software systems play a key role in most businesses nowadays. Building robust, reliable and scalable software systems require going through a software production cycle (or process). However, it has been noticed that software systems are subjected to changes, whether those amendments are important or not. Those changes to software systems are viewed as a considerable issue in software engineering; they are considered as a burden and cost a lot, especially in cases such as enterprises and large-scale software systems. This study aims to identify the reasons that cause software changes and suggest remedies for those reasons. We survey the opinions of experts such as technical managers, team leaders, and senior developers. We collected 81 responses to our questionnaire, which aimed to establish common software development practices in the local industry. We also conducted 16 semi-structured interviews targeting the most senior experts, in which we directly discussed the reasons and remedies for software changes. Our results highlight the most influential reasons that cause changes to software systems, such as changes to user requirements, requests for new features, software development methodology, solving bugs, refactoring, and weak user experience design. Most importantly, the study solicited solutions that can reduce the need for software changes

To assure high software quality for large-scale industrial software systems, traditional approaches of software quality assurance, such as software testing and performance engineering, have been widely used within Alibaba, the world's largest retailer, and one of the largest Internet companies in the world. However, there still exists a high demand for software quality assessment to achieve high sustainability of business growth and engineering culture in Alibaba. To address this issue, we develop an industrial solution for software quality assessment by following the GQM paradigm in an industrial setting. Moreover, we integrate multiple assessment methods into our solution, ranging from metric selection to rating aggregation. Our solution has been implemented, deployed, and adopted at Alibaba: (1) used by Alibaba's Business Platform Unit to continually monitor the quality for 60+ core software systems; (2) used by Alibaba's R&D Efficiency Unit to support group-wide quality-aware code search and automatic code inspection. This paper presents our proposed industrial solution, including its techniques and industrial adoption, along with the lessons learned during the development and deployment of our solution.

In the past few years, research has been actively carried out in an attempt to improve the quality and reliability of large-scale software systems. Although progress has been made on the formal proof of program correctness, proving large-scale software systems correct by formal proof is still many years away. Automated software tools have been found to be valuable in improving software reliability and attacking the high cost of software systems. This paper attempts to describe some main features of automated software tools and some software evaluation systems that are currently available.

As the evolution of applications, software systems become more and more complex. However, it is a challenge to deliver easy-to-use and reliable large-scale distributed software systems. This paper first reviews current requirements on software systems and the progress made and then reports our effort in delivering a more usable and reliable large-scale distributed software development framework (iFrame) to support e-research. Bearing human collaboration in the first place, iFrame synthesizes peer-to-peer (P2P), service-oriented architecture (SOA), Web 2.0 and semantic Web into grid: P2P is deployed to construct an interconnected environment to enhance reliability and scalability, SOA and semantic Web are exploited to deliver concrete business functionality and prompt interoperability, whereas Web 2.0 is utilized to devise more usable interface.

The knowledge representation of software component relations using nonmonotonic logic to assist the validity and integrity checking of software information is presented. Software components and their interconnection information are represented by axioms that exhibit the structure and behavior of the software system. Another set of axioms represents the basic truisms about a software system in general. These axioms can easily be extended to cover a wide variety of software systems architectures. In the software development and maintenance phases, information about the software system can be derived from these axioms using an automated reasoning system, and the software system itself can easily be checked against a specification of the system and compared for validity. This knowledge-based system will provide programmers with useful software information and assist the software development and maintenance process. >

Software systems are important components for the deployment and operation of large-scale critical systems, such as nuclear plants and aerospace shuttles. The very high reliability is critically required. Due to the very large scale and computational complexity, however, there are some inherent challenges for conducting extensive testing. In this paper, we define such challenges in the testing scope of large-scale critical software. The paper presents the testing workflows and coverage, the mechanism of random testing, followed by the automated testing framework. We then present the implementing details of the automated testing platform ATLAS.

The purpose of this study was to identify fault-prone functions that are likely to contain faults in a given software system. Five metrics were used: Di, an internal design metric which incorporates factors related to a function's internal structure; De, an external design metric which focuses on a function's external relationships to the rest of the software system; D(G), a composite design metric which is a linear combination of Di and De; and the union and intersection of Di, De, and D(G). Since the system being considered was already developed, a very important aspect of our study was to extract the design information directly from the source code rather than from the corresponding design documentation which may not exist or, if it does exist, it may be incomplete, difficult to understand, or not updated. To make the analysis more accurate and efficient, a metric analysis tool (χMetrics) was implemented. We conducted experiments using χMetrics on part of a distributed software system, written in C, with a client–server architecture, and identified a small percentage of its functions as good candidates for fault-proneness. Files containing these functions were then validated by the real defect data collected between a recent major release and its subsequent release for their fault-proneness. The results indicate that our metrics are good indicators of fault-prone functions. Two extra experiments were also conducted to show that function size cannot replace any of our metrics; and where the function size was factored out our metrics performed better than the normalized metrics. The important benefit of our metrics is that they help project managers determine where additional testing effort should be spent and possibly which fault-prone functions should be assigned to more experienced programmers if modifications are required. Copyright © 2000 John Wiley & Sons, Ltd.

This essay summarizes an inquiry that explores relations between the structure of stratified systems and the processes of vertical mobility. The inquiry considers economic stratification (the distribution of wealth) and is directed to determining whether the structural properties of stratification systems are sufficient to generate basic patterns in vertical mobility observed in empirical research, especially, the rank‐distance effect. In particular, the question is whether these patterns can be generated even if movement is constrained by nothing more than the size of the population over which wealth is distributed and the total amount of wealth to be distributed. Our results show that the rank‐distance effect emerges even under these minimal assumptions and, further, that rates and distances of vertical mobility are closely related to changes in these boundary parameters of a stratified system. The basic theory developed to relate structure and mobility provides results that are highly consistent with many empirical observations. It also challenges existing claims concerning the nature of the mechanisms determining the relative status immobility of most people in large scale systems. The theory implies that the way in which system structure constrains opportunity for movement is, by itself, sufficient to produce this result and others commonly observed.