Contribution: This full research paper presents an innovative parsing technique that aims to improve syntax error messages for undergraduate students. The quality of syntax error messages generated by the new parsing technique was evaluated and compared with the messages produced by mainstream compilers. Background: Unfortunately, compiler error messages are often unhelpful. The study explains some intrinsic challenges faced in generating good syntax error messages and presents a global, local, and expression-level (GLE) parsing technique to overcome some of these challenges. GLE is a 3-phase parsing that prioritizes the parsing of the large code components over diving into all the details. The first phase parses the functional structures and ignores errors in the syntax of the smaller constructions. The second phase parses the control structures and ignores errors in the expressions and other statements. The third phase parses the expressions and statements excluded from phase two. Research Question: Can GLE parsing techniques help generate better syntax error messages? Methodology: The study evaluated the quality of syntax error messages generated by the proposed GLE parsing technique. The evaluation was done in a controlled experiment and within-group design where participants found and fixed errors in erroneous programs using accompanying error messages from different compilers. The independent variable is the compiler type. The dependent variable is the quality of syntax error messages. The quality of syntax error messages is measured by three factors: the success rate of finding errors in erroneous programs, the success rate of fixing syntax errors in erroneous programs, and mean-time-to-find and -fix erroneous programs. Three questions were used to evaluate the “helping in finding errors” quality of the error message: 1) what is the error in the program? 2) in which line is the error? 3) what is the cause of the error? One question was used to evaluate the quality of “helping in fixing errors”: “how to fix the error?” The time that participants used to find and fix a program was calculated. The participants were 51 undergraduate students in the Computer Science and Engineering department at the New Mexico Institute of Mining and Technology. Findings: The results show there is a significant statistical difference in finding errors and fixing erroneous programs using messages generated by the proposed GLE parsing technique and two mainstream compilers: GNU GCC and Microsoft Visual C++. No significant difference exists in the time-to-find and -fix. The result indicates that the proposed GLE parsing technique can help generate better error messages for undergraduate students.

This Innovative Practice Work-in-Progress paper presents an Integrated Learning Development Environment (ILDE) that integrates technologies with pedagogies for first-year students learning to program. Novice programmers must overcome misconceptions, debugging, and problem-solving. ILDE employs multimedia learning content, formative feedback, a customized compiler, and visualization using modern pedagogical and cognitive psychology practices. Visualization and multimedia illustrate what happens inside the computer as the program is running. Enhanced compiler messages with graphical representation reduce the difficulty of compilation errors.

Developing 3D virtual environments requires an advanced level of programming expertise. In many cases, working on such an application involves a wide range of programming activities such as 3D graphics, networking, user interfaces and audio programming. At the same time, such applications are usually real time and performance critical. The complexity of developing such an application comes from two sources: first, the programming language used in development with its strengths and also the limitations it imposes. The second is the requirements of the virtual environment itself, with its dynamics and size. Some languages are more suitable than others for any given application domain, but in general once a programming language is selected, the main focus is the application itself and not the language used. This paper presents an approach where a virtual environment (CVE) and its implementation language (Unicon) evolved together over the course of the project development, derived from emerging functional and performance requirements. The Unicon language was improved and new features were added over time to meet new demands and address the complexities that arose at the application level. This approach was combined with developing a framework to build virtual worlds with a social integrated development environment and to populate those worlds with non-player characters.

There is a growing interest in using game-like virtual environments for education. Massively multi-user online games such as World of War craft employ computer controlled non-player characters (NPCs) and quest activities in training or tutoring capacities. This approach is very effective, incorporating active learning, incremental progress, and creative repetition. This paper explores ways to utilize this model in educational virtual environments, using NPCs as anthropocentric keys to organize and deliver educational content. Our educational NPC design includes a knowledge model and a user performance model, in addition to the physical traits, behavior, and dialog model necessary to make them interesting members of the environment. Web-based educational content, exercises, and quizzes are imported into the virtual worlds, reducing the effort needed to create new NPCs with associated educational content. The NPC architecture supports multi-platform NPCs in two virtual environments, our own CVE (Collaborative Virtual Environment) and Second Life.

Massively multiuser online games such as World of Warcraft employ computer controlled non-player characters (NPCs) and quest activities extensively in tutoring capacities that incorporate active learning, incremental progress, and creative repetition. This poster explores ways to use this model in educational virtual environments (VE), using NPCs as anthropocentric keys to organize and deliver educational content. Our educational NPC design includes a knowledge model and a user performance model, in addition to the physical traits, behavior model, and dialog model necessary to make them interesting, credible members of the environment. Formatted web-based educational content, exercises, and quizzes are imported into the virtual worlds (VWs), reducing the effort needed to create new educational NPCs. The NPC architecture in this poster supports simple multi-platform NPCs that offer educational quests to users in two VEs, CVE and Second Life.

This paper explores generating efficient, portable high-speed producer consumer (HSPC) code on current shared memory architectures: chip multi-processors (CMP), simultaneous multi-threading processors (SMT) and shared memory processors (SMP). To build an HSPC, we use a code generation approach in two stages. Stage one generates data structures to eliminate memory interference. This is done by adjusting and timing cache/buffer/stack placements and lengths for an idealized producer/consumer. Perfect load-balancing is achievable for CMP and SMP, but not for SMT due to simultaneous-execution interference. In stage two, the codebase is refined inside its target application: profiling events sent from Python to a consumer that computes profiling information. Stage two further tests the impact of altering event sizes, synchronization primitives, container libraries, and processor affinity. Stage two achieves near perfect balancing for CMP and SMP architectures, but SMT still performs poorly.

LR parser generators are powerful and well-understood, but the parsers they generate are not suited to provide good error messages. Many compilers incur extensive modifications to the source grammar to produce useful syntax error messages. Interpreting the parse state (and input token) at the time of error is a nonintrusive alternative that does not entangle the error recovery mechanism in error message production. Unfortunately, every change to the grammar may significantly alter the mapping from parse states to diagnostic messages, creating a maintenance problem. Merr is a tool that allows a compiler writer to associate diagnostic messages with syntax errors by example, avoiding the need to add error productions to the grammar or interpret integer parse states. From a specification of errors and messages, Merr runs the compiler on each example error to obtain the relevant parse state and input token, and generates a yyerror() function that maps parse states and input tokens to diagnostic messages. Merr enables useful syntax error messages in LR-based compilers in a manner that is robust in the presence of grammar changes.

This paper presents an application framework in which declarative specifications of debugging actions are translated into execution monitors that can automatically detect bugs. The approach is non-intrusive with respect to program source code and provides a high level of abstraction for debugging activities.

Efficient server selection algorithms reduce retrieval time for objects replicated on different servers and are an important component of Internet cache architectures. This paper empirically evaluates six client-side server selection algorithms. The study compares two statistical algorithms, one using median bandwidth and the other median latency, a dynamic probe algorithm, two hybrid algorithms, and random selection. The server pool includes a topologically dispersed set of United States state government Web servers. Experiments were run on three clients in different cities and on different regional networks. The study examines the effects of time-of day, client resources, and server proximity. Differences in performance highlight the degree of algorithm adaptability and the effect that network upgrades can have on statistical estimators. Dynamic network probing performs as well or better than the statistical bandwidth algorithm and the two probe bandwidth hybrid algorithms. The statistical latency algorithm is clearly worse, but does outperform random selection.

Automatic software instrumentation is usually done at the machine level or is targeted at specific program behavior for use with a particular monitoring application. The paper describes CCI, an automatic software instrumentation tool for ANSI C designed to serve a broad range of program execution monitors. CCI supports high level instrumentation for both application-specific behavior as well as standard libraries and data types. The event generation mechanism is defined by the execution monitor which uses CCI, providing flexibility for different monitors' execution models. Code explosion and the runtime cost of instrumentation are reduced by declarative configuration facilities that allow the monitor to select specific events to be instrumented. Higher level events can be defined by combining lower level events with information obtained from semantic analysis of the instrumented program.

The Alamo monitor architecture reduces the difficulty of writing dynamic analysis tools such as special-purpose profilers, bug-detectors, and visualizations.

Abstract When graphics input/output capabilities are added to a programming language originally designed with a text stream input/output model, various design decisions affect the ease with which the graphics facilities are learned and used by applications programmers. In adding window system facilities to the Icon programming language, some design decisions were made very differently from the conventional wisdom, resulting in substantial benefits for programmers. In addition, some pre‐existing Icon language features have proved to be useful in graphics programming.

Nova is a simple technique for animating a data sequence whose elements include a primary numeric component and possibly one or more secondary dimensions. We use nova to visualize program behavior such as individual memory allocations, where the number of bytes in each allocation is a natural primary numeric dimension.

Abstract Execution monitors are widely used during software development for tasks that require an understanding of program behavior, such as debugging and profiling. The Icon programming language has been enhanced with a framework that supports execution monitoring. Under the enhanced translator and interpreter, neither source modification nor any special compiler command‐line option is required in order to monitor an Icon program. Execution monitors are written in the source language, instead of the implementation language. Performance, portability, and detailed access to the monitored program's state are achieved using a coroutine model and dynamic loading rather than the separate‐process model employed by many conventional monitoring systems.