81,445 research outputs found
Evaluation of a Frame-based Programming Editor
Frame-based editing is a novel way to edit programs, which claims to combine the benefits of textual and block-based programming. It combines structured ‘frames’ of preformatted code, designed to reduce the burden of syntax, with ‘slots’ that allow for efficient textual entry of expressions.
We present an empirical evaluation of Stride, a frame-based language used in the Greenfoot IDE. We compare two groups of middle school students who worked on a short programming activity in Greenfoot, one using the original Java editor, and one using the Stride editor. We found that the two groups reported similarly low levels of frustration and high levels of satisfaction, but students using Stride progressed through the activity more quickly and completed more objectives. The Stride group also spent significantly less time making purely syntactic edits to their code and significantly less time with non-compilable code
Towards rule-based visual programming of generic visual systems
This paper illustrates how the diagram programming language DiaPlan can be
used to program visual systems. DiaPlan is a visual rule-based language that is
founded on the computational model of graph transformation. The language
supports object-oriented programming since its graphs are hierarchically
structured. Typing allows the shape of these graphs to be specified recursively
in order to increase program security. Thanks to its genericity, DiaPlan allows
to implement systems that represent and manipulate data in arbitrary diagram
notations. The environment for the language exploits the diagram editor
generator DiaGen for providing genericity, and for implementing its user
interface and type checker.Comment: 15 pages, 16 figures contribution to the First International Workshop
on Rule-Based Programming (RULE'2000), September 19, 2000, Montreal, Canad
Frame-Based Editing: Easing the Transition from Blocks to Text-Based Programming
Block-based programming systems, such as Scratch or Alice, are the most popular environments for introducing young children to programming. However, mastery of text-based programming continues to be the educational goal for stu- dents who continue to program into their teenage years and beyond. Transitioning across the significant gap between the two editing styles presents a difficult challenge in school- level teaching of programming. We propose a new style of program manipulation to bridge the gap: frame-based edit- ing. Frame-based editing has the resistance to errors and approachability of block-based programming while retaining the flexibility and more conventional programming seman- tics of text-based programming languages. In this paper, we analyse the issues involved in the transition from blocks to text and argue that they can be overcome by using frame- based editing as an intermediate step. A design and imple- mentation of a frame-based editor is provided
Towards a Tool-based Development Methodology for Pervasive Computing Applications
Despite much progress, developing a pervasive computing application remains a
challenge because of a lack of conceptual frameworks and supporting tools. This
challenge involves coping with heterogeneous devices, overcoming the
intricacies of distributed systems technologies, working out an architecture
for the application, encoding it in a program, writing specific code to test
the application, and finally deploying it. This paper presents a design
language and a tool suite covering the development life-cycle of a pervasive
computing application. The design language allows to define a taxonomy of
area-specific building-blocks, abstracting over their heterogeneity. This
language also includes a layer to define the architecture of an application,
following an architectural pattern commonly used in the pervasive computing
domain. Our underlying methodology assigns roles to the stakeholders, providing
separation of concerns. Our tool suite includes a compiler that takes design
artifacts written in our language as input and generates a programming
framework that supports the subsequent development stages, namely
implementation, testing, and deployment. Our methodology has been applied on a
wide spectrum of areas. Based on these experiments, we assess our approach
through three criteria: expressiveness, usability, and productivity
Guide on the Side and LibWizard Tutorials side-by-side: How do the two platforms for split-screen online tutorials compare?
Split-screen tutorials are an appealing and effective way for libraries to create online learning objects where learners interact with real-time web content. Many libraries are using the University of Arizona’s award-winning, open source platform, Guide on the Side; in 2016, Springshare released a proprietary alternative, LibWizard Tutorials. This article reviews the advantages and limitations of this kind of tutorial. It also examines the differences between each platform’s distinctive characteristics. These platforms create similar split-screen tutorials, but have differences that affect diverse aspects of installation, administration, authoring and editing, student learning, data management, and accessibility. Libraries now have the opportunity to consider and compare alternative platforms and decide which one is best suited to their needs, priorities and resources
Beltway: Getting Around Garbage Collection Gridlock
We present the design and implementation of a new garbage collection framework that significantly generalizes existing copying collectors. The Beltway framework exploits and separates object age and incrementality. It groups objects in one or more increments on queues called belts, collects belts independently, and collects increments on a belt in first-in-first-out order. We show that Beltway configurations, selected by command line options, act and perform the same as semi-space, generational, and older-first collectors, and encompass all previous copying collectors of which we are aware. The increasing reliance on garbage collected languages such as Java requires that the collector perform well. We show that the generality of Beltway enables us to design and implement new collectors that are robust to variations in heap size and improve total execution time over the best generational copying collectors of which we are aware by up to 40%, and on average by 5 to 10%, for small to moderate heap sizes. New garbage collection algorithms are rare, and yet we define not just one, but a new family of collectors that subsumes previous work. This generality enables us to explore a larger design space and build better collectors
Live Programming Environment for Deep Learning with Instant and Editable Neural Network Visualization
Artificial intelligence (AI) such as deep learning has achieved significant success in a variety of application domains. Several visualization techniques have been proposed for understanding the overall behavior of the neural network defined by deep learning code. However, they show visualization only after the code or network definition is written and it remains complicated and unfriendly for newbies to build deep neural network models on a code editor. In this paper, to help user better understand the behavior of networks, we augment a code editor with instant and editable visualization of network model, inspired by live programming which provides continuous feedback to the programmer
Recommended from our members
Towards an aspect weaving BPEL engine
This position paper proposes the use of dynamic aspects and
the visitor design pattern to obtain a highly configurable and
extensible BPEL engine. Using these two techniques, the
core of this infrastructural software can be customised to
meet new requirements and add features such as debugging,
execution monitoring, or changing to another Web Service
selection policy. Additionally, it can easily be extended to
cope with customer-specific BPEL extensions. We propose
the use of dynamic aspects not only on the engine itself
but also on the workflow in order to tackle the problems of
Web Service hot deployment and hot fixes to long running
processes. In this way, composing aWeb Service "on-the-fly"
means weaving its choreography interface into the workflow
- …