Mike O'Neal

An empirical study of three common software complexity measures

This Paper preaats theredtaofa nempirical study thatcompered three corngmn so!tware complexity measumx McCabe’s mesaurq HahSead’s Wand Lines of COCMto the maintenance logs of 44 programs over a one year period. These progmmswere written andaremehtakd in an industrial setting. Three empirical measurements of the mhtwmce effolt ~~ on -h of ~ programs were atxtmctecI from ~ ~~. tenance logs number of pgram modilkations, tclal maktmum tire% and average modidcation time. A survey was also given to the pm~g ~ ~pon

Watson: a modular software environment for introductory computer science education

ib~ for writing ~ ~

Design and implementation of a generalized problem solving assistant for algorithm development

! -p~ag*wmtiwql*of200ftiw-on ● d of 1 (simple) to 10 (complex). AU three complexity messums produced strong linear comelations with the programmed’ subjective Wings of program complexity dssived from the survey. Somewhat weaker linear camktions weuu obsemed between the complexity masures and the number of program modifications. Linear correlation b&ween the masums and total maintenance time ●nd between the measures and ●vmaga modifkation time wa-e weak. These tindings support the conclusion that complexity measums do appear to accurately cqxure intuitive notions of complexity. However, Lines of Code pdormed as well as McCabe’s Measure aml Halsted”c Wumo. Care should be used when @tempt@ to predict maintenarm time fmm complexity measuresI, since no clear relationship between thl?ss fectors could be found.

Comprehending rule-based programs: a graph-oriented approach

This paper provides an overview of the Watson project and a report on its current status and direction. Watson is a National Science Foundation sponsored project (DUE 92543 17) aimed at creating computerbased laboratory experiences for introducing many of the basic concepts in computing to both majors and non-majors. We have developed and implemented eight prototype Watson laboratories which are currently being used in our introductory computer science course. Activities include: applications (spreadsheets and databases), algorithms (data structures and graphics), programming languages (imperative and functional), architecture (combinational logic), and theory (finite state automata). The goal of this project is to develop a diverse collection of 12 to 15 laboratory experiences that will present major concepts in computing to a wide variety of students in an accessible way and to encourage the development of critical thinking skills in these students by emphasizing problem solving in challenging, but limited, domains.

Scripting of event driven programs for graphical, computer-based laboratories

INTRODUCTION Our “introduction to computer science” course at Louisiana Tech University provides a breadth-first overview of the entire discipline, much in the spirit of the Denning report [Denning, 89] and Curricula91 [Tucker, 91]. We have developed a sequence of eight laboratory modules to be used in closed lab sessions that help students develop problem solving skills. The range of topics includes applications (spreadsheets, databases), algorithms (data structures, graphics), programming paradigms (imperative, functional), architecture (digital logic design), and theory (finite state automata). We have carefully designed the interface for all labs to have a uniform “look and feel” that is mouse, rather than keyboard, oriented. This paper reports on techniques we have developed that provide problem solving assistance for a wide range of topics as found in our laboratory modules. We have received funding from the National Science Foundation (DUE92543 17) to develop the laboratory environment for this breadth-fwst overview course. The current student profile in the course is quite heterogeneous. About 40-50% of the students are computer science majors, while the remainder are drawn from programs throughout the University. Typically, 30-40% of the students in CS 100 are women, while approximately 20% of the class is composed of ethnic minorities (predominately African American). These studenta represent a wide range of interests and abilities. Most have little or no background in college-level mathematics. We are covering a wide range of topics, but materials are presented at a very intuitive level so that students will appreciate the breadth of computer science as a discipline and gain some valuable knowledge about computer systems. Two other papers provide an overview of the entire project [Kurtz, 94; O’Neal, 95]. This paper concentrates on the development of an intelligent assistant for algorithm development, which we will refer to as the Problem Solving Assistant.

A semantic interpreter for a transportable command language interface

Abstract This paper describes the construction of a Restricted Flow Graph (RFG) which should be useful for aiding comprehension of programs written in forward-chaining, non-monotonic, rule-based languages such as OPS5. An RFG is composed of nodes and arcs and is derived from a synthetic execution of a program. The nodes of the RFG represent abstracted working memory states, while the arcs represent transformations between these states. These transformations correspond to one or more executions of a program rule. Five versions of the RFG are presented. Each successive version is more highly constrained, or restricted, in the arcs and states that it may contain. Three RFG-based measures of program complexity are proposed: the number of nodes in an RFG, the number of arcs in an RFG, and a measure, similar to McCabes measure, which combines counts of both nodes and arcs. These measures were computed for each of the five versions of the RFGs of eight rule-based programs. The number of nodes was found to correlate well with the performance of a group of 14 programmers who examined the programs and were tested on their level of understanding using a series of objective questions. In addition, the correlation coefficient was found to improve as the RFG became more constrained. The authors conclude that measures based on RFGs may be good indicators of program complexity and that a tool for presenting graphical representations of RFGs could be useful in increasing programmer comprehension.

Complexity measures for rule-based programs

At Louisiana Tech, we have been developing graphical, eventdriven software for the last 18 months as part of the Watson project, an NSF sponsored project aimed at creating computerbased laboratories for introducing many of the basic concepts in computing. We consider it best to guide the students through scripted activities, yet maintain as much flexibility as possible with our labs. This paper describes a technique we have developed which allows us to impose scripts onto event-driven programs.

Restructuring computing programs to meet employment challenges

Three theories of representation for semantic knowledge have influenced the design of the semantic interpreter. They are semantic nets, conceptual dependency, and conceptual graphs. A brief overview of each formalism and a discussion of their combined influence on the semantic interpreter are presented. The implementation of a semantic interpreter for a transportable command language interface that accepts natural language input is described. The interpreter is based on the theory that sentences expressing the same concept should have the same representation, that is, conceptual dependency.<<ETX>>