Typescript (photocopy). / Digitized by Kansas Correctional Industries

Abstract not available

This thesis presents the results of two studies that investigate the question of what interruption-styles are most appropriate for end-user programmers who are debugging programs. In the studies, end-user programmers are presented with surprises that encourage them to investigate, use, and learn about debugging devices in their programming environment. We used various interruption-styles to present these surprises to the end-user programmers, and we evaluated how they affected the end-user programmers ability to learn about the debugging features, their accuracy at debugging their programs, and how accurate they were at judging how well they had debugged their programs. The three styles we compared were immediate-style interruptions (which force the user to acknowledge them), low-intensity negotiated-style interruptions (which do not force the user to acknowledge them, but rather use visual elements such as red circles around cell values in order to notify users that there is something for them to do), and high-intensity negotiated-style interruptions (which are the same as low-intensity negotiated-style interruptions except that the visual elements are more intense, e.g. they are larger and they blink). We found that low-intensity negotiated-style interruptions best supported end-user programmers debugging, learning, and self-assessment. We also found that immediate-style and high-intensity negotiated-style interruptions had very similar effects on the end-user programmers. / Graduation date: 2004

Sophisticated software systems are inherently complex. Understanding, debugging and maintaining such systems requires inferring high-level characteristics of the system's behavior from a myriad of low-level details. For large systems, this quickly becomes an extremely difficult task. MrSpidey is a static debugger that augments the programmers ability to deal with such complex systems. It statically analyzes the program and uses the results of the analysis to identify and highlight any program operation may cause a run-time fault. The programmer can then investigate each potential fault site and, using the graphical explanation facilities of MrSpidey, determine if the fault will really happen or whether the corresponding correctness proof is beyond the analysis's capabilities. In practice, MrSpidey has proven to be an effective tool for debugging program under development and understanding existing programs. The key technology underlying MrSpidey is componential set-based analysis. This is a constraint-based, whole-program analysis for object-oriented and functional programs. The analysis first processes each program component (eg. module or package) independently, generating and simplifying a constraint system describing the data flow behavior of that component. The analysis then combines and solves these simplified constraint systems to yield invariants characterizing the run-time behavior of the entire program. This component-wise approach yields an analysis that handles significantly larger programs than previous analyses of comparable accuracy. The simplification of constraint systems raises a number of questions. In particular, we need to ensure that simplification preserves the observable behavior, or solution space, of a constraint system. This dissertation provides a complete proof-theoretic and algorithmic characterization of the observable behavior of constraint systems, and establishes a close connection between the observable equivalence of constraint systems and the equivalence of regular tree grammars. We exploit this connection to develop a complete algorithm for deciding the observable equivalence of constraint systems, and to adapt a variety of algorithms for simplifying regular tree grammars to the problem of simplifying constraint systems. The resulting constraint simplification algorithms yield an order of magnitude reduction in the size of constraint systems for typical program expressions.

M. Tech. Information Networks / Code clone is a code portion in one source code fragment that is similar or identical to a code portion in another source code fragment. Clones in applications are inevitable within an organization's intranet. There are a great number of clone detection tools to help maintenance programmers to locate and refactor code clones where they exist. Currently clone detection process has not been explored fully to construct digital libraries to store clones for reuse and shareability. This is because most of clone detection techniques produce Indexed Statistical Reports as textual file showing related group of code fragments. Other techniques visualize clones to depict clones versions history as genealogies. Furthermore current techniques do not indicate the reusability and shareability worthiness of the detected clones in taxonomy. In this mini-dissertation a Clone Wrapper Detection Technique prototype is developed to detect and store commonly used structural clones into a Discoverable Digital Clone Library hosted in Fedora Repository. Stored clones metadata are then extracted to induce a Clone Family Tree Ontology of related class clones in a taxonomy based on Abstraction (inheritance and composition hierarchy) process.

No description available.

Thesis (Ph. D.)--Computing, Georgia Institute of Technology, 2008. / Committee Chair: Harrold, Mary Jean; Committee Member: Orso, Alessandro; Committee Member: Pande, Santosh; Committee Member: Reiss, Steven; Committee Member: Rugaber, Spencer.

Thesis (M.S.)--Worcester Polytechnic Institute. / Keywords: Eclipse plug-in; tracer; timeline; software visualization; sunburst; SoftViz; ParaVis; error categorization framework; debugging; program understanding. Includes bibliographical references (p. 85-89).

Thesis (M.S.)--Brigham Young University. Dept. of Computer Science, 2007. / Includes bibliographical references (p. 30-31).

Thesis (Ph. D.)--University of Wisconsin-Madison, 1989. / Cover title. "August 1989." Includes bibliographical references.