PARTITIONING OBJECT-ORIENTED SOURCE CODE FOR

[1]  Jianjun Zhao.  APPLYING PROGRAM DEPENDENCE ANALYSIS TO JAVA SOFTWARE , 2007 .

[2]  Stéphane Ducasse,et al.  Analyzing feature traces to incorporate the semantics of change in software evolution analysis , 2005, 21st IEEE International Conference on Software Maintenance (ICSM'05).

[3]  Martin P. Robillard,et al.  The Emergent Structure of Development Tasks , 2005, ECOOP.

[4]  Janice Singer,et al.  NavTracks: supporting navigation in software , 2005, 13th International Workshop on Program Comprehension (IWPC'05).

[5]  Margaret-Anne D. Storey,et al.  Theories, Methods and Tools in Program Comprehension: Past, Present and Future , 2005, IWPC.

[6]  Stéphane Ducasse,et al.  Correlating features and code using a compact two-sided trace analysis approach , 2005, Ninth European Conference on Software Maintenance and Reengineering.

[7]  Mik Kersten,et al.  Mylar: a degree-of-interest model for IDEs , 2005, AOSD '05.

[8]  Martin P. Robillard,et al.  How effective developers investigate source code: an exploratory study , 2004, IEEE Transactions on Software Engineering.

[9]  Jens Krinke,et al.  Slicing, Chopping, and Path Conditions with Barriers , 2004, Software Quality Journal.

[10]  Marc Roper,et al.  A novel software visualisation model to support software comprehension , 2004, 11th Working Conference on Reverse Engineering.

[11]  David Hovemeyer,et al.  Finding bugs is easy , 2004, SIGP.

[12]  Monica S. Lam,et al.  Cloning-based context-sensitive pointer alias analysis using binary decision diagrams , 2004, PLDI '04.

[13]  Gregor Snelting,et al.  An improved slicer for Java , 2004, PASTE.

[14]  Mark Harman,et al.  CONSIT: a fully automated conditioned program slicer , 2004, Softw. Pract. Exp..

[15]  Per Runeson,et al.  Are the Perspectives Really Different? – Further Experimentation on Scenario-Based Reading of Requirements , 2000, Empirical Software Engineering.

[16]  James Miller,et al.  A Comparison of Computer Support Systems for Software Inspection , 2004, Automated Software Engineering.

[17]  Forrest Shull,et al.  The empirical investigation of Perspective-Based Reading , 1995, Empirical Software Engineering.

[18]  Robert J. Hall.  Automatic extraction of executable program subsets by simultaneous dynamic program slicing , 2004, Automated Software Engineering.

[19]  Ben Shneiderman,et al.  Syntactic/semantic interactions in programmer behavior: A model and experimental results , 1979, International Journal of Computer & Information Sciences.

[20]  Mats Skoglund,et al.  An Experimental Comparison of the Effectiveness and Usefulness of Inspection Techniques for Object-Oriented Programs , 2004, ICSE 2004.

[21]  Tao Qin,et al.  Discovering use cases from source code using the branch-reserving call graph , 2003, Tenth Asia-Pacific Software Engineering Conference, 2003..

[22]  Neil Walkinshaw,et al.  The Java system dependence graph , 2003, Proceedings Third IEEE International Workshop on Source Code Analysis and Manipulation.

[23]  Paolo Tonella,et al.  Reverse engineering of the interaction diagrams from C++ code , 2003, International Conference on Software Maintenance, 2003. ICSM 2003. Proceedings..

[24]  Paul Anderson,et al.  Design and Implementation of a Fine-Grained Software Inspection Tool , 2003, IEEE Trans. Software Eng..

[25]  Marc Roper,et al.  The Development and Evaluation of Three Diverse Techniques for Object-Oriented Code Inspection , 2003, IEEE Trans. Software Eng..

[26]  Claes Wohlin,et al.  An Experimental Comparison of Usage-Based and Checklist-Based Reading , 2003, IEEE Trans. Software Eng..

[27]  Gail C. Murphy,et al.  Hipikat: recommending pertinent software development artifacts , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[28]  Ondrej Lhoták,et al.  Scaling Java Points-to Analysis Using SPARK , 2003, CC.

[29]  Mark Harman,et al.  Unions of slices are not slices , 2003, Seventh European Conference onSoftware Maintenance and Reengineering, 2003. Proceedings..

[30]  Rainer Koschke,et al.  Locating Features in Source Code , 2003, IEEE Trans. Software Eng..

[31]  Leon Moonen,et al.  Java quality assurance by detecting code smells , 2002, Ninth Working Conference on Reverse Engineering, 2002. Proceedings..

[32]  Jens Krinke,et al.  Evaluating context-sensitive slicing and chopping , 2002, International Conference on Software Maintenance, 2002. Proceedings..

[33]  J. Csirik,et al.  Union slices for program maintenance , 2002, International Conference on Software Maintenance, 2002. Proceedings..

[34]  Craig K. Tyran,et al.  Improving software inspections with group process support , 2002, CACM.

[35]  Martin P. Robillard,et al.  Concern graphs: finding and describing concerns using structural program dependencies , 2002, Proceedings of the 24th International Conference on Software Engineering. ICSE 2002.

[36]  Alastair Peter Dunsmore,et al.  Investigating effective inspection of object-oriented code , 2002 .

[37]  Harvey P. Siy,et al.  Does the modern code inspection have value? , 2001, Proceedings IEEE International Conference on Software Maintenance. ICSM 2001.

[38]  Liang Guo,et al.  Evaluating explicitly context-sensitive program slicing , 2001, PASTE '01.

[39]  Mark Harman,et al.  Backward conditioning: a new program specialisation technique and its application to program comprehension , 2001, Proceedings 9th International Workshop on Program Comprehension. IWPC 2001.

[40]  Douglas R. Vogel,et al.  Using Group Support Systems for Software Inspections , 2001, IEEE Softw..

[41]  Khaled El Emam,et al.  An Internally Replicated Quasi-Experimental Comparison of Checklist and Perspective-Based Reading of Code Documents , 2001, IEEE Trans. Software Eng..

[42]  Giuseppe A. Di Lucca,et al.  Recovering use case models from object-oriented code: a thread-based approach , 2000, Proceedings Seventh Working Conference on Reverse Engineering.

[43]  Laurie J. Hendren,et al.  Practical virtual method call resolution for Java , 2000, OOPSLA '00.

[44]  Colin Atkinson,et al.  An experimental comparison of reading techniques for defect detection in UML design documents , 2000, J. Syst. Softw..

[45]  Václav Rajlich,et al.  Case study of feature location using dependence graph , 2000, Proceedings IWPC 2000. 8th International Workshop on Program Comprehension.

[46]  Marc Roper,et al.  The role of comprehension in software inspection , 2000, J. Syst. Softw..

[47]  M. Roper,et al.  Object-oriented inspection in the face of delocalisation , 2000, Proceedings of the 2000 International Conference on Software Engineering. ICSE 2000 the New Millennium.

[48]  Vivek Sarkar,et al.  Dependence Analysis for Java , 1999, LCPC.

[49]  Shinji Kusumoto,et al.  Call-mark slicing: an efficient and economical way of reducing slice , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[50]  Colin Atkinson,et al.  Generalizing perspective-based inspection to handle object-oriented development artifacts , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[51]  David W. Binkley,et al.  Computing amorphous program slices using dependence graphs , 1999, SAC '99.

[52]  Michael E. Fagan.  Design and Code Inspections to Reduce Errors in Program Development , 1976, IBM Syst. J..

[53]  Ivar Jacobson,et al.  The Unified Software Development Process , 1999 .

[54]  Hausi A. Müller,et al.  Cognitive design elements to support the construction of a mental model during software exploration , 1999, J. Syst. Softw..

[55]  Martin Fowler,et al.  Refactoring - Improving the Design of Existing Code , 1999, Addison Wesley object technology series.

[56]  Aniello Cimitile,et al.  Conditioned program slicing , 1998, Inf. Softw. Technol..

[57]  Donglin Liang,et al.  Slicing objects using system dependence graphs , 1998, Proceedings. International Conference on Software Maintenance (Cat. No. 98CB36272).

[58]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[59]  David Grove,et al.  Call graph construction in object-oriented languages , 1997, OOPSLA '97.

[60]  John Howard,et al.  Hybrid slicing: integrating dynamic information with static analysis , 1997, TSEM.

[61]  Mark Harman,et al.  Amorphous program slicing , 1997, Proceedings Fifth International Workshop on Program Comprehension. IWPC'97.

[62]  Giuliano Antoniol,et al.  Flow Insensitive C++ Pointers and Polymorphism Analysis and its application to slicing , 1997, Proceedings of the (19th) International Conference on Software Engineering.

[63]  Gregor Kiczales,et al.  Aspect-oriented programming , 1996, CSUR.

[64]  David F. Bacon,et al.  Fast static analysis of C++ virtual function calls , 1996, OOPSLA '96.

[65]  Mary Jean Harrold,et al.  Slicing object-oriented software , 1996, Proceedings of IEEE 18th International Conference on Software Engineering.

[66]  Mary Shaw,et al.  Software architecture: the next step for object technology (panel) , 1993, OOPSLA '93.

[67]  Hausi A. Müller,et al.  Manipulating and documenting software structures using SHriMP views , 1995, Proceedings of International Conference on Software Maintenance.

[68]  Thomas W. Reps,et al.  Precise interprocedural chopping , 1995, SIGSOFT FSE.

[69]  David Notkin,et al.  Software reflexion models: bridging the gap between source and high-level models , 1995, SIGSOFT FSE.

[70]  David Grove,et al.  Optimization of Object-Oriented Programs Using Static Class Hierarchy Analysis , 1995, ECOOP.

[71]  Adam A. Porter,et al.  Comparing Detection Methods for Software Requirements Inspections: A Replicated Experiment , 1995, IEEE Trans. Software Eng..

[72]  Frank Tip,et al.  Parametric program slicing , 1995, POPL '95.

[73]  Norman Wilde,et al.  Software reconnaissance: Mapping program features to code , 1995, J. Softw. Maintenance Res. Pract..

[74]  Frank Tip,et al.  A survey of program slicing techniques , 1994, J. Program. Lang..

[75]  Brian Henderson-Sellers,et al.  A conceptual model of cognitive complexity of elements of the programming process , 1995, Inf. Softw. Technol..

[76]  Thomas W. Reps,et al.  Speeding up slicing , 1994, SIGSOFT '94.

[77]  Lionel E. Deimel,et al.  Applying program comprehension techniques to improve software inspections , 1994 .

[78]  Paul C. Jorgensen,et al.  Object-oriented integration testing , 1994, CACM.

[79]  Thomas Gilb,et al.  Software Inspection , 1994 .

[80]  Brian Henderson-Sellers,et al.  Application of Cognitive Complexity Metrics to Object-Oriented Programs , 1994, Journal of object-oriented programming.

[81]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[82]  Lawrence G. Votta,et al.  Does every inspection need a meeting? , 1993, SIGSOFT '93.

[83]  John C. Knight,et al.  An improved inspection technique , 1993, CACM.

[84]  Ivar Jacobson,et al.  Object-oriented software engineering - a use case driven approach , 1993, TOOLS.

[85]  Mark N. Wegman,et al.  Efficiently computing static single assignment form and the control dependence graph , 1991, TOPL.

[86]  Eugene H. Spafford,et al.  Dynamic slicing in the presence of unconstrained pointers , 1991, TAV4.

[87]  Keith Brian Gallagher,et al.  Using Program Slicing in Software Maintenance , 1991, IEEE Trans. Software Eng..

[88]  Janusz W. Laski,et al.  Dynamic slicing of computer programs , 1990, J. Syst. Softw..

[89]  Laurence Brothers,et al.  ICICLE: groupware for code inspection , 1990, CSCW '90.

[90]  Joseph Robert Horgan,et al.  Dynamic program slicing , 1990, PLDI '90.

[91]  Wei-Tek Tsai,et al.  N-Fold inspection: a requirements analysis technique , 1990, Commun. ACM.

[92]  David W. Binkley,et al.  Interprocedural slicing using dependence graphs , 1990, TOPL.

[93]  Thomas W. Reps,et al.  Illustrating interference in interfering versions of programs , 1989, SCM.

[94]  Ian F. Darwin.  Checking C programs with lint , 1988 .

[95]  Joe D. Warren,et al.  The program dependence graph and its use in optimization , 1984, TOPL.

[96]  Michael E. Fagan.  Advances in software inspections , 1986, IEEE Transactions on Software Engineering.

[97]  David Lorge Parnas,et al.  Active design reviews: principles and practices , 1985, ICSE '85.

[98]  Bernard Carré,et al.  Information-flow and data-flow analysis of while-programs , 1985, TOPL.

[99]  Karl J. Ottenstein,et al.  The program dependence graph in a software development environment , 1984, SDE 1.

[100]  Mark Weiser,et al.  Program Slicing , 1981, IEEE Transactions on Software Engineering.

[101]  Ruven E. Brooks,et al.  Towards a Theory of the Comprehension of Computer Programs , 1983, Int. J. Man Mach. Stud..

[102]  Mark Weiser,et al.  Programmers use slices when debugging , 1982, CACM.

[103]  Richard C. Linger,et al.  Structured programming , 1979 .

[104]  Mark David Weiser,et al.  Program slices: formal, psychological, and practical investigations of an automatic program abstraction method , 1979 .