Complexity Metrics

Empirical work supporting the hypothesis that simple size metrics and complexity metrics are good predictors of fault-prone modules have been published in the past. Some studies have also shown that contrary to common belief complexity measures are not always better predictors than simple size metrics. All of these studies share one characteristic – they measure size, complexity and number of faults at the granularity of at least modules. In this work we compare the relative ability to predict the number of faults and fault-proneness of simple size metrics, such as Lines of Code (LOC), and complexity metrics. The caveat of our empirical investigation is that we seek evidences to compare the metrics on a level of granularity smaller than modules; we do it for segments of code that implement a particular software testing requirement. Our data show that complexity measures are better predictors of the number of faults than simple size metrics at that granularity level.

Information overload is a new challenge in e-commerce sites. The problem refers to the fast growing of information that lead following the information flow in real world be impossible. Recommender systems, as the most successful application of information filtering, help users to find items of their interest from huge datasets. Collaborative filtering, as the most successful technique for recommendation, utilises social behaviours of users to detect their interests. Traditional challenges of Collaborative filtering, such as cold start, sparcity problem, accuracy and malicious attacks, derived researchers to use new metadata to improve accuracy of recommenders and solve the traditional problems. Trust based recommender systems focus on trustworthy value on relation among users to make more reliable and accurate recommends. In this paper our focus is on trust based approach and discuss about the process of making recommendation in these method. Furthermore, we review different proposed trust metrics, as the most important step in this process.

tivity and flexibility in output, which could result in information customization systems. Data interchange. Data interchange involves transforming information from one representation to another. Often, the same initial and target formats occur many times, as in converting documents from one word processing format to another. Sometimes, though, data must be converted to a specialized format for a one-time analysis. Typically, a program will be written to do this custom conversion. To our knowledge, no one has yet developed a tool for interactively helping a user specify initial and/or target formats. Such an artifact would be a useful information customizing tool.

Summary Business Process Models (BPMs), often created using a modeling language such as UML activity diagrams, Event- Driven Process Chains Markup Language (EPML) and Yet Another Workflow Language (YAWL), serve as a base for communication between the stakeholders in the software development process. In order to fulfill this purpose, they should be easy to understand and easy to maintain. For

Software metrics should be used in order to improve the productivity and quality of software, because they provide critical information about reliability and maintainability of the system. In this paper, we propose a cognitive complexity metric for evaluating design of object-oriented (OO) code. The proposed metric is based on an important feature of the OO systems: Inheritance. It calculates the complexity at method level considering internal structure of methods, and also considers inheritance to calculate the complexity of class hierarchies. The proposed metric is validated both theoretically and empirically. For theoretical validation, principles of measurement theory are applied since the measurement theory has been proposed and extensively used in the literature as a means to evaluate the software engineering metrics. We applied our metric on a real project for empirical validation and compared it with Chidamber and Kemerer (CK) metrics suite. The theoretical, practical and empirical validations and the comparative study prove the robustness of the measure.

This paper reports on a modest study which relates seven different software complexity metrics to the experience of maintenance activities performed on a medium size software system. Three different versions of the system that evolved over a period of three years were analyzed in this study. A major revision of the system, while still in its design phase, was also analyzed.

This paper presents some of the most important features of a tree visualisation system called Latour, developed for the purposes of information visualisation. This system includes a number of interesting and unique characteristics, for example the provision for visual cues based on complexity metrics on graphs, which represent general principles that, in our view, graph based information visualisation systems should generally offer.

Predicting the incidence of faults in code has been commonly associated with measuring complexity. In this paper, we propose complexity metrics that are based on the code change process instead of on the code. We conjecture that a complex code change process negatively affects its product, i.e., the software system. We validate our hypothesis empirically through a case study using data derived from the change history for six large open source projects. Our case study shows that our change complexity metrics are better predictors of fault potential in comparison to other well-known historical predictors of faults, i.e., prior modifications and prior faults.

In view of results obtained in split decomposition theory, it is of some interest to investigate the structure of weakly compatible split systems. A particular class of such split systems -the so called octahedral split systems -can be constructed as follows: Given a set X together with a surjective map φ : X→ →V onto the six-element set V of vertices of an octahedron, form the four bipartitions X = A i∪ B i (i = 1, 2, 3, 4) of X obtained by first partitioning V in all four possible ways into two disjoint 3-subsets U i and W i (i = 1, 2, 3, 4) so that the vertices in both U i and W i form an equilateral triangle, and then taking their pre-images A i := φ −1 (U i ) and .

Viewshed calculation can play an important role in urban and natural resource planning. However, difficulties exist in incorporating built structures in viewshed computation. These features are rarely reflected in available elevation maps and adding them can be complicated as their locations, shapes, and heights are often uncertain. This study examined the impact of generalizing building locations and heights on viewshed properties. We used a geographic information system and high resolution data to assess how viewsheds, generated with actual building footprints and heights, differ from viewsheds generated from generalized building locations and uniform heights. We measured differences among viewsheds created with different approaches in terms of area and landscape complexity. Viewsheds generated using uniform heights and actual footprints differed significantly from the most accurate viewsheds in their areal extents and in the areas of some land use classes. Viewsheds produced using estimated locations combined with both realistic and uniform heights differed significantly from viewsheds created with accurate data in their areal extents and areas most land use types. Viewsheds produced using estimated locations also differed significantly from more accurate viewsheds in both complexity metrics assessed. Viewsheds produced using accurate locations and uniform heights differed significantly in one complexity metric, richness, but not in a second, diversity. Therefore, it may be feasible to generalize building heights when diversity and the areas of some specific land use classes are central to viewshed analysis, but generalizing building locations is less advisable. When viewshed areal extents are critical, location or height generalization may be ill-advised.

The problem of cost estimation in software engineering has been addressed by several researchers. Research shows that among many factors that affect the development cost, size of the product plays an important role. In addition to the size, product properties like complexity, cohesion and coupling are also mentioned as cost factors. We focus on the relationship between complexity of a

Software systems are affected by degradation as an effect of continuous change. Since late interventions are too much onerous, software degradation should be detected early in the software lifetime. Software degradation is currently detected by using many different complexity metrics, but their use to monitor maintenance activities is costly. These metrics are difficult to interpret, because each emphasizes a particular aspect of degradation and the aspects shown by different metrics are not orthogonal. The purpose of our research is to measure the entropy of a software system to assess its degradation. In this paper, we partially validate the entropy class of metrics by a case study, replicated on successive releases of a set of software systems. The validity is shown through direct measures of software quality such as the number of detected defects, the maintenance effort and the number of slipped defects.

The cognitive strategies by which humans process complex, metrically-ambiguous rhythmic patterns remain poorly understood. We investigated listeners' abilities to perceive, process and produce complex, syncopated rhythmic patterns played against a regular sequence of pulses.

Empirical work supporting the hypothesis that simple size metrics and complexity metrics are good predictors of fault-prone modules have been pub- lished in the past. Some studies have also shown that contrary to common belief complexity measures are not always better predictors than simple size metrics. All of these studies share one characteristic ñ they measure size, complexity and number of faults at the granularity of at least modules. In this work we compare the relative ability to predict the number of faults and fault-proneness of simple size metrics, such as Lines of Code (LOC), and complexity metrics. The caveat of our empirical investigation is that we seek evidences to compare the metrics on a level of granularity smaller than modules; we do it for segments of code that im- plement a particular software testing requirement. Our data show that complexity measures are better predictors of the number of faults than simple size metrics at

AbstractÐThe dearth of published empirical data on major industrial systems has been one of the reasons that software engineering has failed to establish a proper scientific basis. In this paper, we hope to provide a small contribution to the body of empirical knowledge. We describe a number of results from a quantitative study of faults and failures in two releases of a major commercial system. We tested a range of basic software engineering hypotheses relating to: The Pareto principle of distribution of faults and failures; the use of early fault data to predict later fault and failure data; metrics for fault prediction; and benchmarking fault data. For example, we found strong evidence that a small number of modules contain most of the faults discovered in prerelease testing and that a very small number of modules contain most of the faults discovered in operation. However, in neither case is this explained by the size or complexity of the modules. We found no evidence to support previous claims relating module size to fault density nor did we find evidence that popular complexity metrics are good predictors of either fault-prone or failure-prone modules. We confirmed that the number of faults discovered in prerelease testing is an order of magnitude greater than the number discovered in 12 months of operational use. We also discovered fairly stable numbers of faults discovered at corresponding testing phases. Our most surprising and important result was strong evidence of a counter-intuitive relationship between pre-and postrelease faults: Those modules which are the most fault-prone prerelease are among the least fault-prone postrelease, while conversely, the modules which are most faultprone postrelease are among the least fault-prone prerelease. This observation has serious ramifications for the commonly used fault density measure. Not only is it misleading to use it as a surrogate quality measure, but, its previous extensive use in metrics studies is shown to be flawed. Our results provide data-points in building up an empirical picture of the software development process. However, even the strong results we have observed are not generally valid as software engineering laws because they fail to take account of basic explanatory data, notably testing effort and operational usage. After all, a module which has not been tested or used will reveal no faults, irrespective of its size, complexity, or any other factor.

Many organizations want to predict the number of defects (faults) in software systems, before they are deployed, to gauge the likely delivered quality and maintenance effort. To help in this, numerous software metrics and statistical models have been developed, with a correspondingly large literature. We provide a critical review of this literature and the state-of-the-art. Most of the wide range of prediction models use size and complexity metrics to predict defects. Others are based on testing data, the "quality" of the development process, or take a multivariate approach. The authors of the models have often made heroic contributions to a subject otherwise bereft of empirical studies. However, there are a number of serious theoretical and practical problems in many studies. The models are weak because of their inability to cope with the, as yet, unknown relationship between defects and failures. There are fundamental statistical and data quality problems that undermine model validity. More significantly many prediction models tend to model only part of the underlying problem and seriously misspecify it. To illustrate these points the "Goldilock's Conjecture," that there is an optimum module size, is used to show the considerable problems inherent in current defect prediction approaches. Careful and considered analysis of past and new results shows that the conjecture lacks support and that some models are misleading. We recommend holistic models for software defect prediction, using Bayesian Belief Networks, as alternative approaches to the single-issue models used at present. We also argue for research into a theory of "software decomposition" in order to test hypotheses about defect introduction and help construct a better science of software engineering.

 This paper deals with imputation techniques and strategies. Usually, imputation truly commences after the first data editing, but many preceding operations are needed before that. In this editing step, the missing or deficient items are to be recognized and coded, and then it is decided which of these, if any, should be substituted by imputing. There are a number of imputation methods and their specifications. Consequently, it is not clear what method finally should be chosen, especially when an imputation method may be best in one respect, and another method in the other. In this paper, we consider these questions through the following four imputation methods: (i) random hot decking, (ii) logistic regression imputation, (iii) linear regression imputation, and (iv) regressionbased nearest neighbour hot decking. The last two methods are applied with the two different specifications. The two metric variables have been used in empirical tests. The first is very complex, but the second is more ordinary, and thus easier to handle. The empirical examples are based on simulations, which clearly show the biases of the various methods and their specifications. In general, it seems that method (iv) is recommendable although the results from it are not perfect either.

Accurate estimates of development effort play an important role in the successful management of larger Web development projects. By applying measurement principles to measure qualities of the applications and their development processes, feedback can be obtained to help understand, control and improve products and processes.

is an agile practice that is widely accepted and advocated by most agile methods and methodologists. In this paper, we report on a post hoc analysis of the results of an IBM team who has sustained use of TDD for five years and over ten releases of a Java-implemented product. The team worked from a design and wrote tests incrementally before or while they wrote code and, in the process, developed a significant asset of automated tests. The IBM team realized sustained quality improvement relative to a pre-TDD project and consistently had defect density below industry standards. As a result, our data indicate that the TDD practice can aid in the production of high quality products. This quality improvement would compensate for the moderate perceived productivity losses. Additionally, our data indicates that the use of TDD may decrease the degree to which code complexity increases as software ages, as measured by cyclomatic complexity metric.

& Conclusions-This paper presents a methodology and an example of risk assessment of functional-requirement specifications for complex real-time software systems. A heuristic risk-assessment technique based on CPN (colored Petri-net) models is presented. This technique is used to classify software functional-requirement specification components according to their relative importance in terms of such factors as severity and complexity. A dynamic complexity measure, based on concurrence in the functional requirements, is introduced. This technique is applied on the Earth Operation Commanding Center (EOC COMMANDING), a large component of the NASA Earth Observing System (EOS) project. Two specification models of the system are considered. Results of applying this technique to both models are presented.

Three software complexity measures (Halstead's E, McCabe's u(G), and the length as measured by number of statements) were compared to programmer performance on two software maintenance tasks. In an experiment on understanding, length and u(G) correlated with the percent of statements correctly recalled. In an experiment on modification, most significant correlations were obtained with metrics computed on modified rather than

Refactoring is widely recognized as a way to improve the internal structure of a software system in order to ensure its long-term maintainability. Consequently, software projects which adopt refactoring practices should see reductions in the complexity of their code base. We evaluated this assumption on an open source system -namely PMD, a Java source code analyzer-and discovered that periods of refactorings did not affect the cyclomatic complexity. This paper investigates this counterintuitive phenomenon through a detailed analysis of the actual source code manipulations applied on the system under study.

A large number of real networks are characterized by two fundamental properties: they are small world and scale-free. A recent paper demonstrated that the structure of many complex networks is also self-similar under a length-scale transformation, and calculated their fractal dimension using the “box counting” method. We studied nine large object-oriented software systems, finding that the graphs associated to these networks are self-similar. We also studied the time evolution of the fractal dimension during system growth, finding a significant correlation between the fractal dimension and object-oriented complexity metrics known to be correlated with software fault-proneness. Thus, in software systems the fractal dimension could be considered as a measure of internal complexity, and consequently of the system quality.

Web applications are increasingly subject to mass attacks, with vulnerabilities found easily in both open source and commercial applications as evinced by the fact that approximately half of reported vulnerabilities are found in web applications. In this paper, we perform an empirical investigation of the evolution of vulnerabilities in fourteen of the most widely used open source PHP web applications, finding that vulnerabilities densities declined from 28.12 to 19.96 vulnerabilities per thousand lines of code from 2006 to 2010. We also investigate whether complexity metrics or a security resources indicator (SRI) metric can be used to identify vulnerable web application showing that average cyclomatic complexity is an effective predictor of vulnerability for several applications, especially for those with low SRI scores.

To produce high quality object-oriented (OO) applications, a strong emphasis on design aspects, especially during the early phases of software development, is necessary. Design metrics play an important role in helping developers understand design aspects of software and, hence, improve software quality and developer productivity. In this paper, we provide empirical evidence supporting the role of OO design complexity metrics, specifically a subset of the Chidamber and Kemerer suite, in determining software defects. Our results, based on industry data from software developed in two popular programming languages used in OO development, indicate that, even after controlling for the size of the software, these metrics are significantly associated with defects. In addition, we find that the effects of these metrics on defects vary across the samples from two programming languages-C++ and Java. We believe that these results have significant implications for designing high-quality software products using the OO approach.

Many distributed systems lend themselves to be modelled as networks, where nodes can have a range of attributes and properties based on which they may be classified. In this paper, we attempt the task of quantifying varying levels of similarity among nodes in a complex network over a period of time. We analyze how this similarity varies as nodes implement their functional logic and node states vary accordingly. We then use information theory to analyze how much Shannon information is conveyed by such a similarity measure, and how such information varies with time. We also propose node congruity as a measure to quantify the contribution of each node to the network's scalar assortativity. Finally, focussing on networks with binary states, we present algorithms (logic functions) which can be implemented in nodes to maximize or minimize scalar assortativity in a given network, and analyze the corresponding tendencies in information content.

This paper proposes some new complexity metrics for distributed programs. The metrics are defined bas e d on graph-the o ret i c a 1 rep r e s e n t a t i o ns fo r multiple control flows, multiple data flows, and various p r i m a r y p r o g r a m d e p e n d e n c e s i n distributed programs. They can be used to measure the complexity of a distributed program from various different viewpoints. This paper proposes some new complexity metrics for distributed programs. The metrics are defined based o n s o m e g r a p h-t h e o r e t i c a l representations, which are proposed by the author recently, for representing multiple control flows, multiple data flows, and various primary program dependences in distributed programs. These complexity metrics can be used to measure the complexity of a distributed program from various different viewpoints.

This thesis lays the necessary groundwork for measuring the complexity of systems architecture models. We propose a set of complexity measures, which are usable with models defined using the Object-Process Model (OPM). In order to do this, we introduce a new concept of interface complexity multiplier for compensating the hidden information at interfaces. We also define a set of complexity metrics for system architecture models. We also develop models for three different systems for mobile entertainment. The purpose of these models is to show how OPM is suitable for modeling such systems and also to provide some comparative material for complexity measurements. We use the new metrics to determine the complexity of the models of mobile entertainment systems. The thesis also contains a rigorous definition of complexity and a survey of existing complexity measurement methods.

Cascading style sheets (CSS) is a Web-based style sheet language that is used for the presentation of Web documents. CSS has advanced from CSS1 to CSS3.and extensions to CSS known as CSS pre-processors have also emerged in the last few years. As is the case with regular software, CSS have inherent complexity that keeps on increasing with age which is undesirable, and metrics are needed to measure with the aim of controlling it. Although several Web metrics have been proposed in the literature, the area of stylesheets is still lagging. Findings show that few CSS-related metrics exist, and there is no evidence of proof for their mathematical soundness through the popularly known frameworks such as Briand framework and Weyuker's properties. In addition, they have not been empirically validated. In order to address this gap, future studies should focus on defining and validating new metrics for CSS and its pre-processors.

Complexity metrics play an important role in software development; they are reducing the costs during almost the whole development process. There is a growing demand for measuring the complexity of large systems with keeping the consistency of the results regardless of the diversity of the programming languages. In this article we present a general software measurement process on .NET basis

It is widely accepted that sizing or predicting the volumes of various kinds of software deliverable items is one of the first and most dominant aspects of software cost estimating. Most of the cost estimation model or techniques usually assume that software size or structural complexity is the integral factor that influences software development effort. Although sizing and complexity measure

Abstract Functional validation of System Level Models, such as those modeled with SystemC, is an important and complex problem. One of the problems in their functional validation is the test case generation with good coverage and higher potential to find faults in the design. We propose a coverage-directed test generation framework for system level design validation by combining the synchronous language ESTEREL, and its advanced verification capability, with C++ based system level language SystemC. The main ...

Many organizations want to predict the number of defects (faults) in software systems, before they are deployed, to gauge the likely delivered quality and maintenance effort. To help in this, numerous software metrics and statistical models have been developed, with a correspondingly large literature. We provide a critical review of this literature and the state-of-the-art. Most of the wide range of prediction models use size and complexity metrics to predict defects. Others are based on testing data, the "quality" of the development process, or take a multivariate approach. The authors of the models have often made heroic contributions to a subject otherwise bereft of empirical studies. However, there are a number of serious theoretical and practical problems in many studies. The models are weak because of their inability to cope with the, as yet, unknown relationship between defects and failures. There are fundamental statistical and data quality problems that undermine model validity. More significantly many prediction models tend to model only part of the underlying problem and seriously misspecify it. To illustrate these points the "Goldilock's Conjecture," that there is an optimum module size, is used to show the considerable problems inherent in current defect prediction approaches. Careful and considered analysis of past and new results shows that the conjecture lacks support and that some models are misleading. We recommend holistic models for software defect prediction, using Bayesian Belief Networks, as alternative approaches to the single-issue models used at present. We also argue for research into a theory of "software decomposition" in order to test hypotheses about defect introduction and help construct a better science of software engineering.

Mixed model manufacturing systems are increasingly used to meet global competition by providing a broad variety of products to customers. The increase of product variety adds more complexity to production processes, thus, leading to a negative effect on the performance of production processes. Therefore, it is of great interest to effectively measure such complexity and to quantify its effect on manufacturing system performance. In this paper, a set of complexity metrics are proposed for measuring the complexity of different elements in a manufacturing system. These metrics were defined by constructing a linkage with the communication system's framework. Different from those existing complexity measures defined in the literature, this paper considers production quality into the measure of the process capability on handling the complexity induced by the input demand variety. Examples are given in the paper to discuss different properties of the defined metrics and their potential applications.

Many organizations want to predict the number of defects (faults) in software systems, before they are deployed, to gauge the likely delivered quality and maintenance effort. To help in this numerous software metrics and statistical models have been developed, with a correspondingly large literature. We provide a critical review of this literature and the state-of-the-art. Most of the wide range of prediction models use size and complexity metrics to predict defects. Others are based on testing data, the "quality" of the development process, or take a multivariate approach. The authors of the models have often made heroic contributions to a subject otherwise bereft of empirical studies. However, there are a number of serious theoretical and practical problems in many studies. The models are weak because of their inability to cope with the, as yet, unknown relationship between defects and failures. There are fundamental statistical and data quality problems that undermine model validity. More significantly many prediction models tend to model only part of the underlying problem and seriously misspecify it. To illustrate these points the "Goldilock's Conjecture," that there is an optimum module size, is used to show the considerable problems inherent in current defect prediction approaches. Careful and considered analysis of past and new results shows that the conjecture lacks support and that some models are misleading. We recommend holistic models for software defect prediction, using Bayesian Belief Networks, as alternative approaches to the single-issue models used at present. We also argue for research into a theory of "software decomposition" in order to test hypotheses about defect introduction and help construct a better science of software engineering.

Value-added measures can be used to allocate funding to schools, to identify those institutions in need of special attention and to underpin government guidance on targets. In England, there has been a tendency to include in these measures an ever-greater number of contextualising variables and to develop evermore complex models that encourage (or 'impose') in schools a single uniform method of analysing data, but whose intricacies are not fully understood by practitioners. The competing claims of robustness, usability and accessibility remain unresolved because it is unclear whether the purpose of the measurement is teacher accountability, pupil predictability or school improvement. This paper discusses the provenance and shortcomings of value-added measurement in England (and the Pupil Level Annual Schools Census that informs it) including the fact that although the metrics are essential for School Effectiveness Research, they fail to capture in its entirety the differential effectiveness of schools across the prior attainment range and across subgroups of students and subjects.

Cascading style sheets (CSS) is a Web-based style sheet language that is used for the presentation of Web documents. CSS has advanced from CSS1 to CSS3.and extensions to CSS known as CSS pre-processors have also emerged in the last few years. As is the case with regular software, CSS have inherent complexity that keeps on increasing with age which is undesirable, and metrics are needed to measure with the aim of controlling it. Although several Web metrics have been proposed in the literature, the area of stylesheets is still lagging. Findings show that few CSS-related metrics exist, and there is no evidence of proof for their mathematical soundness through the popularly known frameworks such as Briand framework and Weyuker's properties. In addition, they have not been empirically validated. In order to address this gap, future studies should focus on defining and validating new metrics for CSS and its pre-processors.

We study the problem of computing maximum flow rates for capacity estimation of an airspace at a constant flight level in the presence of convective weather constraints, under various operational conditions. Our problem statements are for future Air Traffic Management (ATM) operations where jetway routing is removed and aircraft routes may conform with the geometry of weather constraints. We consider several ATM flow organizations: All Altitudes (aircraft flying in any direction), Alternating Altitude Rule (aircraft flying with headings from 0° to 180°, versus 180° to 360°), Monotonic Rule (aircraft flying in from the east), and Unidirectional (aircraft flying from east to west). We investigate both decentralized Free Flight scenarios and centralized Packed scenarios under each flow organization. For each flow organization, we compute the maximum flow rates for the airspace through experimental analysis based on simulated demand for travel through the airspace and routes computed using an algorithmic solution. We compare the throughput, observed in simulations, to the theoretical upper bounds we compute using network flow theory adapted to the geometric problem domain. We also compute a complexity metric to evaluate the solutions computed under each flow organization. Experiments are based on both real and synthesized weather data.

AbstractÐThe dearth of published empirical data on major industrial systems has been one of the reasons that software engineering has failed to establish a proper scientific basis. In this paper, we hope to provide a small contribution to the body of empirical knowledge. We describe a number of results from a quantitative study of faults and failures in two releases of a major commercial system. We tested a range of basic software engineering hypotheses relating to: The Pareto principle of distribution of faults and failures; the use of early fault data to predict later fault and failure data; metrics for fault prediction; and benchmarking fault data. For example, we found strong evidence that a small number of modules contain most of the faults discovered in prerelease testing and that a very small number of modules contain most of the faults discovered in operation. However, in neither case is this explained by the size or complexity of the modules. We found no evidence to support previous claims relating module size to fault density nor did we find evidence that popular complexity metrics are good predictors of either fault-prone or failure-prone modules. We confirmed that the number of faults discovered in prerelease testing is an order of magnitude greater than the number discovered in 12 months of operational use. We also discovered fairly stable numbers of faults discovered at corresponding testing phases. Our most surprising and important result was strong evidence of a counter-intuitive relationship between pre-and postrelease faults: Those modules which are the most fault-prone prerelease are among the least fault-prone postrelease, while conversely, the modules which are most faultprone postrelease are among the least fault-prone prerelease. This observation has serious ramifications for the commonly used fault density measure. Not only is it misleading to use it as a surrogate quality measure, but, its previous extensive use in metrics studies is shown to be flawed. Our results provide data-points in building up an empirical picture of the software development process. However, even the strong results we have observed are not generally valid as software engineering laws because they fail to take account of basic explanatory data, notably testing effort and operational usage. After all, a module which has not been tested or used will reveal no faults, irrespective of its size, complexity, or any other factor.

Maintainers face the daunting task of wading through a collection of both new and old revisions, trying to ferret out revisions which warrant personal inspection. One can rank revisions by size/lines of code (LOC), but often, due to the distribution of the size of changes, revisions will be of similar size. If we can't rank revisions by LOC perhaps we can rank by Halstead's and McCabe's complexity metrics? However, these metrics are problematic when applied to code fragments (revisions) written in multiple languages: special parsers are ...

This study examines verb processing during sentence comprehension. We describe two experiments that assess whether or not a verb's representational complexity affects real-time sentence processing in normal listeners. Complexity is defined in terms of the kinds of structural information arrayed against verbs in their lexical entries-syntactic subcategorization and argument structure. Subjects had to perform a complex secondary task presented in the immediate vicinity of the verb while listening to a sentence for meaning. Reaction times to this secondary task show that the relevant verb complexity metric for sentence processing involves the argument structure of verbs and not syntactic subcategorization, and that it is the number of different argument structure possibilities for a verb that counts in this respect. These data reflect the operation of a processing device that momentarily activates all argument structures for a verb in the verb's immediate temporal vincinity during sentence comprehension .