Smalltalk and exploratory programming

Using Smalltalk-80, programmers can produce prototypes much faster than with C or Pascal. What techniques do Smalltalk-80 programmers use to produce these prototypes? What is special about Smalltalk-80 that enables them to uses these techniques? Can these techniques be used with conventional languages such as C? In an attempt to answer these questions we interviewed experienced Smalltalk programmers and asked how they approach programming in Smalltalk. Such introspective interviews that are conducted after completion of a project are known to be somewhat unreliable, but not enough is known to use any other methodology. What follows is a summary of the interviews, followed by an explanation of the results. Finally we discuss some of the weaknesses of Smalltalk and some possible solutions

Specification of Interpreters and Debuggers Using an Extension of Attribute Grammars

Recent research in programming environments has focused on the generation of software tools from specifications. Several specification mechanisms have been proposed, and the most successful of these has been attribute grammars. Attribute grammars have been successfully applied to compile-time tools such as type checkers and code generators, which perform static analysis of the program, but have hitherto seemed unsuited to the description of run-time tools such as interpreters and debuggers that involve dynamic interaction with the user of the programming environment. This report describes an extension to attribute grammars that solves this problem. The extended attribute grammars are suitable for the specification of all semantics processing performed by single-user programming environments

An integrated programming environment for pseudo-code development, IPE-PC

An Integrated Programming Environment, IPE-PC, that supports pseudo-code development has been designed and implemented. This environment is based on a Pascal-like language which is designed according to the requirements of a language-based environment. The nucleus of IPE-PC is a language-based editor which represents programs as graphs internally. The same representation is used in every mode of the environment (i.e., editing, compilation, execution, debugging and translation). The system provides facilities to take advantage of both top-down and bottom-up programming. Stepwise refinement has been supported by providing comment structures that can be transformed into procedures. Bottom-up programming is supported because it is possible to create and save program segments which can be inserted to the programs at the appropriate points --Abstract, page ii

APT: A principled design for an animated view of program execution for novice programmers

This thesis is concerned with the principled design of a computational environment which depicts an animated view of program execution for novice programmers. We assert that a principled animated view of program execution should benefit novice programmers by: (i) helping students conceptualize what is happening when programs are executed; (ii) simplifying debugging through the presentation of bugs in a manner which the novice will understand; (iii) reducing program development time. The design is based on principles which have been extracted from three areas: (i) the problems that novices encounter when learning a programming language; (ii) the general design principles for computer systems; and (iii) systems which present a view of program execution. The design principles have been embodied in three 'canned stepper displays for Prolog, Lisp and 6502 Assembler. These prototypes, called APT-0 (Animated Program Tracer), demonstrate that the design principles can be broadly applied to procedural and declarative; low and high level languages. Protocol data was collected from subjects using the prototypes in order to check the direction of the research and to suggest improvements in the design. These improvements have been incorporated in a real implementation of APT for Prolog. This principled approach embodied by APT provides two important facilities which have previously not been available, firstly a means of demonstrating dynamic programming concepts such as variable binding, recursion, and backtracking, and secondly a debugging tool which allows novices to step through their own code watching the virtual machine in action. This moves towards simplifying the novice's debugging environment by supplying program execution information in a form that the novice can easily assimilate. An experiment into the misconceptions novices hold concerning the execution of Prolog programs shows that the order of database search, and the concepts of variable binding, unification and backtracking are poorly understood. A further experiment was conducted which looked at the effect that APT had on the ability of novice Prolog programmers to understand the execution of Prolog programs. This demonstrated that the performance of subjects significantly increased after being shown demonstrations of the execution of Prolog programs on APT, while the control group who saw no demonstration showed no improvement. The experimental evidence demonstrates the potential of APT, and the principled approach which it embodies, to communicate run-time information to novice programmers, increasing their understanding of the dynamic aspects of the Prolog interpreter. APT, uses an object centred representation, is built on top of a Prolog interpreter and environment, and is implemented in Common Lisp and Zeta Lisp and runs on the Symbolics 3600 range of machines

A function-key driven syntax-directed editor for software systems design

A project report submitted to the Faculty of Engineering, University of the Witwatersrand, Johannesburg in partial fulfillment of the requirements for the degree of Master of Science in Engineering.Program Description Language (PDL) is a high-level design language used for both hardware and software systems design. Due to the clerical effort involved in creating such a structured program, however, the PDL design is usually bypassed, and coding performed directly. The syntax-directed PDL generator package presented here, written in Pascal for the IBM-PC, is aimed at providing a tool for producing syntactically correct PDL programs with the minimum of effort. Function keys are used extensively for specifying system inputs, and PDL keywords are inserted via construct templates. Syntactical correctness is always enforced while indentation or prettypriuting is automatic. This userfriendly PDL editor thus encourages a top-down iterative design approach while automatically performing syntax and partial semantic error detection. It is believed that this much needed tool will not only promote high-level design principles, but also serve as the basis for automatic code generation for commonly used programming languages