Professional Programmers Research Articles

Research Report—The Relevance of Application Domain Knowledge: The Case of Computer Program Comprehension

The field of software, has, to date, focused almost exclusively on application-independent approaches. In this research, we demonstrate the role of application domain knowledge in the processes used to comprehend computer programs. Our research sought to reconcile two apparently conflicting theories of computer program comprehension by proposing a key role for knowledge of the application domain under examination. We argue that programmers use more top-down comprehension processes when they are familiar with the application domain. When the application domain is unfamiliar, programmers use processes that are more bottom-up in nature. We conducted a protocol analysis study of 24 professional programmers comprehending programs in familiar and unfamiliar application domains. Our findings confirm our thesis.

Apple Computer's Authoring Tools & Titles R&D Program

This site description reports on four projects that are part of Apple Computer’s Authoring Tools & Titles R&D Program. Our charter is to empower people to build, extend, and maintain interactive multimedia software by lowering barriers to entry for non-programmers and improving the productivity of professional programmers. In addition, we partner with design teams to create software titles that illustrate the potential of intelligent multimedia applications, especially in the areas of education and training.

Computational Geometry in C

From the Publisher: This is the newly revised and expanded edition of a popular introduction to the design and implementation of geometry algorithms arising in areas such as computer graphics, robotics, and engineering design. The basic techniques used in computational geometry are all covered: polygon triangualtions, convex hulls, Voronoi diagrams, arrangements, geometric searching, and motion planning. The self-contained treatment presumes only an elementary knowledge of mathematics, but it reaches topics on the frontier of current research. Thus professional programmers will find it a useful tutorial.

Software reconnaissance: Mapping program features to code

AbstractMaintainers of old code often need to discover where particular program features are implemented. This paper presents a method, called ‘software reconnaissance’ for answering this question through an analysis of the execution of different test cases. The method is quite easy to implement, requiring only a test coverage monitor, some simple tools, and a surprisingly small number of test cases.A statistical case study is presented that shows the kind of results that can be obtained on a typical medium‐sized program. The method seems to be effective in identifying a small number of code components that are unique to a particular program feature, though it may not find all components that make up the feature's delocalized plan. A small protocol case study shows that professional programmers can learn to use the method quickly and can use the information that it produces.Software reconnaissance may be a simple but useful addition to the maintainer's tool kit in that it provides starting points for understanding a large program and a way of recovering some requirements traceability information from old code. For the researcher, it also provides a novel functionality ‘view’ of software that maps features to program components at different levels of precision.

The evolution of Forth

Forth is unique among programming languages in that its development and proliferation has been a grass-roots effort unsupported by any major corporate or academic sponsors. Originally conceived and developed by a single individual, its later development progressed under two significant influences: professional programmers who developed tools to solve application problems and then commercialized them, and the interests of hobbyists concerned with free distribution of Forth. These influences have produced a language markedly different from traditional programming languages.

The first personal computers in the world

The application scale and the technical capabilities of computers have increased to such an extent since the early 1950s that the level of economic development today is determined by programmer productivity and program development times. Highlevel algorithmic languages are now a necessary economic factor in computer applications. In the past, high cost and scarcity of machine time led to the development of batch debugging and execution methods and necessitated reliance on professional operators, thus distancing the programmers and the users from direct access to the computer. Particularly harmful for scientific and technical problems was the emergence in Europe and the USSR of a class of programmers acting as intermediaries: these programmers were not authors of the actual problems and therefore could not efficiently correct the algorithms and the mathematical models in real time. V. M. Glushkov was the first to recognize that progress in science and engineering required seating the author of the problem at the computer console. To achieve this, a low-cost computer was needed, with an algorithmic language that was as close as possible to the language of mathematics used by all engineers and researchers. In Glushkov's view, this language and its application technology had to be consistent with the psychology and experience of engineers and researchers who were not professional programmers and allow poorly formalized (fuzzily defined) problems to be solved by altering their specification and changing the algorithm in execution time. In other words, the user should have access to an advanced set of tools for interacting with the computer. These requirements for precise definition of engineering tasks determined the properties and the direction of development of a whole family of computers for solving engineering problems, the MIR series computers. These low-cost and accessible computers were manufactured in the USSR for thousands and hundreds of thousands of engineers, researchers, and students. They became the first and main tool for acquiring computer lkeracy. At present, it is universally recognized that the properties and the operating system of MIR (1965), MIR-1 (1966), and MIR-2 (1970) made them the first personal computers in the world. They were conceived as such and implemented as such to the best of the technical abilities of the Soviet industry at that time. Efficient implementation of high-level languages, such as FORTRAN or Algol, required very large and, at that time, expensive RAM and was therefore available only on high-cost computers. The difficulty was resolved by introducing hardware language support [1] developed at the Special Design Bureau of Mathematical Machines and Systems at the Institute of Cybernetics of the Ukrainian Academy of Sciences. This was a low-cost solution that left virtually the entire RAM to the user. The high level of man-machine interaction was supported by a highly efficient hardware-implemented source-language interpreter, which allowed the user access virtually to the entire program execution trace. It thus became possible to correct data and to alter the direction of transformations virtually at every execution point in the program. Combined with the use of display monitors, another first in Soviet computers, this provided an exceptionally effective, for that time° program debugging system. Many mainframe users actually continued using MIR-2 machines until the 1980s as an instrument for program debugging, exploiting the advantages of personal computers for this task. The main properties of MIR series computers included hardware support of the programming language, operator-byoperator interpreting of the language, and a steadily increasing level of machine intelligence, which grew from one computer version to the next. Subsequently, the enhancement of machine intelligence became the main factor in the development of these computers. New constructs were introduced as part of the ANALITIK family of languages, a pattern recognition system for mathematical constructs was developed, the application domain was broadened. The advent of personal computers with large RAM and large external storage allowed software implementation of the latest versions of the ANALITIK languages, which provided the users with a transportable tool for solving complex scientific and technical problems and intensifying the instruction process.

Teaching C with UNIX for college credit to professional programmers

This paper addresses the problem of introducing the UNIX operating system and the C language to professional programmers and system analyists who have had little or no experience with either UNIX or C. Workshops given to industrial employees ordinarily last for no more than a few consecutive days and offer no college credit. In contrast, the course described in this paper required approximately nine days, spread over a three week period, and the students earned three hours of undergraduate credit towards a degree in computer science. A detailed breakdown of the contents of the lectures is given, and examples of the programming exercises done in the laboratory component of the course are presented. Observations on the effectiveness of the approach and suggestions for future improvements in the course are offered in the final section of the paper.

Lessons learned from SUIT, the simple user interface toolkit

In recent years, the computer science community has realized the advantages of GUIs (Graphical User Interfaces). Because high-quality GUIs are difficult to build, support tools such as UIMSs, UI Toolkits, and Interface Builders have been developed. Although these tools are powerful, they typically make two assumptions: first, that the programmer has some familiarity with the GUI model, and second, that he is willing to invest several weeks becoming proficient with the tool. These tools typically operate only on specific platforms, such as DOS, the Macintosh, or UNIX/X-windows. The existing tools are beyond the reach of most undergraduate computer science majors, or professional programmers who wish to quickly build GUIs without investing the time to become specialists in GUI design. For this class of users, we developed SUIT , the S imple U ser I interface T oolkit. SUIT is an attempt to distill the fundamental components of an interface builder and GUI toolkit, and to explain those concepts with the tool itself, all in a short period of time. We have measured that college juniors with no previous GUI programming experience can use SUIT productively after less than three hours. SUIT is a C subroutine library which provides an external control UIMS, an interactive layout editor, and a set of standard “widgets,” such as sliders, buttons, and check boxes. SUIT-based applications run transparently across the Macintosh, DOS, and UNIX/X platforms. SUIT has been exported to hundreds of external sites on the internet. This paper describes SUIT's architecture, the design decisions we made during its development, and the lessons we learned from extensive observations of over 120 users.

SAMPLE

In this paper, a new simple AI language is described, which ties up Logic Programming and Algebraic Programming concepts, and, to our mind, may take the same place in the AI languages family as Basic language --- in the conventional programming languages family.The main (and slightly unusual for programming languages) feature of this language is the most possible similarity of the constructions for writing algorithms to the data being processed. This feature provides a new programming technology: the user composes a program from data examples (building up some structure on them) rather than writing constructions on a programming language with non-trivial a priori syntax and semantics.This programming technology makes it possible to develop sophisticated expert systems by problem analysts rather than professional programmers. Many of Sample programs turn out to be the shortest possible representations of the corresponding algorithms. This feature seems to be a characteristic feature of the language.The paper contains program examples, discussion on the applicability and implementation, and description of some experiments with current implementation of the Sample language interpreter.

On the decline of classical programming

Summary form only given. The author puts forward the view that we are in a period of far-reaching and fundamental change in the practice of information technology. This has been a gradual though accelerating process during the 1980s and some of its effects are now becoming apparent in the changes in the structure and activities of industry. A central aspect is the increasing shift to the design of computing systems by non-specialists in IT. He looks at the general features of this new era. Then he turns to an analysis of the specific developments in computer programming and the role of the 'professional programmer'. Finally, he embarks on some speculation as to the future of programming support environments and of research in the field.

The role of program structure in software maintenance

A number of claims have been made by the developers of program design methodologies, including the claim that the code produced by following the methodologies will be more understandable and more easily maintained than code produced in other ways. However, there has been little empirical research to test these claims. In this study, student and professional programmers were asked to make either simple or complex modifications to programs that had been generated using each of three different program structures. Data on the programmers' modification performance, cognitive representations formed of the programs and subjective reactions to the programs suggested that problem structure (as created by the different methodologies), problem content, complexity of modification, and programmer experience all play a crucial role in determining performance and the representation formed.

Program design methodologies and the software development process

This research examined program design methodologies which claim to improve the design process by providing strategies to programmers for structuring solutions to computer problems. In this experiment, professional programmers were provided with the specifications for each of three non-trivial problems and asked to produce pseudo-code for each specification according to the principles of a particular design methodology. The measures collected were the time to design and code, percent complete, and complexity, as measured by several metrics. These data were used to develop profiles of the solutions produced by different methodologies and to develop comparisons among the various methodologies. These differences are discussed in light of their impact on the comprehensibility, reliability, and maintainability of the programs produced.

REUSING SOLUTIONS IN SOFTWARE DESIGN ACTIVITY

This study is on code reuse in the software design activity. The data analysed in this paper were collected in an experiment 1 aimed at studying the activity of design with an object-oriented programming (OOP) language (Détienne, 1990). Four professional programmers were given two problems to solve and code with an OOP language. The material consisted of two management problems; the task domain was familiar to the subjects. The environment was composed of a basic editor and the 0 2 system (0. Deux et al., 1989) which is an object-oriented data base system. We collected the subjects-verbalizations, successive versions of programs under development, notes written during the realization of the task, the order in which the different traces of the activity were made, i.e., the order for writing notes and for coding programs with the verbalization recorded simultaneously.

Experimental evaluation of a test coverage analyzer for C and C + +

Experiments tested the effectiveness of nvcc, a test coverage analyzer for C and C + +. Subjects were professional programmers and systems analysts at AT&T Bell Laboratories. Results indicate that using nvcc will result in a higher level of test coverage for a given testing time, allow testers to reach a given coverage level at least 40% faster, and reduce variability in level of coverage reached by different testers. Use of nvcc did not significantly increase the number of bugs found. All subjects surveyed said they found nvcc to be a useful tool. Results also suggest that the effectiveness of nvcc may be related to users' software engineering experience.

A design rationale for a language‐based editor

AbstractThis paper reviews the design issues that arise in the construction of effective language‐based editors for the preparation of syntactically and static semantically correct language sentences, typically computer programs. The need for such editors to support a pluralistic view of program structure is identified, together with the need to observe the constraints on performance and storage consumption if such editors are to be accepted by professional programmers. From these basic needs, more specific requirements for the display, parsing and semantic checking components of such an editor are derived.

Cognitive Asymmetry, Computer Science Students, and Professional Programmers

System analysts and computer programmers of a university computer center performed better on visuospatial tasks usually attributed to the right cerebral hemisphere. By contrast, subjects from a human resources department of a bank performed better on verbosequential tasks associated with the left hemisphere. The cognitive profile was significantly different although the overall performance was not different between the groups. In an intermediate computer class there was a significant correlation between the cognitive profile favoring visuospatial skills and scores on computer projects in which the students used their own ingenuity. There was no correlation with scores that depended on class notes nor with scores on examinations. These results suggest that the cognitive profile may be an important indicator for success in certain occupations.

Cross System Product application generator: Application design

This paper describes some techniques that can be used for Cross System Product/Application Development (CSP/AD) application design. CSP/AD is an application development tool for professional programmers. A well-designed application is obtained by using proven principles of structured analysis, structured design, and structured programming. An understanding of these principles and the application definition constructs provided by Cross System Product/Application Development is necessary for the CSP/AD application designer. Application design for CSP/AD is accomplished by using a combination of techniques for data design, application design, and application program design. For each of these design techniques there exist formal, accepted practices, and methodologies that may be used. These techniques are described, and methods that have proven successful for designing CSP/AD applications are presented.

Machine-independent image processing: Performance of apply on diverse architectures

One of the most important obstacles standing in the way of widespread use of parallel computers for low-level vision is the lack of a programming language that can be mapped efficiently onto different computer architectures which is suited for low-level vision. The Apply language has been designed and implemented to perform such operations. We demonstrate its capabilities by comparing the performance of the Hughes HBA, the Carnegie Mellon Warp machine, and the Sun 3 on a large set of low-level vision programs. In order to demonstrate its efficiency, we also compare performance of the Sun code with routines of similar function written by professional programmers.

Spreadsheets, PC's and the finite-difference solutions for ecological distribution

Abstract High-speed computation with parallel processing is within the grasp of mathematical ecologists and environmental managers. One can imagine the numerical solution of the large set of simultaneous partial differential equations of population dynamics. This would allow for ecosystem model verification and, eventually, for ecosystem management. It is important to differentiate between numerical analysis and programming. Programming is the final stage during which the most efficient possible management tool is produced. Programming will always be best left professional programmers who specialize in an understanding of the idiosyncracies of particular hardware and particular compilers. A necessary preliminary study, a numerical analysis, will always be required to study the numerical difficulties of, say, the finite difference method. Numerical analysis cannot be conducted without a firm understanding of the phenomena and, therefore, will fall within the purview of the numerical ecologist. Numerical analysis is best conducted on simplified versions of the model in order to discern and control the myriad of error types: numerical instability, numerical dispersal, aliasing, etc. In this paper we demonstrate the use of spreadsheets on PC's as an ideal environment for these preliminary studies.

Experimental comparison of design/documentation formats for expert systems

This study examines the effectiveness of using a design methodology to modify an expert system. In this study, professional programmers were asked to make one of two different types of modifications to an existing expert system. Along with standard documentation (e.g., listings, program specifications, etc.) programmers were provided with either no design/documentation format or one of two different design/documentation formats. The measures collected were time to modify the program and number of errors. Results indicate that the subjects who used a design/documentation format took less time to modify their expert systems than subjects who did not have a documentation format. Furthermore, results suggest that programmers who used an Entity-Relationship design format were able to complete the modification task in less time. These differences are discussed with respect to their impact on software engineering practices for expert systems.