Thu, 21 Aug 2008 14:18:35 BST CiteULike: swiftwatch's library [154 articles] http://www.citeulike.org/user/swiftwatch CiteULike.org en-gb Copyright © 2004-2008 citeulike.org http://www.citeulike.org/user/swiftwatch/article/2925256 <i>IEEE Softw., Vol. 7, No. 2. (March 1990), pp. 17-25.</i> Design Measurement: Some Lessons Learned Dieter Rombach IEEE Softw., Vol. 7, No. 2. (March 1990), pp. 17-25. 2008-06-25T06:50:54-00:00 1990 IEEE Softw. 0740-7459 7 2 17 25 IEEE Computer Society Press design lessons measurement http://www.citeulike.org/user/swiftwatch/article/2712604 <i>Software Engineering, IEEE Transactions on, Vol. 17, No. 6. (1991), pp. 636-638.</i><br /><br />Properties for software complexity measures are discussed. It is shown that a collection of nine properties suggested by E.J. Weyuker is inadequate for determining the quality of a software complexity measure. (see ibid., vol.14, p.1357-65, 1988). A complexity measure which satisfies all nine of the properties, but which has absolutely no practical utility in measuring the complexity of a program is presented. It is concluded that satisfying all of the nine properties is a necessary, but not sufficient, condition for a good complexity measure On Weyuker's axioms for software complexity measures JC Cherniavsky CH Smith doi:10.1109/32.87287 Software Engineering, IEEE Transactions on, Vol. 17, No. 6. (1991), pp. 636-638. 2008-04-24T10:08:14-00:00 1991 Software Engineering, IEEE Transactions on 17 6 636 638 complexity measurement validation weyuker http://www.citeulike.org/user/swiftwatch/article/2885400 <i>(1981), pp. 81-88.</i> On the relationships among three software metrics Sallie Henry Dennis Kafura Kathy Harris doi:10.1145/800003.807911 (1981), pp. 81-88. 2008-06-12T06:33:07-00:00 1981 81 88 ACM correlation flow information metrics http://www.citeulike.org/user/swiftwatch/article/2057824 <i>IEEE Trans. Softw. Eng., Vol. 32, No. 12. (December 2006), pp. 971-987.</i><br /><br />Senior Member-Brad A. Myers An Exploratory Study of How Developers Seek, Relate, and Collect Relevant Information during Software Maintenance Tasks Andrew Ko Michael Coblenz Htet Aung doi:10.1109/TSE.2006.116 IEEE Trans. Softw. Eng., Vol. 32, No. 12. (December 2006), pp. 971-987. 2007-12-04T19:19:51-00:00 2006 IEEE Trans. Softw. Eng. 0098-5589 32 12 971 987 IEEE Press comprehension debugging empirical experiment maintenance http://www.citeulike.org/user/swiftwatch/article/2818401 <i>(2008), pp. 301-310.</i> Debugging reinvented: asking and answering why and why not questions about program behavior Andrew Ko Brad Myers doi:10.1145/1368088.1368130 (2008), pp. 301-310. 2008-05-21T06:54:08-00:00 2008 301 310 ACM analysis debugging dynamic program slicing static http://www.citeulike.org/user/swiftwatch/article/1191882 <i>Software Engineering, IEEE Transactions on, Vol. 25, No. 4. (1999), pp. 456-473.</i><br /><br />Experimentation in software engineering is necessary but difficult. One reason is that there are a large number of context variables and, so, creating a cohesive understanding of experimental results requires a mechanism for motivating studies and integrating results. It requires a community of researchers that can replicate studies, vary context variables, and build models that represent the common observations about the discipline. The paper discusses the experience of the authors, based upon a collection of experiments, in terms of a framework for organizing sets of related studies. With such a framework, experiments can be viewed as part of common families of studies, rather than being isolated events. Common families of studies can contribute to important and relevant hypotheses that may not be suggested by individual experiments. A framework also facilitates building knowledge in an incremental manner through the replication of experiments within families of studies. To support the framework, the paper discusses the experiences of the authors in carrying out empirical studies, with specific emphasis on persistent problems encountered in experimental design, threats to validity, criteria for evaluation, and execution of experiments in the domain of software engineering Building knowledge through families of experiments VR Basili F Shull F Lanubile doi:10.1109/32.799939 Software Engineering, IEEE Transactions on, Vol. 25, No. 4. (1999), pp. 456-473. 2007-03-28T16:42:09-00:00 1999 Software Engineering, IEEE Transactions on 25 4 456 473 empirical experiment families model validation http://www.citeulike.org/user/swiftwatch/article/1281500 <i>Program Comprehension, 2006. ICPC 2006. 14th IEEE International Conference on (2006), pp. 74-78.</i><br /><br />During initial program comprehension, software engineers could benefit from knowing the most need-to-beunderstood classes in the system under study in order to kick-start their software reconnaissance. Previously we have used webmining techniques on runtime trace data to identify these important classes. Here, we reprise this webmining technique and make a thorough comparison of its effectiveness when collecting static information of the software system under study. Apache Ant and Jakarta JMeter, two medium-scale open source Java software systems, serve as case studies. From publicly available developers notes we conclude that the webmining technique in combination with dynamic analysis provides the best results with a level of recall of 90% when comparing with the developers’ opinion. How Webmining and Coupling Metrics Improve Early Program Comprehension A Zaidman Bart Du Bois S Demeyer doi:10.1109/ICPC.2006.26 Program Comprehension, 2006. ICPC 2006. 14th IEEE International Conference on (2006), pp. 74-78. 2007-05-07T06:07:52-00:00 2006 Program Comprehension, 2006. ICPC 2006. 14th IEEE International Conference on 74 78 comprehension coupling metrics mining web http://www.citeulike.org/user/swiftwatch/article/712835 <i>Software Maintenance and Reengineering, 2002. Proceedings. Sixth European Conference on (2002), pp. 99-107.</i><br /><br />Software quality is an important external software attribute that is difficult to measure objectively. In this case study, we empirically validate a set of object-oriented metrics in terms of their usefulness in predicting fault-proneness, an important software quality indicator We use a set of ten software product metrics that relate to the following software attributes: the size of the software, coupling, cohesion, inheritance, and reuse. Eight hypotheses on the correlations of the metrics with fault-proneness are given. These hypotheses are empirically tested in a case study, in which the client side of a large network service management system is studied. The subject system is written in Java and it consists of 123 classes. The validation is carried out using two data analysis techniques: regression analysis and discriminant analysis Predicting fault-proneness using OO metrics. An industrial case study Ping Yu T Systa H Muller doi:10.1109/CSMR.2002.995794 Software Maintenance and Reengineering, 2002. Proceedings. Sixth European Conference on (2002), pp. 99-107. 2006-06-27T18:43:09-00:00 2002 Software Maintenance and Reengineering, 2002. Proceedings. Sixth European Conference on 99 107 fault-proneness metrics object-oriented prediction http://www.citeulike.org/user/swiftwatch/article/1281491 <i>Program Comprehension, 2006. ICPC 2006. 14th IEEE International Conference on (2006), pp. 3-12.</i><br /><br />Readers of programs have two main sources of domain information: identifier names and comments. When functions are uncommented, as many are, comprehension is almost exclusively dependent on the identifier names. Assuming that writers of programs want to create quality identifiers (e.g., include relevant domain knowledge) how should they go about it? For example, do the initials of a concept name provide enough information to represent the concept? If not, and a longer identifier is needed, is an abbreviation satisfactory or does the concept need to be captured in an identifier that includes full words? Results from a study designed to investigate these questions are reported. The study involved over 100 programmers who were asked to describe twelve different functions. The functions used three different "levels" of identifiers: single letters, abbreviations, and full words. Responses allow the level of comprehension associated with the different levels to be studied. The functions include standard algorithms studied in computer science courses as well as functions extracted from production code. The results show that full word identifiers lead to the best comprehension; however, in many cases, there is no statistical difference between full words and abbreviations. What’s in a Name? A Study of Identifiers D Lawrie C Morrell H Feild D Binkley doi:10.1109/ICPC.2006.51 Program Comprehension, 2006. ICPC 2006. 14th IEEE International Conference on (2006), pp. 3-12. 2007-05-07T06:01:11-00:00 2006 Program Comprehension, 2006. ICPC 2006. 14th IEEE International Conference on 3 12 empirical identifiers study http://www.citeulike.org/user/swiftwatch/article/2450177 <i>Software Engineering, IEEE Transactions on, Vol. 33, No. 1. (2007), pp. 2-13.</i><br /><br />The value of using static code attributes to learn defect predictors has been widely debated. Prior work has explored issues like the merits of "McCabes versus Halstead versus lines of code counts" for generating defect predictors. We show here that such debates are irrelevant since how the attributes are used to build predictors is much more important than which particular attributes are used. Also, contrary to prior pessimism, we show that such defect predictors are demonstrably useful and, on the data studied here, yield predictors with a mean probability of detection of 71 percent and mean false alarms rates of 25 percent. These predictors would be useful for prioritizing a resource-bound exploration of code that has yet to be inspected Data Mining Static Code Attributes to Learn Defect Predictors T Menzies J Greenwald A Frank doi:10.1109/TSE.2007.256941 Software Engineering, IEEE Transactions on, Vol. 33, No. 1. (2007), pp. 2-13. 2008-03-01T06:01:41-00:00 2007 Software Engineering, IEEE Transactions on 33 1 2 13 data defect mccabe mining prediction http://www.citeulike.org/user/swiftwatch/article/2450162 <i>Software Maintenance, 2005. ICSM'05. Proceedings of the 21st IEEE International Conference on (2005), pp. 101-110.</i><br /><br />Distributed applications provide numerous advantages related to software performance, reliability, interoperability, and extensibility. This paper focuses on distributed Java programs built with the help of the remote method invocation (RMI) mechanism. We consider points-to analysis for such applications. Points-to analysis determines the objects pointed to by a reference variable or a reference object field. Such information plays a fundamental role as a prerequisite for many other static analyses. We present the first theoretical definition of points-to analysis for RMI-based Java applications, and an algorithm for implementing a flow- and context-insensitive points-to analysis for such applications. We also discuss the use of points-to information for computing call graph information, for understanding data dependencies due to remote memory locations, and for identifying opportunities for improving the performance of object serialization at remote calls. The work described in this paper solves one key problem for static analysis of RMI programs, and provides a starting point for future work on improving the understanding, testing, verification, and performance of RMI-based software. Static analysis of object references in RMI-based Java software M Sharp A Rountev doi:10.1109/ICSM.2005.84 Software Maintenance, 2005. ICSM'05. Proceedings of the 21st IEEE International Conference on (2005), pp. 101-110. 2008-03-01T05:52:54-00:00 2005 Software Maintenance, 2005. ICSM'05. Proceedings of the 21st IEEE International Conference on 101 110 analysis java rmi static http://www.citeulike.org/user/swiftwatch/article/2450155 <i>(1987), pp. 100-113.</i> Comprehension strategies in programming Nancy Pennington (1987), pp. 100-113. 2008-03-01T05:44:50-00:00 1987 100 113 Ablex Publishing Corp. comprehension program strategies http://www.citeulike.org/user/swiftwatch/article/2446040 <i>Proceedings of the IEEE, Vol. 68, No. 9. (1980), pp. 1144-1157.</i><br /><br />The contributions of measurement and experimentation to the state of the art in software engineering are reviewed. The role of measurement in developing theoretical models is discussed, and concerns for reliability and validity are stressed. Current approaches to measuring software characteristics are presented as examples. In particular, software complexity metrics related to control flow, module interconnectedness, and Halstead's Software Science are discussed. The use of experimental methods in evaluating cause-effect relationships is also discussed. Example programs of experimental research which investigated conditional statements and control flow are reviewed. The conclusion argues that many advances in software engineering will be related to improvements in the measurement and experimental evaluation of software techniques and practices. Measurement and experimentation in software engineering B Curtis Proceedings of the IEEE, Vol. 68, No. 9. (1980), pp. 1144-1157. 2008-02-29T02:04:50-00:00 1980 Proceedings of the IEEE 68 9 1144 1157 empirical experiment measurement http://www.citeulike.org/user/swiftwatch/article/2439879 <i>Empirical Software Engineering, Vol. 2, No. 3. (1997), pp. 313-316.</i> Comments to the Paper: Briand, Eman, Morasca: On the Application of Measurement Theory in Software Engineering Horst Zuse doi:10.1023/A:1009772101672 Empirical Software Engineering, Vol. 2, No. 3. (1997), pp. 313-316. 2008-02-28T05:11:13-00:00 1997 Empirical Software Engineering 2 3 313 316 briand comments measurement theory http://www.citeulike.org/user/swiftwatch/article/2439803 <i>Empirical Software Engineering, Vol. 1, No. 1. (1 January 1996), pp. 61-88.</i><br /><br />Elements of measurement theory have recently been introduced into the software engineering discipline. It has been suggested that these elements should serve as the basis for developing, reasoning about, and applying measures. For example, it has been suggested that software complexity measures should be additive, that measures fall into a number of distinct types (i.e., levels of measurement: nominal, ordinal, interval, and ratio), that certain statistical techniques are not appropriate for certain types of measures (e.g., parametric statistics for less-than-interval measures), and that certain transformations are not permissible for certain types of measures (e.g., non-linear transformations for interval measures). In this paper we argue that, inspite of the importance of measurement theory, and in the context of software engineering, many of these prescriptions and proscriptions are either premature or, if strictly applied, would represent a substantial hindrance to the progress of empirical research in software engineering. This argument is based partially on studies that have been conducted by behavioral scientists and by statisticians over the last five decades. We also present a pragmatic approach to the application of measurement theory in software engineering. While following our approach may lead to violations of the strict prescriptions and proscriptions of measurement theory, we demonstrate that in practical terms these violations would have diminished consequences, especially when compared to the advantages afforded to the practicing researcher. On the application of measurement theory in software engineering Lionel Briand Khaled Emam Sandro Morasca doi:10.1007/BF00125812 Empirical Software Engineering, Vol. 1, No. 1. (1 January 1996), pp. 61-88. 2008-02-28T04:44:36-00:00 1996 Empirical Software Engineering 1 1 61 88 empirical measurement theory http://www.citeulike.org/user/swiftwatch/article/2428610 <i>IEEE Trans. Softw. Eng., Vol. 22, No. 10. (October 1996), pp. 751-761.</i> A Validation of Object-Oriented Design Metrics as Quality Indicators Victor Basili Lionel Briand Walcélio Melo IEEE Trans. Softw. Eng., Vol. 22, No. 10. (October 1996), pp. 751-761. 2008-02-26T07:07:54-00:00 1996 IEEE Trans. Softw. Eng. 0098-5589 22 10 751 761 IEEE Press empirical fault-proneness metrics quality validation http://www.citeulike.org/user/swiftwatch/article/2428601 <i>(2001)</i> A Study on Fault-Proneness Detection of Object-Oriented Systems F Fioravanti P Nesi (2001) 2008-02-26T07:03:56-00:00 2001 IEEE Computer Society fault-proneness metrics prediction http://www.citeulike.org/user/swiftwatch/article/2424082 <i>(1995)</i> Foundations of Software Measurement Martin Shepperd (1995) 2008-02-25T02:57:38-00:00 1995 Prentice Hall measurement http://www.citeulike.org/user/swiftwatch/article/2424063 <i>(1991)</i> Object-oriented design Peter Coad Edward Yourdon (1991) 2008-02-25T02:44:03-00:00 1991 Yourdon Press cohesion coupling design object-oriented http://www.citeulike.org/user/swiftwatch/article/2396935 <i>Software Engineering, IEEE Transactions on, Vol. 33, No. 10. (2007), pp. 687-708.</i><br /><br />We present a comprehensive study of an implementation of the Smalltalk object oriented system, one of the first and purest object-oriented programming environment, searching for scaling laws in its properties. We study ten system properties, including the distributions of variable and method names, inheritance hierarchies, class and method sizes, system architecture graph. We systematically found Pareto - or sometimes log-normal - distributions in these properties. This denotes that the programming activity, even when modeled from a statistical perspective, can in no way be simply modeled as a random addition of independent increments with finite variance, but exhibits strong organic dependencies on what has been already developed. We compare our results with similar ones obtained for large Java systems, reported in the literature or computed by ourselves for those properties never studied before, showing that the behavior found is similar in all studied object oriented systems. We show how the Yule process is able to stochastically model the generation of several of the power-laws found, identifying the process parameters and comparing theoretical and empirical tail indexes. Lastly, we discuss how the distributions found are related to existing object-oriented metrics, like Chidamber and Kemerer's, and how they could provide a starting point for measuring the quality of a whole system, versus that of single classes. In fact, the usual evaluation of systems based on mean and standard deviation of metrics can be misleading. It is more interesting to measure differences in the shape and coefficients of the data?s statistical distributions. Power-Laws in a Large Object-Oriented Software System Giulio Concas Michele Marchesi Sandro Pinna Nicola Serra doi:10.1109/TSE.2007.1019 Software Engineering, IEEE Transactions on, Vol. 33, No. 10. (2007), pp. 687-708. 2008-02-19T01:50:22-00:00 2007 Software Engineering, IEEE Transactions on 33 10 687 708 empirical law power http://www.citeulike.org/user/swiftwatch/article/2390087 <i>Commun. ACM, Vol. 14, No. 4. (April 1971), pp. 221-227.</i> Program development by stepwise refinement Niklaus Wirth doi:10.1145/362575.362577 Commun. ACM, Vol. 14, No. 4. (April 1971), pp. 221-227. 2008-02-17T05:06:21-00:00 1971 Commun. ACM 0001-0782 14 4 221 227 ACM 8-queens education refinement stepwise http://www.citeulike.org/user/swiftwatch/article/2332956 <i>Software Engineering, Transactions on, Vol. 27, No. 4. (2001), pp. 337-350.</i><br /><br />Software size is a fundamental product measure that can be used for assessment, prediction and improvement purposes. However, existing software size measures, such as function points, do not address the underlying problem complexity of software systems adequately. This can result in disproportional measures of software size for different types of systems. We propose a vector size measure (VSM) that incorporates both functionality and problem complexity in a balanced and orthogonal manner. The VSM is used as the input to a vector prediction model (VPM) which can be used to estimate development effort early in the software life-cycle. We theoretically validate the approach against a formal framework. We also empirically validate the approach with a pilot study. The results indicate that the approach provides a mechanism to measure the size of software systems, classify software systems, and estimate development effort early in the software life-cycle to within ±20% across a range of application types A vector-based approach to software size measurement and effort estimation TE Hastings ASM Sajeev doi:10.1109/32.917523 Software Engineering, Transactions on, Vol. 27, No. 4. (2001), pp. 337-350. 2008-02-05T02:10:40-00:00 2001 Software Engineering, Transactions on 27 4 337 350 effort estimation measurement size vector http://www.citeulike.org/user/swiftwatch/article/2235025 <i>(2004), pp. 53-59.</i> A solar system metaphor for 3D visualisation of object oriented software metrics Hamish Graham Hong Yang Rebecca Berrigan (2004), pp. 53-59. 2008-01-15T13:38:25-00:00 2004 53 59 Australian Computer Society, Inc. 3d metrics solar-system visualisation http://www.citeulike.org/user/swiftwatch/article/984431 <i>(2005), pp. 13-19.</i> Evaluating and tuning a static analysis to find null pointer bugs David Hovemeyer Jaime Spacco William Pugh doi:10.1145/1108792.1108798 (2005), pp. 13-19. 2006-12-08T13:39:19-00:00 2005 13 19 ACM Press analysis bugs dereference null pointer static http://www.citeulike.org/user/swiftwatch/article/2233693 <i>SIGPLAN Not., Vol. 42, No. 6. (June 2007), pp. 435-445.</i> Static error detection using semantic inconsistency inference Isil Dillig Thomas Dillig Alex Aiken doi:10.1145/1273442.1250784 SIGPLAN Not., Vol. 42, No. 6. (June 2007), pp. 435-445. 2008-01-15T05:45:55-00:00 2007 SIGPLAN Not. 0362-1340 42 6 435 445 ACM analysis c dereference detection err null static http://www.citeulike.org/user/swiftwatch/article/2227781 <i>Software Engineering Conference, 2005. Proceedings. 2005 Australian (2005), pp. 212-221.</i><br /><br />Coupling is considered by many to be an important concept in measuring design quality There is still much to be learned about which aspects of coupling affect design quality or other external attributes of software. Much of the existing work concentrates on direct coupling, that is, forms of coupling that exists between entities that are directly related to each other. A form of coupling that has so far received little attention is indirect coupling, that is, coupling between entities that are not directly related. What little discussion there is in the literature suggests that any form of indirect coupling is simple the transitive closure of a form of direct coupling. We demonstrate that this is not the case, that there are forms of indirect coupling that cannot be represented in this way and suggest ways to measure it. We present a tool that identifies a particular form of indirect coupling that is integrated in the Eclipse IDE. Detecting indirect coupling Hong Yang E Tempero R Berrigan doi:10.1109/ASWEC.2005.22 Software Engineering Conference, 2005. Proceedings. 2005 Australian (2005), pp. 212-221. 2008-01-14T00:05:54-00:00 2005 Software Engineering Conference, 2005. Proceedings. 2005 Australian 212 221 analysis coupling eclipse indirect plugin http://www.citeulike.org/user/swiftwatch/article/2227773 <i>Software Engineering Conference, 2007. ASWEC 2007. 18th Australian (2007), pp. 319-328.</i><br /><br />It is widely accepted that coupling plays an important role in software quality, particularly in the areas of software maintenance, so effort should be made to keep coupling levels to a minimum in order to reduce the complexity of the system. We have previously introduced the concept of "indirect" coupling - coupling formed by relationships/dependencies that are not directly evident - with the belief that high levels of indirect coupling can constitute greater costs to maintenance as it is harder to detect. In this paper we extend our previous studies by proposing metrics that can advance our understanding of the exact relationship between indirect coupling and maintainability. In particulars the metrics focus on the reflection of "strength" as it is a fundamental component of coupling. We present our observations on the results of applying the metrics to existing Java applications. Measuring the Strength of Indirect Coupling HY Yang E Tempero doi:10.1109/ASWEC.2007.28 Software Engineering Conference, 2007. ASWEC 2007. 18th Australian (2007), pp. 319-328. 2008-01-14T00:03:29-00:00 2007 Software Engineering Conference, 2007. ASWEC 2007. 18th Australian 319 328 coupling empirical indirect metrics http://www.citeulike.org/user/swiftwatch/article/2190660 <i>(2007), pp. 405-422.</i> Tracking bad apples: reporting the origin of null and undefined value errors Michael Bond Nicholas Nethercote Stephen Kent Samuel Guyer Kathryn Mckinley (2007), pp. 405-422. 2008-01-03T05:56:01-00:00 2007 405 422 ACM analysis null program tracking http://www.citeulike.org/user/swiftwatch/article/690278 <i>(2006), pp. 341-350.</i> On the success of empirical studies in the international conference on software engineering Carmen Zannier Grigori Melnik Frank Maurer doi:10.1145/1134285.1134333 (2006), pp. 341-350. 2006-06-09T02:47:48-00:00 2006 341 350 ACM Press empirical icse study http://www.citeulike.org/user/swiftwatch/article/1905019 <i></i> Indus project site 2007-11-13T01:52:31-00:00 analysis bytecode framework java program http://www.citeulike.org/user/swiftwatch/article/1905018 <i>(2004)</i><br /><br />We apply data mining to version histories in order to guide programmers along related changes: "Programmers who changed these functions also changed.... Given a set of existing changes, the mined association rules 1) suggest and predict likely further changes, 2) show up item coupling that is undetectable by program analysis, and 3) can prevent errors due to incomplete changes. After an initial change, our ROSE prototype can correctly predict further locations to be changed; the best predictive power is obtained for changes to existing software. In our evaluation based on the history of eight popular open source projects, ROSE's topmost three suggestions contained a correct location with a likelihood of more than 70 percent. Mining Version Histories to Guide Software Changes Thomas Zimmermann Peter Weissgerber Stephan Diehl Andreas Zeller (2004) 2007-11-13T01:52:31-00:00 2004 change coupling data mining http://www.citeulike.org/user/swiftwatch/article/1905017 <i>(1999)</i><br /><br />Understanding program dependencies in a computer program is essential for many software engineering activities including program slicing, testing, debugging, reverse engineering, and maintenance. In this paper, we present a dependence-based representation called the multithreaded dependence graph, which extends previous dependence-based representations, to represent program dependencies in a concurrent Java program. We also discuss some important applications of a multithreaded dependence graph in a maintenance environment for concurrent Java programs. Multithreaded Dependence Graphs for Concurrent Java Program Jianjun Zhao (1999) 2007-11-13T01:52:31-00:00 1999 IEEE Computer Society analysis concurrent dependence graph java program http://www.citeulike.org/user/swiftwatch/article/1905016 <i>(October 2000), pp. 486-491.</i><br /><br />Understanding program dependencies in a computer program is essential for many software engineering tasks such as program understanding, testing, debugging, reverse engineering, and maintenance. In this paper, we present an approach to dependence analysis of Java bytecode, and discuss some applications of our technique, which include Java bytecode slicing, understanding, and testing. Dependence Analysis of Java Bytecode Jianjun Zhao (October 2000), pp. 486-491. 2007-11-13T01:52:31-00:00 2000 486 491 analysis bytecode dependence java http://www.citeulike.org/user/swiftwatch/article/1905015 <i>(1999)</i><br /><br />Imagine some program and a number of changes. If none of these changes is applied ("yesterday"), the program works. If all changes are applied ("today"), the program does not work. Which change is responsible for the failure? We present an efficient algorithm that determines the minimal set of failure-inducing changes. Our delta debugging prototype tracked down a single failure-inducing change from 178,000 changed GDB lines within a few hours. Yesterday My Program worked. Today, It Does Not. Why? Andreas Zeller (1999) 2007-11-13T01:52:31-00:00 1999 analysis change debugging delta http://www.citeulike.org/user/swiftwatch/article/1905014 <i>(2001)</i><br /><br />Large software systems are difficult to understand and maintain. Program dependency analysis plays a key role in both understanding and maintenance. This paper discusses hidden dependencies among software components that make both understanding and maintenance hard. Hidden dependency is a relationship between two seemingly independent components and it is caused by a data flow inside of a third software components. The paper uses Abstract System Dependence Graphs to define hidden dependencies. It discusses the impact of hidden dependencies on the process of change propagation and also discusses an algorithm that warns about possible presence of hidden dependencies. Hidden Dependencies in Program Comprehension and Change Propagation Zhifeng Yu Vaclav Rajlich (2001) 2007-11-13T01:52:31-00:00 2001 IEEE Computer Society analysis change dependency hidden program http://www.citeulike.org/user/swiftwatch/article/1905013 <i>IEEE Trans. Software Eng., Vol. 30, No. 10. (2004), pp. 694-706.</i><br /><br />Data coupling between modules, especially common coupling, has long been considered a source of concern in software design, but the issue is somewhat more complicated for products that are comprised of kernel modules together with optional nonkernel modules. This paper presents a refined categorization of common coupling based on definitions and uses between kernel and nonkernel modules and applies the categorization to a case study. Common coupling is usually avoided when possible because of the potential for introducing risky dependencies among software modules. The relative risk of these dependencies is strongly related to the specific definition-use relationships. In a previous paper, we presented results from a longitudinal analysis of multiple versions of the open-source operating system Linux. This paper applies the new common coupling categorization to version 2.4.20 of Linux, counting the number of instances of common coupling between each of the 26 kernel modules and all the other nonkernel modules. We also categorize each coupling in terms of the definition-use relationships. Results show that the Linux kernel contains a large number of common couplings of all types, raising a concern about the long-term maintainability of Linux. Categorization of Common Coupling and Its Application to the Maintainability of the Linux Kernel Liguo Yu Stephen Schach Kai 0003 Jefferson Offutt IEEE Trans. Software Eng., Vol. 30, No. 10. (2004), pp. 694-706. 2007-11-13T01:52:31-00:00 2004 IEEE Trans. Software Eng. 30 10 694 706 analysis common coupling longitudinal maintainability http://www.citeulike.org/user/swiftwatch/article/1905012 <i>(1979)</i> Structured Design: Fundamentals of a Discipline of Computer Program and System Design Edward Yourdon Larry Constantine (1979) 2007-11-13T01:52:31-00:00 1979 Prentice-Hall cohesion coupling design modularity structured http://www.citeulike.org/user/swiftwatch/article/1905011 <i>(2005)</i><br /><br />This paper presents the results of an empirical study carried out to investigate if the complexity profile graph (CPG) is related with one of the predicators of software complexity measures, such as response time and error rate, and thus could be used as a valid indicator of program comprehensibility. Lower and upper division computer science and software engineering students were asked to respond to questions regarding the execution of a source code module written in JAVA and understanding the fundamental goal of each part of the source code. The response time for each question and the correctness of each response were recorded. The statistical analysis of the experimental data reports that there is a positive linear correlation between the CPG and the time taken to respond correctly to each question. In addition, the paper discusses if there is any effect of the control structure diagram (CSD) on measuring the difficulty of program comprehensibility. An Empirical Validation of Complexity Profile Graph Jeong Yang Dean Hendrix Kai Chang David Umphress (2005) 2007-11-13T01:52:30-00:00 2005 complexity empirical metric validation http://www.citeulike.org/user/swiftwatch/article/1905008 <i>ACM SIGPLAN, Vol. 36 (2001), pp. 70-76.</i><br /><br />Dependence analysis is an important approach to analyzing, understanding, testing and maintaining programs. This paper develops a new kind of dependence analysis method for recursive Java programs. In our method, the program dependence graph (PDG) of a Java program consists of a set of PDGs that are not connected. They interact with each other by dependences among parameters. Thus, he inter-function dependence analysis is transformed to intra-function dependence analysis. Based on this model, we develop a new approach to analyze dependences of a direct or indirect recursive Java program by simulating its execution. Dependence Analysis for Recursive Java Programs Baowen Xu Zheniang Chen ACM SIGPLAN, Vol. 36 (2001), pp. 70-76. 2007-11-13T01:52:30-00:00 2001 ACM SIGPLAN 36 70 76 analysis dependence java recursive http://www.citeulike.org/user/swiftwatch/article/1905007 <i>IEEE Transactions on Software Engineering, Vol. 14, No. 9. (September 1988), pp. 1357-1365.</i><br /><br />A set of properties of syntactic software complexity measures is proposed to serve as a basis for the evaluation of such measures. Four known complexity measures are evaluated and compared using these criteria. This formalized evaluation clarifies the strengths and weaknesses of the examined complexity measures, which include the statement count, cyclomatic number, effort measure, and data flow complexity measures. None of these measures possesses all nine properties, and several are found to fail to possess particularly fundamental properties; this failure calls into question their usefulness in measuring synthetic complexity. Evaluating Software Complexity Measures Elaine Weyuker IEEE Transactions on Software Engineering, Vol. 14, No. 9. (September 1988), pp. 1357-1365. 2007-11-13T01:52:30-00:00 1988 IEEE Transactions on Software Engineering 14 9 1357 1365 complexity empirical metric validation http://www.citeulike.org/user/swiftwatch/article/1905006 <i>IEEE Transactions on Software Engineering, Vol. 16, No. 2. (1990), pp. 121-128.</i><br /><br />A family of test data adequacy criteria employing data-flow information was previously proposed, and a theoretical complexity analysis was performed. The author describes an empirical study to determine the actual cost of using these criteria. The aim is to establish the practical usefulness of these criteria in testing software and provide a basis for predicting the amount of testing needed for a given program. The first goal of the study is to confirm the belief that the family of software testing criteria considered is practical to use. An attempt is made to show that even as the program size increases, the amount of testing, expressed in terms of the number of test cases sufficient to satisfy a given criterion, remains modest. Several ways of evaluating this hypothesis are explored. The second goal is to provide the prospective user of these criteria with a way of predicting the number of test cases that will be needed to satisfy a given criterion for a given program. This provides testers with a basis for selecting the most comprehensive criterion that they can expect to satisfy. Several plausible bases for such a prediction are considered. The Cost of Data Flow Testing: An Empirical Study EJ Weyuker IEEE Transactions on Software Engineering, Vol. 16, No. 2. (1990), pp. 121-128. 2007-11-13T01:52:30-00:00 1990 IEEE Transactions on Software Engineering 16 2 121 128 IEEE Computer Society data empirical flow study testing http://www.citeulike.org/user/swiftwatch/article/1905005 <i>IEEE Trans. Software Eng., Vol. 10, No. 4. (1984), pp. 352-357.</i><br /><br />Program slicing is a method used by experienced computer programmers for abstracting from programs. Starting from a subset of a program's behavior, slicing reduces that program to a minimal form which still produces that behavior. The reduced program, called a "slice", is an independent program guaranteed to faithfully represent the original program within the domain of the specified subset of behavior. Finding a slice is in general unsolvable. A dataflow algorithm is presented for approximating slices when the behavior subset is specified as the values of a set of variables at a statement. Experimental evidence is presented that these slices are used by programmers during debugging. Experience with two automatic slicing tools is summarized. New measures of program complexity are suggested based on the organization of a program's slices. Program Slicing Mark Weiser IEEE Trans. Software Eng., Vol. 10, No. 4. (1984), pp. 352-357. 2007-11-13T01:52:30-00:00 1984 IEEE Trans. Software Eng. 10 4 352 357 analysis original program slicing http://www.citeulike.org/user/swiftwatch/article/1905004 <i>(JanuarySeptember-February0 June 2006), pp. 77-84.</i><br /><br />Since it was introduced in 1979, program slicing has been used widely in many aspects of software engineering, such as code debugging, program comprehension, software maintenance and reverse engineering etc. Since 1995, many people have studied and developed some methods and tools to help programmers use program slicing technique in software testing, and some valuable results have been obtained by theoretic and empirical analysis and evaluation. Research results show that program slicing is very useful for regression testing and simplifying testing. In this article, we try to extend the ability of Harman and Danicics robust slicing algorithm by considering how to deal with dynamically allocated storage. Especially, we discuss how to compute the robustness slice when the subscripts of an array are dynamic. An Extension to Robustness Slicing Algorithm Based on Dynamic Array Yancheng Wang Bixin Li Xufang Gong (JanuarySeptember-February0 June 2006), pp. 77-84. 2007-11-13T01:52:30-00:00 2006 77 84 dynamic program robustness slicing http://www.citeulike.org/user/swiftwatch/article/1905003 <i>(2003)</i><br /><br />The Program Dependence Graph was introduced by Ottenstein and Ottenstein in 1984. It was suggested to be a suitable internal program representation for monolithic programs, for the purpose of carrying out certain software engineering operations such as slicing and the computation of program metrics. Since then, Horwitz et al. have introduced the multi-procedural equivalent System Dependence Graph. Several authors have proposed object-oriented dependence graph construction approaches. Every approach provides its own benefits, some of which are language specific. This paper presents a Java System Dependence Graph which draws on the strengths of a range of earlier works and adapts them, if necessary, to the Java language. It also provides guidance on the construction of the graph, identifies potential research topics based on it and shows, in the appendix, a completed graph with a slice highlighted for a small, but realistic example. The Java system dependence graph M Walkinshaw M Roper (2003) 2007-11-13T01:52:30-00:00 2003 dependence graph java system http://www.citeulike.org/user/swiftwatch/article/1905002 <i>(1991), pp. 107-119.</i><br /><br />Program slicing is a source-to-source transformation that has applications in construction, analysis, testing and debugging of programs. A program slice contains the portion of a program that captures some subset of the program behavior. Algorithms are available for constructing slices for a particular execution of a program (dynamic slices) as well as to approximate a subset of the behavior over all possible executions of a program (static slices). As the behavior of a program is determined by the semantics of the language, it is reasonable to expect a semantic justification for the practice of program slicing, Program slices have been used in several applications but there is no single notion of a slice that is useful for all applications. This paper identifies and categorizes different notions of a program slice available in the literature as well as several new notions. The various notions are formalized in a denotational framework. Extending the work by Cartwright and Felleisen [2] on the semantics of program dependence, a semantic justification is provided for the process of program slicing using program dependence graphs. The semantic approach to program slicing GA Venkatesh (1991), pp. 107-119. 2007-11-13T01:52:30-00:00 1991 107 119 ACM Press analysis program semantic slicing http://www.citeulike.org/user/swiftwatch/article/1905001 <i>(Nov. 2006), pp. 137-142.</i><br /><br />This paper presents the development of a hierarchical methodology for speeding-up a symbolic trajectory evaluation (STE) based verification flow, using "program slicing" techniques. An overview of the proposed methodology is described, along with the details of a prototype tool that has been developed to automate the approach. The tool, called FACTOR, has been successfully applied to reduce the size of the RTL implementation of a floating-point unit in an Intelreg Pentiumreg 4 processor model needed for formally verifying an embedded module. The existing proof specification for the module was validated using Forte, Intel's STE tool, on both the original and the reduced model. A comparison of the results demonstrates the effectiveness of the methodology, and its immense potential to scale up the verification flow to larger design sizes Taming the Complexity of STE-based Design Verification Using Program Slicing VM Vedula FL Andersen JA Abraham (Nov. 2006), pp. 137-142. 2007-11-13T01:52:30-00:00 2006 137 142 program slicing ste verification http://www.citeulike.org/user/swiftwatch/article/1905000 <i>(1999)</i><br /><br />This paper presents Soot, a framework for optimizing Java bytecode. The framework is implemented in Java and supports three intermediate representations for representing Java bytecode: Baf, a streamlined representation of bytecode which is simple to manipulate; Jimple, a typed 3-address intermediate representation suitable for optimization; and Grimp, an aggregated version of Jimple suitable for decompilation. We describe the motivation for each representation, and the salient points in translating from one representation to another. In order to demonstrate the usefulness of the framework, we have implemented intraprocedural and whole program optimizations. To show that whole program bytecode optimization can give performance improvements, we provide experimental results for 12 large benchmarks, including 8 SPECjvm98 benchmarks running on JDK 1.2 for GNU/Linux. These results show up to 8 improvement when the optimized bytecode is run using the interpreter and up to 21% when run using the JIT compiler. Soot - a Java bytecode optimization framework Vallee Rai Phong C Etienne G Laurie H Patrick L Vijay (1999) 2007-11-13T01:52:30-00:00 1999 bytecode java optimization soot http://www.citeulike.org/user/swiftwatch/article/1904999 <i>(1998)</i><br /><br />Inheritance is one of the main concepts of object-oriented technology. It is claimed that the use of inheritance improves productivity and decreases development time. John Daly et al. reported on two experiments evaluating the effects of inheritance depth on program maintenance. They found that maintenance was performed significantly quicker for software using three levels of inheritance, compared to equivalent flattened software without inheritance. A second experiment found that maintenance for software using five levels of inheritance tended to be slightly slower than for equivalent software without inheritance. We report on similar experiments on the same question. Our results contradict those mentioned above. Several crucial changes were made to the setup. In particular longer and more complex programs were used, an inheritance diagram was available to the subjects, and we used more and different kinds of maintenance tasks. Furthermore, our experiment design compares zero level, three level and five level inheritance directly in one experiment. The results suggest that there is a tendency that deeper inheritance may complicate program understanding. But the effect depends rather on other factors such as complexity of the program and type of maintenance task than on inheritance depth. We found a high correlation between maintenance time and the number of methods to trace to gain program understanding. Further work should be done to identify other influence factors. The impact of inheritance depth on maintenance tasks --- Detailed description and evaluation of two experiment replications Barbara Unger Lutz Prechelt (1998) 2007-11-13T01:52:30-00:00 1998 experiment inheritance maintenance http://www.citeulike.org/user/swiftwatch/article/1904998 <i>SIGPLAN Not., Vol. 40, No. 10. (2005), pp. 211-230.</i><br /><br />This paper describes a type system that is capable of expressing and enforcing immutability constraints. The specific constraint expressed is that the abstract state of the object to which an immutable reference refers cannot be modified using that reference. The abstract state is (part of) the transitively reachable state: that is, the state of the object and all state reachable from it by following references. The type system permits explicitly excluding fields from the abstract state of an object. For a statically type-safe language, the type system guarantees reference immutability. If the language is extended with immutability downcasts, then run-time checks enforce the reference immutability constraints.This research builds upon previous research in language support for reference immutability. Improvements that are new in this paper include distinguishing the notions of assignability and mutability; integration with Java 5's generic types and with multi-dimensional arrays; a mutability polymorphism approach to avoiding code duplication; type-safe support for reflection and serialization; and formal type rules and type soundness proof for a core calculus. Furthermore, it retains the valuable features of the previous dialect, including usability by humans (as evidenced by experience with 160,000 lines of Javari code) and interoperability with Java and existing JVMs. Javari: adding reference immutability to Java Matthew Tschantz Michael Ernst SIGPLAN Not., Vol. 40, No. 10. (2005), pp. 211-230. 2007-11-13T01:52:30-00:00 2005 SIGPLAN Not. 40 10 211 230 ACM Press immutability java reference http://www.citeulike.org/user/swiftwatch/article/1904997 <i>(2004), pp. 317-325.</i><br /><br />A recent industry survey (Townhidnejad and Hilburn, 2002) has reported that more than fifty percent of a software project's budget is spent on activities related to improving software quality. Industry leaders claim that this is caused by the inadequate attention paid to software quality in the development phase. This paper introduces a static analysis framework which can be used to give beginning students practice in writing better quality Java programs and to assist teaching staff in the marking process. The framework uses both software engineering metrics and relative comparison to judge the quality of student's programs and provide feedback about how solutions might be improved. Static analysis of students' Java programs Nghi Truong Paul Roe Peter Bancroft (2004), pp. 317-325. 2007-11-13T01:52:30-00:00 2004 317 325 Australian Computer Society, Inc. analysis java static students