Natural and Flexible Error Recovery for Generated Modular Language Environments

Error recovery is an essential feature for a parser that should be plugged in Integrated Development Environments (IDEs), which must build Abstract Syntax Trees (ASTs) even for syntactically invalid programs in order to offer features such as automated refactoring and code completion. Parsing Expressions Grammars (PEGs) are a formalism that naturally describes recursive top-down parsers using a restricted form of backtracking. Labeled failures are a conservative extension of PEGs that adds an error reporting mechanism for PEG parsers, and these labels can also be associated with recovery expressions to also be an error recovery mechanism. These expressions can use the full expressivity of PEGs to recover from syntactic errors. Manually annotating a large grammar with labels and recovery expressions can be difficult. In this work, we present an algorithm that automatically annotates a PEG with labels, and builds their corresponding recovery expressions. We evaluate this algorithm by adding error recovery to the parser of the Titan programming language. The results shown that with a small amount of manual intervention our algorithm can be used to produce error recovering parsers for PEGs where most of the alternatives are disjoint.

Parser generators are an indispensable tool for rapid language development. However, they often fall short of the finesse of a hand-crafted parser, built with the language semantics in mind. One area where generated parsers have provided unsatisfactory results is that of error recovery. Good error recovery is both natural, giving recovery suggestions in line with the intention of the programmer; and flexible, allowing it to be adapted according to language insights and language changes. This paper describes a novel approach to error recovery, taking into account not only the context-free grammar, but also indentation usage. We base our approach on an extension of the SGLR parser that supports fine-grained error recovery rules and can be used to parse complex, composed languages. We take a divide-and-conquer approach to error recovery: using indentation, erroneous regions of code are identified. These regions constrain the search space for applying recovery rules, improving performance and ensuring recovery suggestions local to the error. As a last resort, erroneous regions can be discarded. Our approach also integrates bridge parsing to provide more accurate suggestions for indentation-sensitive language constructs such as scopes. We evaluate our approach by comparison with the JDT Java parser used in Eclipse.

Software is rapidly moving from the desktop to the Web. The Web provides a generic user interface that allows ubiquitous access, instant collaboration, integration with other online services, and avoids installation and configuration on desktop computers. For software development, the Web presents a shift away from developer workstations as a silo, and has the promise of closer collaboration and improved feedback through innovations in Web-based interactive development environments (IDEs). Moving IDEs to the Web is not just a matter of porting desktop IDEs; a fundamental reconsideration of the IDE architecture is necessary in order to realize the full potential that the combination of modern IDEs and the Web can offer. This paper discusses research challenges and opportunities in this area, guided by a pilot study of a web IDE implementation.

TCP performance over wireless networks often degrades because it cannot effectively differentiate between wireless losses and congestion losses. In this paper, we propose a new version of the TCP protocol, called TCP EWR, which enhances TCP Westwood+ performance by integrating three improvements: in bandwidth estimation, error recovery mechanisms, and loss differentiation techniques. We selected TCP Westwood+ as our base protocol due to its controllable friendliness compared to other protocols. Normally, TCP Westwood+ estimates bandwidth from the sender's side by measuring the rate of returning acknowledgments (ACKs). However, in our approach, we calculate bandwidth using the packet arrival rate, which provides a more accurate estimate in both wired and mixed wiredwireless networks. For error recovery, we developed a more effective scheme that performs better in networks suffering from significant wireless losses. To differentiate between types of losses, we incorporate the Vegas predictor, which helps distinguish between wireless and congestion losses. This paper first analyzes TCP Westwood+ and then details the key techniques used by TCP EWR. We present the results of comprehensive experimental performance studies using simulations, comparing our proposed protocol to major existing protocols such as TCP New Reno, TCP Vegas, TCP Westwood+, and TCP New Jersey. The main finding is that TCP EWR achieves substantial improvements in throughput and goodput over TCP Westwood+, particularly in wired networks. In hybrid wired-wireless networks, TCP EWR also demonstrates better friendliness toward TCP New Reno than TCP Westwood+.

Our aim is to investigate reliable transmission for multicast communication and explore its relationship to multicast routing. We derive two characterizations that enable the comparison of routing algorithms and error recovery mechanisms with respect to the multicast tree topology, namely the probability mass function of successful receptions and the expected number of retransmissions needed to deliver a packet from the source to all receivers. We also give a tight approximation of the computationally expensive expected number of retransmissions. These expressions allow to explore the relationship between routing and error recovery for multicast communication. We finally evaluate the impact of routing algorithms on the performance of reliable multicast transmission and give a realistic generic model for a multicast tree.

Wind River Systems Inc. has implemented VxWorks on the TRON-architecture Gmicro/200 microprocessor. VxWorks is an interactive development environment and real-time kernel in which the real-time target is linked with networked hosts. This paper describes how VxWorks was ported to the Gmicro microprocessor. demonstrates the role of interactive development tools, and discusses VxWorks in light of the TRON concept. >

The paper describes a new tool called JupyTEP integrated development environment (IDE), which is an online integrated development environment for earth observation data processing available in the cloud. This work is a result of the project entitled “JupyTEP IDE—Jupyter-based IDE as an interactive and collaborative environment for the development of notebook style EO algorithms on network of exploitation platforms infrastructure” carried out in cooperation with European Space Agency. The main goal of this project was to provide a universal earth observation data processing tool to the community. JupyTEP IDE is an extension of Jupyter software ecosystem with customization of existing components for the needs of earth observation scientists and other professional and non-professional users. The approach is based on configuration, customization, adaptation, and extension of Jupyter, Jupyter Hub, and Docker components on earth observation data cloud infrastructure in the most flexible way; integration with accessible libraries and earth observation data tools (sentinel application platform (SNAP), geospatial data abstraction library (GDAL), etc.); adaptation of existing web processing service (WPS)-oriented earth observation services. The user-oriented product is based on a web-related user interface in the form of extended and modified Jupyter user interface (frontend) with customized layout, earth observation data processing extension, and a set of predefined notebooks, widgets, and tools. The final IDE is addressed to the remote sensing experts and other users who intend to develop Jupyter notebooks with the reuse of embedded tools, common WPS interfaces, and existing notebooks. The paper describes the background of the system, its architecture, and possible use cases.

Mashups are newly envisaged applications, made up from local information sources and processes, Web services and other distributed resources, bound together technically in some way. Interactive Development Environments (IDE) used to build mashups are becoming more accessible to end-user programmers. Design methods that end-users may apply to a given problem addressed by a mashup, are much less prevalent. This paper describes an end-user-friendly design method called TANDEM and demonstrates the use of it in detail, by way of an example: the design of a mashup of services that solves the so-called movie-cinema problem. An implementation of the newly designed movie-cinema app is then built within the DigitalFriend, an end-user programmer IDE. Furthermore, a significant part of the TANDEM design method, is then automated within the development tool itself. This automation removes the most skilled task required by TANDEM of the end-user: the automation of the process of Data Normalization. The automation applies data normalization to the initial model of components and data sources that feed into the mashup. The presentation here relies on some understanding of Data Normalization, so a simple example is presented. After this demonstrated example of the method and the implementation, the paper discusses the applicability of a model achievable by end-users using TANDEM coupled with the automated normalization process built into the IDE, versus, using a top-down model by an experienced information analyst. In conclusion, the TANDEM method combined with the automation as demonstrated, does empower an end-user to a significant degree in achieving a workable mashup or distributed application. And furthermore, the TANDEM method does have broader applicability to designing a broad class of logic programs, complementing the use of collected patterns in logic programs.

The incorporation of error detection and recovery mechanisms becomes mandatory as the probability of the occurrence of transient faults increases. The detection of control flow errors has been extensively investigated in literature. However, only few works have been conducted towards recovery from control-flow errors. Generally, a program is re-executed after error detection. Although re-execution prevents faults from corrupting data, it does not allow the application to run to completion correctly in the presence of an error. Moreover, the overhead of re-execution increases prominently. The current study presents a pure-software method based on encoded signatures to recover from control-flow errors. Unlike general signature monitoring techniques, the proposed method targets not only interblock transitions, but also intrablock and inter-function transitions. After detecting the illegal transition, the program flow transfers back to the block where the error occurred, and the data errors caused by the error propagation are recovered. Fault injection and performance overhead experiments are performed to evaluate the proposed method. The experimental results show that most control flow errors can be recovered with relatively low performance overhead.

In programming courses, students are often asked to work in groups to write multiple programs. The existing Integrated Development Environments (IDE), however, do not encourage concurrent interactions among student programmers. Students often encounter difficulties in collaborative activities, sharing resources, reviewing code and discussing ideas, especially when the group cannot reach a common arrangement for face-to-face meetings at a convenient time and place. We propose to resolve this problem by transforming the traditional IDE into Software as a Service on the Web, and integrating collaborative features in order to create an interactive and responsive environment, where real-time on-the-job guidance, communication and collaboration can be delivered. In this paper, we introduce a web-based IDE designed for this purpose, and show how it can be applied in programming courses.

An important aspect in the development of dependable software is to decide where to locate mechanisms for efficient error detection and recovery. We present a comparison between two methods for selecting locations for error detection mechanisms, in this case executable assertions (EAs), in black-box, modular software. Our results show that by placing EAs based on error propagation analysis one may reduce the memory and execution time requirements as compared to experience- and heuristic-based placement while maintaining the obtained detection coverage. Further, we show the sensitivity of the EA-provided coverage estimation on the choice of the underlying error model. Subsequently, we extend the analysis framework such that error-model effects are also addressed and introduce measures for classifying signals according to their effect on system output when errors are present. The extended framework facilitates profiling of software systems from varied dependability perspectives and is also less susceptible to the effects of having different error models for estimating detection coverage.

The internal program representation chosen for a software development environment plays a critical role in the nature of that environment. A form should facilitate implementation and contribute to the responsiveness of the environment to the user. The program dependence graph (PDG) may be a suitable internal form. It allows programs to be sliced in linear time for debugging and for use by language-directed editors. The slices obtained are more accurate than those obtained with existing methods because I/O is accounted for correctly and irrelevant statements on multi-statement lines are not displayed. The PDG may be interpreted in a data driven fashion or may have highly optimized (including vectorized) code produced from it. It is amenable to incremental data flow analysis, improving response time to the user in an interactive environment and facilitating debugging through data flow anomaly detection. It may also offer a good basis for software complexity metrics, adding to the completeness of an environment based on it.

There are many application fields for robotic systems including service robotics, search and rescue missions, industry and space robotics. As the scenarios in these areas grow more and more complex, there is a high demand for powerful tools to efficiently program heterogeneous robotic systems. Therefore, we created RAFCON, a graphical tool to develop robotic tasks and to be used for mission control by remotely monitoring the execution of the tasks. To define the tasks, we use state machines which support hierarchies and concurrency. Together with a library concept, even complex scenarios can be handled gracefully. RAFCON supports sophisticated debugging functionality and tightly integrates error handling and recovery mechanisms. A GUI with a powerful state machine editor makes intuitive, visual programming and fast prototyping possible. We demonstrated the capabilities of our tool in the SpaceBotCamp national robotic competition, in which our mobile robot solved all exploration and assembly challenges fully autonomously. It is therefore also a promising tool for various RoboCup leagues.

Optimizing supercomputer performance requires a balance between objectives for processor performance, network performance, power delivery and cooling, cost and reliability. In particular, scaling a system to a large number of processors poses challenges for reliability, availability and serviceability. Given the power and thermal constraints of data centers, the BlueGene/L supercomputer has been designed with a focus on maximizing floating point operations per second per Watt (FLOPS/Watt). This results in a drastic reduction in FLOPS/m <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">2</sup> floor space and FLOPS/dollar, allowing for affordable scale-up. The BlueGene/L system has been scaled to a total of 65,536 compute nodes in 64 racks. A system approach was used to minimize power at all levels, from the processor to the cooling plant. A BlueGene/L compute node consists of a single ASIC and associated memory. The ASIC integrates all system functions including processors, the memory subsystem and communication, thereby minimizing chip count, interfaces, and power dissipation. As the number of components increases, even a low failure rate per-component leads to an unacceptable system failure rate. Additional mechanisms have to be deployed to achieve sufficient reliability at the system level. In particular, the data transfer volume in the communication networks of a massively parallel system poses significant challenges on bit error rates and recovery mechanisms in the communication links. Low power dissipation and high performance, along with reliability, availability and serviceability were prime considerations in BlueGene/L hardware architecture, system design, and packaging. A high-performance software stack, consisting of operating system services, compilers, libraries and middleware, completes the system, while enhancing reliability and data integrity

SIMPLE is a translator writing system composed of a simple precedence syntax analyzer .and a semantic constructor and is implemented in PL/I. It provides an error diagnostic and recovery mechanism for any system implemented using SIMPLE. The removal of precedence conflicts is discussed in detail with several examples. The utilization of SIMPLE is illustrated by defining a command language meta system for the construction of scanners for a wide variety of command oriented languages. This meta system is illustrated by defining commands from several text editors.