Abstract not found

The Programmers ’ Playground is a software library and run-time system for creating distributed multimedia applications from collections of reusable software modules. This paper presents the design and implementation of EUPHORIA, Playground’s user interface management system. Implemented as a Playground module, EUPHORIA allows end-users to create direct manipulation graphical user interfaces (GUIs) exclusively through the use of a graphics editor. No programming is required. At run-time, attributes of the GUI state can be exposed and connected to external Playground modules, allowing the user to visualize and directly manipulate state information in remote Playground modules. Features of EUPHORIA include real-time direct manipulation graphics, constraint-based editing and visualization, imaginary alignment objects, user-definable types, and user-definable widgets with alternative representations.

Exception handling is widely regarded as a necessity in programming languages today, and almost every programming language currently used for professional software development supports some form of it. However, spreadsheet systems, which may be the most widely used type of "programming language" today in terms of number of users using it to create "programs" (spreadsheets), have traditionally had only extremely limited support for exception handling. Spreadsheet system users range from end users to professional programmers, and this wide range suggests that an approach to exception handling for spreadsheet systems needs to be compatible with the equational reasoning model of spreadsheet formulas, yet feature expressive power comparable to that found in other programming languages.

We present a theoretical framework for comparing visual languages. This framework was developed in order to teach an introductory visual programming subject. The subject aims at teaching students general principles of visual programming rather than just the details of a particular visual programming systems. To support these aims, we also developed an evaluation framework for visual programming concepts. Such frameworks would be useful for other educators as well as novices to visual programming who want a quick introduction to the numerous publications in this field. 1 Introduction A summary of the visual programming (VP) field is a report of an emerging field which is still developing its theoretical foundations (though see [5] for an interesting approach to a precise theory of VP). An introduction to VP must therefore be an exploration of an emerging field, rather than a report and summary of an established field. This paper presents two overview frameworks developed for SFT5030, ...

It is an interesting and exciting challenge to change programming modalities from a traditional textbased approach to a 2-D screen. Based on a survey of current visual programming systems, we find that numerous software engineering and knowledge engineering techniques are required to meet that challenge. Further, we argue that VP systems can benefit from on-going knowledge engineering research on the computational complexity of different representations. Hence, we conclude that the designers of VP systems should be well-versed in a wide range of knowledge engineering and software engineering techniques. 1 Introduction It is an interesting and exciting challenge to change programming modalities from a traditional textbased approach to a 2-D screen. When faced with such a challenge, we find that a wide range of software engineering and knowledge engineering techniques are required. For example: ffl The main problem with constraint-based visual programming languages (e.g. the THINGLAB...

data types includes a collection of types and operations on those types; data abstraction includes the abstract data type concept and adds information hiding to force the use of the data type. Without abstract data types and data abstraction a language's capabilities are limited.[1] Type systems come in a variety of flavors. Monomorphic type systems mean that each object or parameter value can be, at most, one type. In polymorphic type systems, as the name implies, objects can take on many types. Type systems can also be static or dynamic. Static type systems ensure, at compile time, that a program is type consistent. Dynamic type systems, on the other hand, require type validation at run-time. Objects may be typed either explicitly (generally at the beginning of programming blocks) or implicitly (the system needs to infer the type of the object). Polymorphic type systems can be classified in two major ways, universal and ad-hoc polymorphism, each major category has two sub-categories...

Programming in parallel is an error-prone and complex task compounded by the lack of tool support for both programming and debugging. Recent advances in compiler-directed shared memory APIs, such as OpenMP, have made shared-memory parallelism more widely accessible for users of traditional procedural languages: however, the mechanisms provided are difficult to use and error-prone. This paper examines the use of visual notations for data flow programming to enable the creation of shared memory parallel programs. We present a model, arising from research on the ReactoGraph visual programming language, that allows code in a general class of visual data flow languages to be parallelized using visual annotations, and discuss the advantages this has over current textual methods.

To adapt software to changing requirements, many authors have advocated interspersing code modifications with refactorings to “keep the code clean”. Thus, it is important that refactoring tools are fast, correct, and integrate well with programmers ’ primary workflow. We present data that suggest that programmers underuse refactoring tools and instead refactor by hand; this is a problem because manual refactoring is slow and error-prone. Our data show that programmers underuse refactoring tools because the tools have poor usability: instead of fitting into programmers ’ workflow, the tools get in the programmers ’ way. We propose guidelines for improving the usability of refactoring tools, and then apply these guidelines to the design of two independent user interfaces for tool activation — interfaces that are designed to make the tool part of the programming workflow. A controlled experiment, an analytic comparison of task models, and interviews with experienced programmers combine to suggest that our new interfaces are faster, less error-prone, and more memorable than existing interfaces. We expect that the application of our guidelines to other refactoring tools will improve programmer productivity by helping programmers to focus on the refactoring that they want to accomplish, rather than on the tool that they might use to accomplish it.

Tools that perform semi-automated refactoring are currently under-utilized by programmers. If more programmers adopted refactoring tools, software projects could make enormous productivity gains. However, as more advanced refactoring tools are designed, a great chasm widens between how the tools must be used and how programmers want to use them. This dissertation begins to bridge this chasm by exposing usability guidelines to direct the design of the next generation of programmer-friendly refactoring tools, so that refactoring tools fit the way programmers behave, not vice-versa.