Search

This chapter describes mobile payment, a mobile financial activity born of digital revolution, which is the combination of electronic money and mobile technology. The underlying technologies of mobile payment, its big players, and its status quo and future trend are discussed. In addition, this chapter discusses how mobile payment is related to social equality and social inclusion. Through presenting the historical, technical, economic, and social aspects of mobile payment, this chapter intends to provide readers with a holistic view of one of the fast-evolving financial activities that are transforming business, individuals, and the society.

Software development is the process to produce an information technology solution to a real-world problem. Teaching and integrating non-technical software engineering skills into the curriculum is considered one of the most challenging tasks in an academic environment. This becomes even more challenging when the curriculum is supposed to be internationalized and applied in different countries because of the cultural difference, policy difference, and business model difference. In this chapter, the authors present their experience of teaching a software engineering course both locally and globally, where two universities of USA and China are chosen for this study. Specifically, they describe how they adjust homework assignments and student performance evaluations to reflect different government policies, different business environment, and different real-world customer requirement. The chapter shows that it is possible to create an internationalized computer science curriculum that contains both common core learning standards and adjustable custom learning standards.

In the past 15 years, China's e-commerce industry has grown tremendously and become the world's largest e-commerce market. This chapter studies some popular e-commerce companies of China, including Alibaba, JD, and Pindoudou. Specifically, the customer engagement strategies of these companies are described and analyzed. This chapter helps readers understand how various customer engagement strategies of China's e-commerce companies have facilitated the change of their consumers' shopping habits—switching from offline shopping centers to online marketplaces and from cash-based payment to credit-based payment. The success of these customer engagement strategies has contributed to the performance improvement of e-commerce companies and could ultimately assist China to transfer from a production economy to a consumption economy. Moreover, these customer engagement strategies developed in China might also be applied to other e-businesses or marketplaces of different regions, especially developing countries that have a similar economy structure as China.

A novel 3D printing strategy for continuous glass fiber reinforced polylactic acid (CGF/PLA) composites was proposed. CGF/PLA filament was prepared by a melting impregnation device, and then CGF/PLA filament was directly supplied to the self-modified 3D printing device. The impregnation process was optimized systematically, and the fiber content reached up to 45 wt%. A specific compatibilizer was used and the amount of compatibilizer was optimized to enhance the interfacial bonding between fiber and polymer. The effects of printing parameters such as nozzle diameter, edge width, layer thickness, printing speed and temperature on the mechanical properties and microstructure of the final printed products were studied. The flexural strength and flexural modulus of the printed products reached 312 MPa and 21.5 GPa, respectively. The fabrication strategies proposed in this study can provide a low-cost and high-strength method for the industrial application of 3D printed continuous fiber reinforced thermoplastic composites.

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.

This chapter describes e-commerce, a trading business built on top of the Internet. Different e-commerce models, such as B2B, B2C, C2C, and their major players are described. E-commerce companies like Amazon and Alibaba, are used to explain the effect of e-commerce on our economy, society, and beyond. GMV, MAU, market capitalization, and other business data are presented and analyzed. Influential factors, such as user retention, government policy, payment method, and logistics are also discussed. Finally, the emerging e-commerce model, emerging e-commerce market, and the future of e-commerce are illustrated.

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.

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 success of a software product depends not only on the quality of the functions it provides but also on the success of its interdependent hardware, software, and other players within its ecosystem. The software ecosystem studied thus far has largely ignored the importance of the market, which is the ecosystem's energy source. The market affects all players in the ecosystem, determining whether the software product can succeed. The author analyzes this market-driven software ecosystem in both the open source and mobile computing communities.

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.

This chapter describes how problem-based learning is utilized in a software engineering classroom to help students develop soft skills, such as communication skills, documentation skills, team working skills, and interpersonal skills. Case studies are performed at Indiana University South Bend, where experiences of two instructors with similar teaching approaching are analyzed. Studies find that while problem-based learning is promising in engaging students and effectively delivering soft skills, it is more challenging for instructors. Compared to traditional instructor-centered learning approach, problem-based learning requires instructors to spend more effort on problem design/refinement, student coaching, performance evaluation, data gathering, and experience analysis. Despite its difficulties of implementation, problem-based learning is considered an effective approach in software engineering education.

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.

Complex software systems and the huge amounts of data they produce are becoming an integral part of our organizations. We are also becoming increasingly dependent on high quality software products in our everyday lives. These systems ‘evolve’ as we identify and correct existing defects, provide new functionalities, or increase their nonfunctional qualities - such as security, maintainability, performance, etc. Simultaneously, more software development projects are distributed over multiple locations (often globally) and are often several millions of dollars in development costs. Consequently, as the Internet continually eliminates geographic boundaries, the concept of doing business within a single country has given way to companies focusing on competing in an international marketplace. The digitalization of work and the reorganization of work processes across many organizations have resulted in routine and/or commodity components being outsourced.

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.

As software systems become more pervasive and complex and - at the same time - expensive and difficult to maintain, the R&D community has turned to biological systems to find mechanisms that support system integrity and robustness. In both biology and software development, evolvability has become a research area in its own right. To improve software evolvability, many researchers have studied biological system properties, such as self-organization, modularity, and gene duplication. Our research focuses instead on software ecosystems and symbiosis as a business strategy for multivendor software systems.

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.

Software systems must continually evolve to adapt to new functional requirements or quality requirements to remain competitive in the marketplace. However, different software systems follow different strategies to evolve, affecting both the release plan and the quality of these systems. In this paper, software evolution is considered as a self-organization process and the difference between closed-source software and open-source software is discussed in terms of self-organization. In particular, an empirical study of the evolution of Linux from version 2.4.0 to version 2.6.13 is reported. The study shows how open-source software systems self-organize to adapt to functional requirements and quality requirements.

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.

Distributed data centers are becoming more and more important for internet-based companies. Without distributed data centers, it will be hard for internet companies to scale up their business. The traditional centralized data center suffers the drawback of bottle neck and single failure problem. Therefore, more and more internet companies are building distributed data centers, and more and more business are moved onto distributed Web services. This paper reviews the history of distributed Web services and studies their current status through examining the distributed data centers of several top Internet companies. Based on the study, we conclude that distributed services, including distributed data centers, are the key factors to scale up the business of a company, especially, an internet-based company.

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.

An accurate maintenance effort model is essential for a successful software maintenance process. Maintenance effort is usually measured in person-hours used to perform a maintenance task. However, maintenance effort data are usually only available for strictly managed software, such as closed-source software. In other software projects that do not have complete maintenance records, especially some open-source software, there are no direct data for maintenance effort, which precludes the establishment of a maintenance effort model. In this paper, we report a series of studies aimed at presenting a method for indirectly predicting the maintenance effort of open-source software. This report covers two parts of our research. First, we examine the maintenance data from NASA SEL closed-source software projects and identify some software measures that can be used to indirectly represent maintenance effort. Second, based on the findings in the first part, we analyze 121 recent versions of Linux, and use linear regression to construct two indirect maintenance effort models for the Linux project. Our study demonstrates the applicability of this approach to indirectly predicting the maintenance effort and improving the software maintenance process. Copyright © 2006 John Wiley & Sons, Ltd.

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.

In 1978, Lientz, Swanson, and Tompkins published the results of a survey on software maintenance. They found that 17.4% of maintenance effort was categorized as corrective in nature, 18.2% as adaptive, 60.3% as perfective, and 4.1% was categorized as other. We refer to this as the “LST” result. We contrast this survey-based result with our empirical results from the analysis of data for the repeated maintenance of three software products: a commercial real-time product, the Linux kernel, and GCC. For all three products and at both levels of granularity we considered, our observed distributions of maintenance categories were statistically very highly significantly different from LST. In particular, corrective maintenance was always more than twice the LST value. For the summed data, the percentage of corrective maintenance was more than three times the LST value. We suggest various explanations for the observed differences, including inaccuracies on the part of the maintenance managers who responded to the LST survey.

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.

Robot-assisted rehabilitation is an active area of research to meet the demand of repetitive therapy in stroke rehabilitation. A wearable upper limb rehabilitation robot is most suitable for this task but needs to be powered by safe and compliant actuators while maintaining overall light weight and accommodating energy efficient dynamic form factor. In this study, we explore an integrative rehabilitation strategy for training patients to practice coordinated reaching and grasping functions by using a hybrid design to reduce the size and weight of the robot. The hybrid technology of the wearable upper limb rehabilitation robot and functional electrical stimulation has many technical and clinical advantages but is yet to be systematically investigated. A properly designed FES can induce active movements while inhibit abnormal reflexes. This is a promising approach to alleviate the actuation power demand of the robot, thereby the size and weight of the robot may be significantly reduced. Most important, the mechanical complexity of the robot may also be limited. We explored the concept of the hybrid design in this preliminary report. The future research is discussed for design principle of how to take advantage of each technique in developing a more energy efficient and functional effective hybrid FES and robot assisted system.

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.

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.

Software systems need to evolve to adapt to either a new environment or a new requirement. This position paper discusses the evolution of a software system from the viewpoint of an ecosystem and asserts that the evolution of a software system is not a standalone process but an aggregate process of other related software systems that forms a software ecosystem. This paper describes several of our ongoing projects in studying different types of symbiotic relationships between software systems and their effects on software evolution.

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.

Biological and software systems share a common property from evolution: they need to change and adapt to either a new environment or a new requirement. If the environment or requirement changes, those systems that have high evolvability will survive and others will be eliminated. The evolvability of a biological system has been widely studied and shown to be dependent on several properties: selforganization, modularity, gene duplication, gene robustness, and symbiosis. This position paper discusses the evolvability of a software system with respect to these properties. Our study shows that software systems share similar evolvability properties with biological systems. We conclude that studying and comparing the internal structures as well as the overall evolution process of these biological systems can help us understand software systems from a holistic ?product-lifecycle? perspective thereby helping us develop software systems with better evolvability traits.

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.

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.