Billion Lines Of Code Research Articles

Practical Mutation Testing at Scale: A view from Google

Mutation analysis assesses a test suite’s adequacy by measuring its ability to detect small artificial faults, systematically seeded into the tested program. Mutation analysis is considered one of the strongest test-adequacy criteria. Mutation testing builds on top of mutation analysis and is a testing technique that uses mutants as test goals to create or improve a test suite. Mutation testing has long been considered intractable because the sheer number of mutants that can be created represents an insurmountable problem–both in terms of human and computational effort. This has hindered the adoption of mutation testing as an industry standard. For example, Google has a codebase of two billion lines of code and more than 150,000,000 tests are executed on a daily basis. The traditional approach to mutation testing does not scale to such an environment; even existing solutions to speed up mutation analysis are insufficient to make it computationally feasible at such a scale. To address these challenges, this paper presents a scalable approach to mutation testing based on the following main ideas: (1) mutation testing is done incrementally, mutating only <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">changed code</i> during code review, rather than the entire code base; (2) mutants are filtered, removing mutants that are likely to be irrelevant to developers, and limiting the number of mutants per line and per code review process; (3) mutants are selected based on the historical performance of mutation operators, further eliminating irrelevant mutants and improving mutant quality. This paper empirically validates the proposed approach by analyzing its effectiveness in a code-review-based setting, used by more than 24,000 developers on more than 1,000 projects. The results show that the proposed approach produces orders of magnitude fewer mutants and that context-based mutant filtering and selection improve mutant quality and actionability. Overall, the proposed approach represents a mutation testing framework that seamlessly integrates into the software development workflow and is applicable to industrial settings of any size.

How Google Autocomplete Algorithms about Conspiracy Theorists Mislead the Public

How Google Autocomplete Algorithms about Conspiracy Theorists Mislead the Public

Free and Open Source Software organizations: A large-scale analysis of code, comments, and commits frequency.

As Free and Open Source Software (FOSS) increases in importance and use by global corporations, understanding the dynamics of its communities becomes critical. This paper measures up to 21 years of activities in 1314 individual projects and 1.4 billion lines of code managed. After analyzing the FOSS activities on the projects and organizations level, such as commits frequency, source code lines, and code comments, we find that there is less activity now than there was a decade ago. Moreover, our results suggest a greater decrease in the activities in large and well-established FOSS organizations. Our findings indicate that as technologies and business strategies related to FOSS mature, the role of large formal FOSS organizations serving as intermediary between developers diminishes.

Software systems at risk: An empirical study of cloned vulnerabilities in practice

With the growth of open source software (OSS), code clones – code fragments that are copied and pasted within or between software systems – are proliferating. Although code cloning may expedite the process of software development, it often critically affects the security of software because vulnerabilities and bugs can easily be propagated through code clones. These vulnerable code clones are increasing in conjunction with the growth of OSS, potentially contaminating many systems. Although researchers have attempted to detect code clones for decades, most of these attempts fail to scale to the size of the ever-growing OSS code base. The lack of scalability prevents software developers from readily managing code clones and associated vulnerabilities. Moreover, most existing clone detection techniques focus overly on merely detecting clones and this impairs their ability to accurately find “vulnerable” clones.In this paper, we propose VUDDY, an approach for the scalable detection of vulnerable code clones, which is capable of detecting security vulnerabilities in large software programs efficiently and accurately. Its extreme scalability is achieved by leveraging function-level granularity and a length-filtering technique that reduces the number of signature comparisons. This efficient design enables VUDDY to preprocess a billion lines of code in 14 hours and 17 minutes, after which it requires a few seconds to identify code clones. In addition, we designed a vulnerability-preserving abstraction technique that renders VUDDY resilient to common modifications in cloned code, while preserving the vulnerable conditions even after the abstraction is applied. This extends the scope of VUDDY to identifying variants of known vulnerabilities, with high accuracy. An implementation of VUDDY has been serviced online for free at IoTcube, an automated vulnerability detection platform. In this study, we describe its principles, evaluate its efficacy, and analyze the vulnerabilities VUDDY detected in various real-world software systems, such as Apache HTTPD server and an Android smartphone.

Utilizing Usability Evaluating Model in Applying CMM to Improve the Quality of Software Maintenance Process

Maintenance plays an important role in the life cycle of a software product. It is estimated that there are more than 100 billion lines of code in production in the world. As much as 80% of it is unstructured, patched and not well documented. Maintenance can alleviate these problems. The purpose of this paper is to explore the use of the Capability Maturity Model (CMM) to improve the quality of software maintenance process (SMP). The architecture of the CMM model has been retained almost as is while its content, which was specific to the development process, has been either modified or extended to take into account the characteristics specified to the maintenance function, these characteristics were then organized into key process areas (KPAs) of CMM model. This paper applied the definition of (ISO 9241-11, 1998) that examines effectiveness, efficiency, and satisfaction. The emphasis will be given to the SMP activities

A few billion lines of code later

How Coverity built a bug-finding tool, and a business, around the unlimited supply of bugs in software systems.

Legacy integration-changing perspectives [Cobol

Dusty Cobol card decks, difficult-to-maintain programs, and software generally incompatible with current state-of-the-art application frameworks: that's legacy. Or is it? Start with the cleansing effect of Y2K, add the Internet and e-commerce, and throw in component technologies such as Corba, COM, and Enterprise JavaBeans, the standardization effort behind XML, and the resurgent interest in data, and you'll find new meaning and vitality for the term legacy. Estimated at over 100 billion lines of code, most of it Cobol, it drives the world's infrastructure. The end result is a new appreciation of legacy and a search for ways to capitalize on its potential. Cobol programs and data are being viewed in a new positive light with options for interconnection and integration for both code and data.