Since the early 1960’s, researchers have built a number of programming languages and environments with the intention of making programming accessible to a larger number of people. This article presents a taxonomy of languages and environments designed to make programming more accessible to novice programmers of all ages. The systems are organized by their primary goal, either to teach programming or to use programming to empower their users, and then, by each system’s authors ’ approach, to making learning to program easier for novice programmers. The article explains all categories in the taxonomy, provides a brief description of the systems in each category, and suggests some avenues for future work in novice programming environments and languages.

Cultures deal with their environments by adapting to them and simultaneously changing them. This is particularly true for technological cultures, such as the dynamic culture of computer users. To date, the ability to change computing environments in non-trivial ways has been dependent upon the skill of programming. Because this skill has been hard to acquire, most computer users must adapt to computing environments created by a small number of programmers. In response to the scarcity of programming ability, the computer science community has concentrated on producing general-purpose tools that cover wide spectrums of applications. As a result, contemporary programming languages largely ignore the intricacies arising from complex interactions between different people solving concrete problems in specific domains. This dissertation describes Agentsheets, a substrate for building domain-oriented, visual, dynamic programming environments that do not require traditional programming skills. It discusses how Agentsheets supports the relationship among people, tools, and problems in the context of four central themes: (1) Agentsheets features a versatile construction paradigm to build dynamic, visual environments for a wide range of problem domains such as art, artificial life, distributed artificial intelligence, education, environmental design, and

Abstract not found

ion John C. Grundy + and John G. Hosking ++ + Department of Computer Science University of Waikato Private Bag 3105, Hamilton, New Zealand jgrundy@cs.waikato.ac.nz ++ Department of Computer Science University of Auckland Private Bag 92019, Auckland, New Zealand john@cs.auckland.ac.nz Abstract We describe a visual language and environment for designing and implementing systems using the tool abstraction paradigm. This paradigm permits systems to be constructed from toolie and abstract data structure components, using an event response mechanism to handle inter-component interaction. This approach leads to systems more easily adapted to functional specification changes than with conventional design. 1. Introduction In a recent paper, Garlan et al [4] introduce the toolabstraction (TA) paradigm for constructing computer systems that support functional evolution. In this approach groups of abstract data structures (ADSs) are shared by a collection of co-operating toolies. Each toolie...

: We describe a practical and enhanced implementation of a graphical Prolog tracer which not only provides a faithful (slow-motion) representation of the inner workings of the Prolog interpreter, but also allows a high-speed visual overview of execution for rapidly homing in on buggy code. The current work extends our original 'Transparent Prolog Machine' in the following ways: (a) complex unification histories for given variables can be displayed; (b) cross-variable dependencies (sharing) across widelydispersed sections of code can be highlighted; (c) an earlier defect, wherein a given user could write code which defeated the speed/size of the current fastest/largest display capability (i.e. a 'horizon effect') is dealt with; (d) users of textual (Byrd box) tracers are provided with an upward-compatible migration pathway; (e) code can be traced either 'live' or 'retrospectively' at different grains of detail. We distinguish among four different ways of manipulating the 'navigational s...

The development of software for reconfigurable sensor-based realtime systems is a complicated and tedious process, requiring highly specialized skills in real-time systems programming. The total development time can be reduced by automatically integrating reusable software modules to create applications. The integration of these modules can be further simplified by the use of a high-level programming interface. We have developed Onika, an iconically programmed human-machine interface, to interact with a reconfigurable software framework to create reusable code. Onika presents appropriate work environments for both application engineers and end-users. For engineers, icons representing real-time software modules can be combined to form real-time jobs. For the end-user, icons representing these jobs are assembled by the user into applications. Onika verifies that all jobs and applications are syntactically correct, non-ambiguous, and complete. They can then be executed from within Onika, or can be saved as a stand-alone program which can be executed independently on the underlying realtime operating system. Onika has been fully integrated with the Chimera real-time operating system in order to control several different

Abstract not found

Diagram construction can be used to visually analyse and design a complex software system using natural, graphical representations describing high-level structure and semantics. Textual programming can specify detailed documentation and functionality not well expressed at a visual level. Integrating multiple textual and graphical views of software development allows programmers to utilise both representations as appropriate. Consistency management between these views must be automatically maintained by the development environment. MViews, a model for such software development environments, has been developed. MViews supports integrated textual and graphical views of software development with consistency management. MViews provides flexible program and view representation using a novel object dependency graph approach. Multiple views of a program may contain common information and are stored as graphs with textual or graphical renderings and editing. Change propagation between program components and views is supported using a novel update record mechanism. Different editing tools are integrated

macgnome @ cs.cmu.edu Previous work has demonstrated that presenting the data structures from programs in a graphical manner can significantly help programmers understand and debug their programs. In most previous systems, however, the graphical displays, called data visualizations, had to be laboriously hand created. The Amethyst system, which runs on Apple Macintosh computers, provides attractive and appropriate default displays for data structures. The default displays include the appropriate forms for literals of the simple types inside type-specific shapes, and stacked boxes for records and arrays. In the near future, we plan to develop rules for layout of simple dynamic data structures (like linked lists and binary trees), and simple mechanisms for creating

Leogo is a novel programming environment supporting an "equal opportunity" user interface which allows users to express their programming tasks through any mixture of three concurrently active programming paradigms: by direct-manipulation using `programming by demonstration'; by clicking buttons and dragging sliders in an iconic language; and by typing commands in a normal text-based language. Equal opportunity ensures that the e#ects of any interface action are simultaneously displayed across each of the three paradigms---input expressions in one paradigm cause output of equivalent expressions in the other two paradigms. Leogo is designed to promote programming skills in primary and junior schools, but the interface properties it demonstrates are applicable to a wide range of novel programming environments. Leogo's motivation, design, development, and preliminary usability study are described. 2 1 Introduction Programming skills are becoming increasingly important at work...