Viewing a programming environment as a single tool

An incremental compiler, in response to a program change, recompiles only the part of the program affected by the change, resulting in more efficient use of system resources and in improved response time. Current incremental programming environments based on compilation do not combine a small incremental unit for recompilation with sophisticated local and global register allocation schemes. This dissertation studies the problems of incrementally allocating local and global registers and generating target code in response to program edits. The unit of change is an intermediate code statement, and the target code that is produced incrementally utilizes registers as efficiently as a non-incremental target code generator that uses the same register allocation heuristics. The first step in the design of an incremental target code generator is an analysis of the effects of program edits on existing local and global register allocation. From the analysis, a model of register histories is constructed that maintains the ideal and the actual register allocation for the program. The model is designed to be independent of the local and global register allocation heuristics that are used. However, it is particularly useful for the incremental allocation of both local and global registers using graph coloring. Using the analysis and the model, incremental techniques for allocating registers and generating target code are developed. To provide insight into the performance of the incremental target code generator, both incremental and non-incremental systems are implemented. Their performances are compared both in terms of the quality of the target code that is produced and in the time it takes to make changes incrementally rather than by completely regenerating the target code. The results of the experiments indicate that the same high-quality target code that is produced non-incrementally can be produced incrementally. Under certain conditions, the savings for incremental incorporation of changes are considerable. The savings in time depend on the amount of code that is changed and on the amount of disruption to the register allocation. For test cases that involve changes to global register allocation, the savings in time range from 34 to 96% when up to 16% of the program is changed.

This paper presents two topics: Implementation of a debugger through use of an incremental compiler, and techniques for fine-grained incremental compilation. Both the debugger and the compiler are components of the highly Integrated programming environment DICE (Distributed Incremental Compiling Environment) which alms at providing programmer support in the case where the programming environment resides in a host computer and the program. Is running on a target computer that is connected to the host.

This paper describes the environment for developing and executing Warp* programs. The center of the program development environment is a customized shell that ties together a compiler for the Warp array, the Warp run-time system, and a debugger. The compiler translates high-level language programs to microcode for the Warp machine. It achieves a high utilization of the computation power of the processor. The run-time system supports remote execution of Warp programs across a network and makes the Warp machine available as a shareable resource. The debugger permits symbolic debugging of Warp programs. The Warp programming environment makes the Warp machine an easily programmable and accessible attached processor in a UNIX™ environment .

Alien is a generator for interactive language-specific programming environments. The system makes a language definition environment available to the language definer and supports him with an interactive generator. Using these tools every syntactic unit of a language can be made available. This can be done by a method of stepwise testing, correction and expansion. Fully defined environments can easily be restricted to subsets of a language.This paper introduces a method making a large software product executable on small UNIX machines as well as a survey of the system's components. These are designed to make the implementation on PCs effective and to develop a powerful generator for programming environments. Therefore the results are of interest to all projects in the programming environment field.ALIEN has been implemented in C running on Siemens PC-X, PC-X10, PC-MX-2 machines and Atari PC. Implementation on Apollo and SUN workstations is still in progress and on IBM PC is planned.The project is supported by the Stiftung Volkswagen-werk under grant 1/61 602.

Since Arduino is the main entry-level platform to the world of electronic circuits and systems, there are many programming environments that try to ease the burden of Arduino textual programming on young primary students. Although block-based, most of these environments retain the imperative structures of textual programming languages, which are not easily comprehensible by such students. The proposed, in this paper, Learning-Arduino-With-Rules Introductory System (LAWRIS) tries to tackle this problem by adopting a rule-based approach: an Arduino-based pre-specified system can be programmed by constructing rules with very simple and intuitive jigsaw pieces, in a visual, web-based environment. Contrary to other programming environments for Arduino, the main logic of LAWRIS is implemented on the board side and only a configuration string is downloaded to it. Thus, LAWRIS features fast responses to both circuit input changes and program modifications, a very important characteristic for young students. It also imposes minimal overhead on the host system, allows web access of the programming environment, and has very low hardware cost.

Teaching and learning programming is a challenge. Although several learning and programming environments have been proposed for classes, there seems to be more dissent than consensus as to which tools are preferable over others. This paper investigates teachers’ perspectives on popular learning and programming environments used in secondary computer science education in Germany. The environments investigated are: BlueJ, Scratch, Greenfoot, Eclipse, MIT App Inventor, Processing IDE, and Alice. Based on prior research, a catalogue of environment features supporting the learning processes of students was constructed. Using these criteria, an online-survey was conducted with computer science teachers in North Rhine-Westphalia, Germany. In the survey, the participating teachers evaluated the selected tools’ adequacy for teaching object-oriented programming. The findings support the results of prior research conducted with students, stressing the importance of a simple and user-friendly graphical user interface (GUI) as well as the option to visualise classes and objects. Contrary to prior studies, the results show that teachers do not see the editor as equally important, as students do, and that there is no consensus about the role of the area of application for choosing an integrated development environment (IDE). Student-friendly debugging messages as well as a step-by-step execution of programs were identified as important features. Although no tool excelled for every criterion, the clear favourite was BlueJ.

In a message-passing program, there are at least as many threads as processors, and the programmer must deal with large numbers of them on a massively parallel machine. On our target machine, the CM-5, we had previously developed Prism, a programming environment that supports debugging, data visualization, and performance analysis of data-parallel programs. We discuss how our new version, Node Prism, extends Prism's capabilities for message-passing programs. It looks and feels like the data-parallel version, but it uses new methods for user-debugger interaction that promote greater understanding of parallel programs. It offers scalable expression, execution, and interpretation of all debugging operations, making it easier to debug and understand message-passing programs. >

This paper explores both the design and classroom usage of a visual and interactive programming environment. This environment, named JavaTown, provides a visual representation of the inner workings of object-oriented programs, in which on-screen characters are literally depicted as carrying messages to each other and remembering values. JavaTown was created to aid in the introduction of some of the most elusive concepts in the CS1/CS2 curriculum: object references, parameter passing, variable scope, recursion, and linked lists.

A large variety of tools for program development are available today. The tools tend to become more and more sophisticated, but are usually isolated utilities that have to be applied one by one. An alternative to the tool-box approach is an integrated programming environment utilizing powerful interaction facilities.The design and a prototype implementation of an integrated programming environment is described and the qualities of such a system are discussed. One important design goal was to obtain an environment which has an execution efficiency comparable to that of a system based on a conventional compiler, and a reasonable interaction speed. For this reason the system is based on incremental translation to native code. Another goal was to obtain incremental execution, i.e. the possibility to modify an executing program. The properties of this mechanism and its consequences are investigated.

We describe a programming environment for Prolog, a common logic programming language. The services offered by our system assist a Prolog user in the tasks of composing, editing, and storing logic (rule-based) programs, as well as in the control of their execution for debugging purposes. In order to facilitate effective debugging of Prolog programs, we propose a new model of computation that can handle both pure Prolog and impure (side-effect causing) Prolog operations quite gracefully. This model employs two stacks representing the state of a computation with respect to the two major activities of Prolog execution: recursion and backtracking. This representation, in addition to being quite clear and intuitive, is easy to display on a terminal's screen and can be further processed. We also describe a Prolog oriented editor with which the user may easily create and update Prolog source programs and, further, inspect states of computation as generated by the debugger.

Computer programming is essential nowadays but still challenging to learn due to its invisible thinking. Current programming environments are mostly designed for operating on computers directly to learn concrete programming, but this approach lacks the support for clarifying learners’ thinking processes. On the other hand, using paper and pens shows usability in developing creative thinking, but it cannot help verify learners’ thinking results due to its nature. To benefit from both paper and computers, we developed an interactive programming learning environment consisting of a paper board game, a computer system, and a digitalization mechanism. Learners can use the learning environment to draw down their thinking results and verify them by comparing them with the evaluation on the computer system immediately. Two experiments were conducted to compare this learning environment with paper board games and computer programming environments, respectively. The experimental results show that the subjects who learn in our environment can learn to program better than those who learn with the other two. The proposed environment is easy to prepare for learners in a classroom as their first step to programming learning. It can help learners cross over from paper board games for computational thinking to computer programming environments.

Off-Line Programming Environment for Robotic Applications

Programming is a central activity in the computing profession. It is facilitated by different tools (editors, compilers, debuggers, etc), which are often integrated into programming environments. Programming also plays a central role in computer science education. For this purpose, a number of complementary tools were developed during the last decade: algorithm animators, program visualizers, problem generators, assignment graders, and so forth.

Smart environments demand novel paradigms offering easy configuration, programming and deployment of pervasive applications. To this purpose, different solutions have been proposed ranging from visual paradigms based on mashups to formal languages. However, most of the paradigms proposed in the literature require further external tools to turn application description code into an executable program before the deployment on target devices. Source code generation, runtime upgrades and recovery, and online debugging and inspection are often cumbersome in these programming environments. In this work we describe a methodology for real-time and on-line programming in smart environments that is compact and efficient enough to run on resource-constrained devices. The pillar of the proposed approach is real-time exchange of executable symbolic code in heterogeneous networks. The methodology is supported by an inference engine that is able to generate symbolic code starting from knowledge about hardware devices and their placement in the environment, and about the application domain. Interoperability with existing smart applications and Internet of Things (IoT) deployments is reached through a symbolic Transmission Control Protocol (TCP) client, and Message Queue Telemetry Transport (MQTT) client.

The PSG programming system generator developed at the Technical University of Darmstadt produces interactive, language-specific programming environments from formal language definitions. All language-dependent parts of the environment are generated from an entirely nonprocedural specification of the language's syntax, context conditions, and dynamic semantics. The generated environment consists of a language-based editor, supporting systematic program development by named program fragments, an interpreter, and a fragment library system. The major component of the environment is a full-screen editor, which allows both structure and text editing. In structure mode the editor guarantees prevention of both syntactic and semantic errors, whereas in textual mode it guarantees their immediate recognition. PSG editors employ a novel algorithm for incremental semantic analysis which is based on unification. The algorithm will immediately detect semantic errors even in incomplete program fragments. The dynamic semantics of the language are defined in denotational style using a functional language based on the lambda calculus. Program fragments are compiled to terms of the functional language which are executed by an interpreter. The PSG generator has been used to produce environments for Pascal, ALGOL 60, MODULA-2, and the formal language definition language itself.