Search

Design patterns are reusable software design solutions to object-oriented programs. Since the initial introduction of the 23 well-known design patterns in 1995, more and more patterns have been identified and utilized in the software industry. The benefits of applying design patterns include reducing development cost, improving code quality, and standardizing the integration and maintenance processes. Therefore, using design patterns is becoming a common practice to build both commercial software and open-source products. Although most design patterns are considered creative solutions to some difficult design problems, not all of them are necessarily the best with respect to all different software quality measures, such as program complexity. This paper studies 13 commonly employed design patterns in software industry. First, these 13 patterns are analyzed theoretically about their design complexity in comparison to the conventional solutions. Second, empirical studies are performed on five open-source Java projects to investigate the correlations between design patterns and class structural quality. Finally, these 13 design patterns are evaluated by software programmers who have experience of using all of them. Overall, this study finds that although some design patterns are considered useful, creative, and significant compared to conventional solutions based on user experience, pattern-involved classes are more complex than pattern-free classes, both theoretically and empirically. The authors accordingly recommend a balanced approach to using design patterns: design quality, cost, development time, and product quality should all be considered, when design patterns are utilized.

In C-alike programs, the source code is separated into header files and source files. During the software evolution process, both these two kinds of files need to adapt to changing requirement and changing environment. This paper studies the coevolution of header files and source files of C-alike programs. Using normalized compression distance that is derived from Kolmogorov complexity, we measure the header file difference and source file difference between versions of an evolving software product. Header files distance and source files distance are compared to understand their difference in pace of evolution. Mantel tests are performed to investigate the correlation of header file evolution and source file evolution. The study is performed on the source code of Apache HTTP web server.

Scheduling is an important management activity in software projects. The relationship between nominal development time and development effort has been characterized as a power-law function where development time is dependent on development effort. Studies performed in 1980s determined that there is a scheduling barrier for any software project given the amount of effort to complete the project. Specifically, the studies found out that it is extremely difficult to reduce the development time lowering than a threshold calculated based on the nominal development time. Scheduling barriers are largely due to the complexity of interactions and communications among developers. Thirty years later, this paper examines six software projects in order to understand the relationship between development time and development effort in the 21st century. The author's study suggests that in modern software development, scheduling barriers could be broken through improving the efficiencies of communications, collaborations, and project management.

Android is an operating system for mobile devices. Its development is led by Google and some other companies. Because of the open-source property of Android, anyone can report a bug through its online bug tracking system. In this paper, we analyze the bug reports of Android operating systems. Specifically, through this study, we would like to answer the following questions regarding Android development and its project management: (1) Could Android bug reports be handled on time? (2) What is the distribution of different maintenance activities initiated by Android bug reports? (3) How long does it take to handle an Android bug report? (4) Are the number of followers and the number of following messages of an Android bug report related to the effort spent on handling this bug report? Through answering these questions, this paper presents a comprehensive study of Android bug reporting and handling process. The information and knowledge obtained through this case study could help us better understand open-source software project, such as its development process and project management.

This chapter describes the evolution of social networking together with its supporting technologies. Most popular social networking service providers, such as Facebook, Tencent, Twitter, and Sina Weibo are described with their market and financial data. The new business and new social relations built on social networking platforms are introduced and their impacts are discussed. The future trends of social networking are also illustrated based on the potential development of related emerging technologies. The objective of this chapter is to help readers understand the impact of technology on the functioning, evolution, and variation of socializations.

This paper describes the teaching methods and teaching experiences of an instructor who has been teaching computer science freshmen for more than ten years. Problem-based learning has been used in introductory programming courses to enhance the quality of learning. The common problem in introductory programming courses is that instructors quite often focus mainly on programming language syntax and usage but ignore the real world applications of these language features. Accordingly, students are likely to find out that it is difficult to apply their programming skills on solving complex problems in their high level courses. Through introducing problem-based learning in introductory programming courses, students not only could obtain experience of dealing with complex problems, but also could practice other soft skills, such as team working skills, which could better prepare them for junior and senior level coursework and capstone projects. In addition, other philosophy issues related to teaching introductory courses are discussed and tentative solutions are presented.

Software development is a fast-changing area. New methods and new technologies emerge all the time. As a result, the education of software engineering is generally considered not to be keeping pace with the development of software engineering in industry. Given the limited resources in academia, it is unrealistic to purchase all the latest software tools for classroom usage. In this chapter, the authors describe how free/open-source data and free/open-source tools are used in an upper-level software engineering class at Indiana University South Bend. Depending on different learning objectives, different free/open-source tools and free/open-source data are incorporated into different team projects. The approach has been applied for two semesters, where instructor’s experiences are assembled and analyzed. The study suggests (1) incorporating both free/open-source tools and free/open-source data in a software engineering course so that students can better understand both development methods and development processes and (2) updating software engineering course regularly in order to keep up with the advance of development tools and development methods in industry.

The engineering of enterprise software systems suffers from an inherent lack of creativity and innovation and is often left to user-centric incremental changes that are not often disruptive enough for business needs. A design-driven approach to systems creates opportunities for transformative evolution of such systems that are both immediate and futuristic in their impact. Software systems stability can be maintained and monitored during evolution utilizing architectural-level, program-level, and information-level stability metrics. Despite increasing complexities involved in the design, development, and testing of such large-scale software systems, they are often predicated by simple techniques for decomposition, generalization, and specification. However, as always they are much more difficult to merge back together in order to rationalize the entire architecture for the levels of confidence necessary during testing, deployment, and commissioning of these systems. mDSM, an extension to Design Structure Matrix (DSM) approach to software systems design and testing, is a methodology developed by the authors to address design-driven rationalization of such complex software system architectures.

Negative binomial regression has been proposed as an approach to predicting fault-prone software modules. However, little work has been reported to study the strength, weakness, and applicability of this method. In this paper, we present a deep study to investigate the effectiveness of using negative binomial regression to predict fault-prone software modules under two different conditions, self- assessment and forward assessment. The performance of negative binomial regression model is also compared with another popular fault prediction model—binary logistic regression method. The study is performed on six versions of an open-source objected-oriented project, Apache Ant. The study shows (1) the performance of forward assessment is better than or at least as same as the performance of self-assessment; (2) in predicting fault-prone modules, negative binomial regression model could not outperform binary logistic regression model; and (3) negative binomial regression is effective in predicting multiple errors in one module.

Complexity metrics have been intensively studied in predicting fault-prone software modules. However, little work is done in studying how to effectively use the complexity metrics and the prediction models under realistic conditions. In this paper, we present a study showing how to utilize the prediction models generated from existing projects to improve the fault detection on other projects. The binary logistic regression method is used in studying publicly available data of five commercial products. Our study shows (1) models generated using more datasets can improve the prediction accuracy but not the recall rate; (2) lowering the cut-off value can improve the recall rate, but the number of false positives will be increased, which will result in higher maintenance effort. We further suggest that in order to improve model prediction efficiency, the selection of source datasets and the determination of cut-off values should be based on specific properties of a project. So far, there are no general rules that have been found and reported to follow.

Software evolutionary stability has become an important issue in software maintenance and evolution. It is directly related to software reusability, maintainability and evolvability. In reported prior research, software evolutionary stability has been measured with architecture-level metrics, including reference points and program-level metrics, such as number of modules and number of lines of code. In this paper, information-level metrics based on Kolmogorov complexity are used to measure the differences between versions of software products. Using normalized compression distance, various evolutionary stability metrics of software artifacts are defined: version stability, branch stability, structure stability and aggregate stability. Case studies are performed on two open-source products, Apache HTTP server and Apache Ant build tool. The results from this study show that information-level evolutionary stability metrics can be used together with architecture-level metrics and program-level metrics to assist monitoring the software evolution process, as well as identifying stable or unstable software artifacts.

In software development, especially component-based software development, dependency locality states that relevant software components should be at shorter distances than irrelevant components. This principle is used together with modularity and hierarchy to guide the design of large-scale complex software systems. In previous work, dependency locality and its correlation with design quality were studied by statically measuring the interactions between software components. This paper presents an empirical approach to evaluating the hierarchical structure of software systems through mining their revision history. Two metrics, spatial distance and temporal distance, are adapted to measure the dependencies between software components. The correlation of spatial distance and temporal distance between software components represents a factor that influences system design quality. More specially, a well designed system hierarchy should have a significant positive correlation while a non-significant positive correlation or a negative correlation would signify design flaws. In an application of this approach, we use Mantel test to study the dependency locality of six software systems from Apache projects.

A software system evolves as changes are made to accommodate new features and repair defects. Software components are frequently interdependent, so changes made to one component can result in changes having to be made to other components to ensure that the system remains consistent; this is called change propagation. Accurate detection of change propagation is essential for software maintenance, which can be aided by accurate prediction of change propagation. In this paper, we study change propagation in three leading open-source software products: Linux, FreeBSD, and Apache HTTP Server. We use association rules-based data-mining techniques to detect change-propagation rules from the product version history. These rules are evaluated with respect to different training data sets and different test data sets. We discuss the applicability of using association-rule mining for change propagation, and several related issues. We find that a challenging issue in association-rule mining, concept drift, exists in software systems. Concept drift complicates the task of change-propagation prediction and requires special approaches, different from currently-used techniques for predicting change propagation.

Coupling represents the degree of interdependence between two software components. Understanding software dependency is directly related to improving software understandability, maintainability, and reusability. In this paper, we analyze the difference between component coupling and component dependency, introduce a two-parameter component coupling metric and a three-parameter component dependency metric. An important parameter in both these metrics is coupling distance, which represents the relevance of two coupled components. These metrics are applicable to layered component-based software. These metrics can be used to represent the dependencies induced by all types of software coupling. We show how to determine coupling and dependency of all scales of software components using these metrics. These metrics are then applied to Apache HTTP, an open-source web server. The study shows that coupling distance is related to the number of modifications of a component, which is an important indicator of component fault rate, stability and subsequently, component complexity.

Modularity is an important principle of software design. It is directly associated with software understandability, maintainability, and reusability. However, as software systems evolve, old code segments are modified / removed and new code segments are added, the original modular design of the program might be distorted. One of the factors that can affect the modularity of the system is the introduction of code clones --- a portion of source code that is identical or similar to another --- in the software evolution process. This paper applies clone detection techniques to study the modularity of Linux. The code clones are first identified using an automatic tool. Then each clone set is analyzed by a domain expert to classify it into one of the three clone concern categories: singular concern, crosscutting concern, and partial concern. Different approaches to dealing with these different categories of code clones are suggested in order to improve modularity.

Component dependency is an important software measure. It is directly related to software understandability, maintainability, and reusability. Two important parameters in describing component dependency are the type of coupling between two components and the type of the dependent component. Depending upon the different types of coupling and the type of the dependent components, there can be different effects on component maintenance and component reuse. In this paper, we divide dependent components into three types. We then classify various component dependencies and analyze their effects on maintenance and reuse. Based on the classification, we present a dependency metric and validate it on 11 open-source Java components. Our study shows that a strong correlation exists between the measurement of the dependency of the component and the effort to reuse the component. This indicates that the classification of component dependency and the suggested metric could be further used to represent other external software quality factors.

We compared and contrasted the maintainability of four open-source operating systems: Linux, FreeBSD, NetBSD, and OpenBSD. We used our categorization of common coupling in kernel-based software to highlight future maintenance problems. An unsafe definition is a definition of a global variable that can affect a kernel module if that definition is changed. For each operating system we determined a number of measures, including the number of global variables, the number of instances of global variables in the kernel and overall, as well as the number of unsafe definitions in the kernel and overall. We also computed the value of each our measures per kernel KLOC and per KLOC overall. For every measure and every ratio, Linux compared unfavorably with FreeBSD, NetBSD, and OpenBSD. Accordingly, we are concerned about the future maintainability of Linux.

After a software system has been delivered, it inevitably has to change to remain useful. Evolutionary coupling measures the change dependencies between software components. Reference coupling measures the architecture dependencies between software components. In this paper, we present a method to correlate evolutionary coupling and reference coupling. We study the evolution of 597 consecutive versions of Linux and measure the evolutionary coupling and reference coupling among 12 kernel modules. We compare 12 pairs of evolutionary coupling data and reference coupling data. The results show that linear correlation exists between evolutionary coupling and reference coupling. We conclude that in Linux, the dependencies between software components induced via the system architecture have noticeable effects on kernel module co-evolution.

Data coupling between modules, especially common coupling, has long been considered a source of concern in software design, but the issue is somewhat more complicated for products that are comprised of kernel modules together with optional nonkernel modules. This paper presents a refined categorization of common coupling based on definitions and uses between kernel and nonkernel modules and applies the categorization to a case study. Common coupling is usually avoided when possible because of the potential for introducing risky dependencies among software modules. The relative risk of these dependencies is strongly related to the specific definition-use relationships. In a previous paper, we presented results from a longitudinal analysis of multiple versions of the open-source operating system Linux. This paper applies the new common coupling categorization to version 2.4.20 of Linux, counting the number of instances of common coupling between each of the 26 kernel modules and all the other nonkernel modules. We also categorize each coupling in terms of the definition-use relationships. Results show that the Linux kernel contains a large number of common couplings of all types, raising a concern about the long-term maintainability of Linux.

A recent editorial in Empirical Software Engineering suggested that open-source software projects offer a great deal of data that can be used for experimentation. These data not only include source code, but also artifacts such as defect reports and update logs. A common type of update log that experimenters may wish to investigate is the ChangeLog, which lists changes and the reasons for which they were made. ChangeLog files are created to support the development of software rather than for the needs of researchers, so questions need to be asked about the limitations of using them to support research. This paper presents evidence that the ChangeLog files provided at three open-source web sites were incomplete. We examined at least three ChangeLog files for each of three different open-source software products, namely, GNUJSP, GCC-g++, and Jikes. We developed a method for counting changes that ensures that, as far as possible, each individual ChangeLog entry is treated as a single change. For each ChangeLog file, we compared the actual changes in the source code to the entries in the ChangeLog> file and discovered significant omissions. For example, using our change-counting method, only 35 of the 93 changes in version 1.11 of Jikes appear in the ChangeLog file—that is, over 62% of the changes were not recorded there. The percentage of omissions we found ranged from 3.7 to 78.6%. These are significant omissions that should be taken into account when using ChangeLog files for research. Before using ChangeLog files as a basis for research into the development and maintenance of open-source software, experimenters should carefully check for omissions and inaccuracies.

GitHub is a distributed code repository and project hosting web site. It is becoming one of the most popular web-based services to host both open-source projects and closed-source projects. In this paper, we review different kinds of version control systems and study the dynamics of GitHub, i.e., the ability and scalability of GitHub to process different requests and provide different services to different GitHub projects and GitHub users. Our study shows that GitHub could handle hundreds of thousands of requests a day for all the projects and thousands of requests for one project. This capability of GitHub makes it suitable for supporting distributed software development.

Design patterns are standardized solutions to commonly encountered problems using the object-oriented programming paradigm. Applying design patterns can speed up software development processes through the reuse of tested, proven templates, or development paradigms. Accordingly, design patterns have been widely used in software industry to build modern software programs. However, as different design patterns are introduced to solve different design problems, they are not necessarily superior to alternative solutions, with respect to all aspects of software design. One major concern is that the inappropriate use of design patterns may unnecessarily increase program complexity, such as class structural quality. Theoretical analysis of the effect of design patterns on software complexity has been widely performed. However, little work is reported to empirically study how design patterns might affect class structural quality. This chapter studies six components from five open-source Java projects and empirically investigates if design patterns can affect class structural quality. The chapter finds that pattern-involved classes are more complex than pattern-free classes and recommends the cautious use of design patterns to avoid unnecessary increases in class complexity and decrease in class structural quality.

Scheduling and staffing are important management activities in software projects. In closed-source software development, the relationships among development effort, time, and staffing have been well established and validated: the development effort determines the development time and the best number of developers that should be allocated to the project. However, there has been no similar research reported in open-source projects. In this chapter, the authors study the development effort, development time, and staffing in an open-source project, the Linux kernel project. Specifically, they investigate the power law relations among development effort, development time, and the number of active developers in the Linux kernel project. The authors find the power law relations differ from one branch to another branch in the Linux kernel project, which suggests different kinds of management and development styles might exist in different branches of the Linux kernel project. The empirical knowledge of software development effort obtained in this study could help project management and cost control in both open-source communities and closed-source industries.

Modularity is an important software design principle. One key point in the design of high quality software products is avoiding code clones, i.e., a portion of source code that is identical or similar to another. During the software evolution process, new code segments are frequently added. It is common to see that code clones accrue with the release of new versions of the product. Such accruement could be more serious in systems software, where new code segments are associated with similar functions or similar drivers. In this paper, we study code clones of two versions of the Linux kernel from the viewpoint of modularity. Our investigation finds that although quite some effort has been spent in Linux to remove some code clones, more code clones are typically added with the release of new versions. This has become a major issue that is potentially causing degradation of the modularity design principle within the Linux kernel.

Working collaboratively across time zone differences is an important issue for distributed software development projects. In such work, computer mediated communications, especially mailing lists, have been widely used for global software development. It is commonly agreed on that time zone differences have a negative impact on real time communications, such as instant messaging and video conferences. However, research results are unclear on whether time zone differences can cause excessive delays in asynchronous communication mediums, such as emails and discussion boards. This paper studies the effect of time zone differences through mining and investigating the Linux kernel mailing list archive. We extract time zone differences and message communication delays between developers. Statistical tests are used to analyse and identify correlations. Our study shows that within the Linux project, time zone differences between developers have a significant effect on short-term email communication delays of 24 hours or less.

With the increasing use of software products, software ecosystems have emerged. Software ecosystems not only include the same type of products, but also include other related products that they support or depend on. Software marketplace diversity and the symbiotic relations between software products are important properties of a software ecosystem. They have great impact on the popularity and evolution of a software product. This paper presents an empirical study of a software marketplace ecosystem, which is formed by operating systems, Web browsers, and Web servers: (1) Using the concept of market share entropy, we analyze the diversity of the marketplace; and, (2) Using correlation tests, we analyze the symbiotic relations between products. Based on the results of these two studies, we analyze the relation between marketplace diversity and symbiosis in a software ecosystem.

There is increasing interest in using robotic devices to assist in improving motor function for stroke patients. Rehabilitation evaluation during the motor rehabilitation process plays a crucial role in instructing robotic or manual therapy. Rehabilitation therapists can take some measure in assessing stiffness or motion range of the patient’s joints, but it is difficult for them to evaluate quantitatively and objectively. Furthermore few wearable robotic devices are reported for evaluating the recovery conditions of the patient’s hand internal muscles. The development of a pneumatic muscle (PM)-driven quantitative muscle rehabilitation evaluation robotic hand device serves this role. On account of the variance of the patient’s muscle recovery active forces and the complex nonlinear dynamics of PMs, the device becomes difficult to control. This paper presents a kind of feasible control strategy applied to this device.

Human-computer interaction plays an important role in most (if not all) computer applications. It is considered even essential for enabling social networking as dynamic Web 2.0 is becoming an important platform for communication, collaboration, information and knowledge sharing. Compared to static web pages (Web 1.0), Web 2.0 enables more intensive human-computer interactions. This chapter analyzes the relationship between human-computer interaction and social networking. A framework is outlined for representing and measuring online social networks, especially those formed through Web 2.0 applications. A case study based on this framework is performed on Wikipedia.

Effective communication is an important issue for global software development. Due to geographical limitations and travel challenges, face-to-face meetings are expensive to schedule and run. Web-based communication methods are thus the primary means of communication in global software development efforts. In general, two types of web-based communication mechanisms exist: synchronous and asynchronous communications; each serves a unique role. In this paper, we present an empirical study of the communication mechanisms in GNOME GTK+, a small-sized open-source distributed software project, in which Internet Relay Chat (IRC) and Mailing Lists are used as synchronous and asynchronous communication methods, respectively. The objective of this study is to identify how real time and asynchronous communication methods could be used and balanced across global software development projects.

Software change logs and release notes are documents released together with new versions of a software product. They contain the description of the changes made to the previous version and the new features introduced in the new version. In this paper, we present a keywordbased approach to mining and analyzing non-source code documents and define a mathematical framework to represent the data. This approach is applied in the study of the change logs of Linux and the release notes of FreeBSD. The results show that the software maintenance process and evolution process share some common properties and the keyword-based text mining technique could be used as a systematic method to study software maintenance and evolution.

Open-source software projects are characterized by their loose management property. Most of the activities of their developers are voluntary instead of mandatory. Compared to closed-source software projects, open-source projects are less dependent on external turbulence, but more on its own structure and operation mechanism. In this paper, we assume that the activities of open-source software projects are only dependent on time. We use time series analysis techniques to study the time dependence of open-source software activities. The activities of open-source Software projects are extracted from mailing lists, bug reports, and revision history. Three mailing list (Linux, FreeBSD, and Apache HTTP), two bug archives (Eclipse and Apache Software Foundation), and one revision history (Apache Software Foundation) are mined. Various time series analysis techniques are used. We find that some activities of some open-source projects are cyclic and seasonally dependent, some are cyclic but seasonally independent, and some are acyclic. We build regression models for cyclic activities and analyzed their model accuracy.

This paper presents a model to represent the interactions of distributed open-source software developers and utilizes data mining techniques to derive developer roles. The model is then applied on case studies of two open-source projects, ORAC-DR and Mediawiki with encouraging results.

Post-delivery fault reporting and correction are important activities in the software maintenance process. It is worthwhile to study these activities in order to understand the difference between open-source and closed-source software products from the maintenance perspective. This paper proposes three metrics to evaluate the post-delivery fault reporting and correction process, the average fault hidden time, the average fault pending time, and the average fault correction time. An empirical study is further performed to compare the fault correction processes of NASA Ames (closed-source) projects and three open-source projects: Apache Tomcat, Apache Ant, and Gnome Panel.

As a software system evolves to accommodate new features and repair bugs, changes are needed. Software components are interdependent, changes made to one component can require changes to be propagated to other components. Change propagation brings potential challenges for software maintenance. In this paper, we divide change propagations into four categories in kernel-based software. Different categories of change propagation have different effects on kernel maintenance. We use product version history to mine change propagations rules and apply the categorization to Linux operating system. Our study provides a framework for measuring, evaluating, and predicting change propagations in kernel-based software, which includes most operating systems, database management systems, game systems, and software product lines.

Modularity, hierarchy, and interaction locality are general approaches to reducing the complexity of any large system. A widely used principle in achieving these goals in designing software systems is striving for high cohesion within a module and low coupling between modules. However, this principle has difficulties in practice. Because a hierarchical system structure often consists of several layers, it is difficult to decide at what layer an interaction should be considered as cohesion, and at what layer an interaction should be considered as coupling. In this paper, we do not differentiate cohesion and coupling, but use a general term interaction to represent the dependencies between software modules. We propose a method to verify the design modularity, hierarchy, and interaction locality of a software system. This approach is based on the component interactions gathered from certain design level artifacts, such as UML diagrams. Data clustering technique is then used to group software components according to the degree of interactions between them. To show how to use this approach, we apply it to Parna's KWIC object-oriented design example, in which sequence diagram is used to derive the degree of component interactions.

Common coupling is usually considered an obstacle to software maintenance. In this paper, we study the interaction of common coupling with other forms of software coupling and introduce the concept of extended common coupling. We define four types of extended common coupling, which can help us to understand how a global variable is usually referenced, and how it is related to other forms of coupling. We perform an application study on Linux global variable current. The result shows that in most cases, global variable current in Linux is used with stamp coupling instead of data coupling, which will make the maintenance more difficult.

An editorial in empirical software engineering suggested that open-source software projects offer a great deal of data that can be used for experimentation. These data include artifacts such as source code and defect reports. In this paper we show that sources of open-source maintenance data, such as defect-tracking systems, change logs, and source code, cannot, in general, be used for measuring maintainability. We further show that approaches such as using defect distributions and the average lag time to fix a defect can be equally unusable. We conclude that, despite the plethora of open-source maintenance data, it is extremely hard to find data for determining the maintainability of open-source software.

Reusability is a desirable property of a software component. Furthermore, when building a new software product by reusing an existing component, it is important that the reusability of the reused component is not destroyed in the new product. In this paper, we use common coupling, a measure of software dependency, to represent software reusability. We have studied Darwin, an open-source operating system that was built by reusing two open-source operating systems, Mach and FreeBSD. We show that, in the course of building Darwin, much of the reusability in Mach and FreeBSD was retained, and that Darwin is therefore a good example of how to reuse software. Unfortunately, the code written specifically for Darwin is less reusable than the reused code.

Common coupling is an important factor that needs to be considered in software design. It affects software dependency via the definition-use relationship of global variables. Common coupling can arise in all types of software; here we focus on issues specific to kernel-based software. In a previous paper, we described a categorization of common coupling and used it to study the maintainability of the Linux operating system. In this paper, we present a detailed description of this categorization, prove its completeness, and suggest further applications. We hope that, by this approach, we can make it easier for others to use our categorization to measure the maintainability of other kernel-based software.

Bug reporting systems, such as Bugzilla are online tools used in software development and maintenance to store and track the status of a bug report. They are widely used by both open-source software projects and commercial software companies and have become a major source to study software evolution, software project management, and software quality control. In some research studies, the number of bug reports has been used as an indicator of software quality. This paper examines this representation. We investigate whether the number of bug reports of a specific version of a software product is correlated with its quality. Our study is performed on six branches of three open-source software systems. Our results do not support using the number of bug reports as a quality indicator of a specific version of an evolving software product. Instead, the study reveals that the number of bug reports is in some ways correlated with the time duration between product releases. Finally, the paper suggests a future research to study whether accumulated bug reports can be used as a means to represent the quality of a software branch.

Coupling measures the degree of dependencies between software modules. Considerable research has been performed to relate software coupling with software understandability, maintainability, and reusability, which are the key properties of software maintenance and evolution. However, only a few research works have been reported that study the relationships between software coupling and software performance. This study implemented two benchmarks that measure and compare the performance of software programs implemented with different kinds of coupling, common coupling, data coupling, and stamp coupling. The experiment is run on three different platforms, Windows, Linux, and Mac. The results show that (1) the relative performance of systems implemented using different software coupling is platform dependent, (2) while loose coupling is more favorable than strong coupling with respect to software maintenance and evolution, it has the drawback of reduced performance of a software program. Based on this study, we make some suggestions to balance the use of strong coupling and loose coupling in designing evolving software systems in order to achieve both maintainability and evolvability without compromising on performance.

Software component interaction is essential for realising proper software system functions. Such interactions between software components induce interdependencies between multiple components. One effect of such a dependency is co-evolution, wherein changes made to one component also requires corresponding changes to other component(s). This study presents a mathematical framework for representing component co-evolution. Two types of co-evolution, internal co-evolution and external co-evolution are defined for an evolving software component. The component dependency metrics that are related with component co-evolutions are analysed and the correlations between component dependency and component co-evolution are hypothesised. Further, in a quasi-experiment of nine open-source Java projects, component dependencies are measured and component revision histories are mined to verify the speculated correlations.

In software evolution, stability is defined as the ability of a module to remain largely unchanged when faced with newer requirements and/or changes in the environment. Although stability is an important long-term design characteristic for hardware systems, it has not been studied deeply for software systems. Stability is directly related to software evolvability and maintainability; and it affects the software evolution process. A model based on software version differences is presented to measure the evolutionary stability of software modules. This model represents and normalises two distances: the source code and the structure distances, between two versions of an evolving software module. As a case study based on this model, the evolutionary stability of Linux and FreeBSD modules is compared. The results of the study shows that the evolutionary stability of a software module in Linux and FreeBSD depends more on its function type and less on the system environment.

In the software industry, 'market share' refers to the percentage of the total available market that is being serviced by a software product. Market share analysis and prediction are important components of managing the marketing of a software business. In this paper, we study the software market share from an ecosystem point of view. We hypothesise that the evolution of the market share of a software product is dependent on two types of factors: internal and external. We build an agent-based model to represent the evolution of the software market share and compare the market share observations with the market share simulations of various operating systems, web servers and web browsers. The results show that the agent-based model effectively incorporates various factors of software products' market share and successfully simulates their evolution.

An obstacle to software reuse is the large number of major modifications that frequently have to be made as a consequence of dependencies within the reused software components. In this paper, common coupling is categorized and used as a measure of the dependencies between software components. We compared common coupling in three operating systems, Linux, FreeBSD, and Mach, and related it to the reuse effort of these systems. The measure is evaluated by studying the creation of two operating systems, MkLinux which is based on the reuse of Linux and Mach, and Darwin which is based on the reuse of FreeBSD and Mach. We conclude that the way that common coupling is implemented in Linux kernel induces large dependencies between software components, which required more effort in order to be reused to produce MkLinux, while the common coupling implemented in the Mach and FreeBSD kernels induces few dependencies between software components, which required less effort in order to be reused to produce Darwin.

Global software development is becoming a widely accepted practice in software industry. While benefits of global software development have been identified and publicized, potential risks have not ...

In this chapter, the authors describe their experiences in designing, developing, and teaching a course on Software Architecture that tested both in an academic context with their graduate Computer Science students and in an advanced context of professional updating and training with scores of system engineers in a number of different companies. The course has been taught in several editions in the last five years. The authors describe its rationale, the way in which they teach it differently in academia and in industry, and how they evaluate the students' learning in the different contexts. Finally, the authors discuss the lessons learnt and describe how this experience is inspiring for the future of this course.