Figure 6 - uploaded by Manuel Fähndrich
Content may be subject to copyright.
Paddle game example. (left) First part of game code in action editor (middle) Editing assignment in expression editor (right) Game while executing
Source publication
The world is experiencing a technology shift. In 2011, more touchscreen-based mobile devices like smartphones and tablets will be sold than desktops, laptops, and netbooks combined. In fact, in many cases incredibly powerful and easy-to-use smart phones are going to be the first and, in less developed countries, possibly the only computing devices...
Contexts in source publication
Context 1
... the expression editor, we can easily add the right-hand side of the assignment by tapping on media in the quick-selection list that shows available services in the current context. Now we see the middle screen of Figure 6 in the expression editor. Then we tap on create picture in the quick-selection list which has now adjusted to show everything we can do with media. ...
Context 2
... screenshot of the beginning of the paddle game code in the action editor is shown on the left screen in Figure 6. Listing 1 shows the full game source code. ...
Similar publications
During the last few years the amount of users with mobile devices (laptops, smart phones, tablets, etc.) with wireless connectivity capabilities has grown at an impressive rate. In the meantime, the number of Wi-Fi networks has also increased a lot, and in addition to this, the emergence and fast growth of applications such as social networking, us...
Mobile devices are becoming ubiquitous in both commercial and personal environments. They come in the form of smart phones, laptops, personal digital assistants (PDAs), among others (Ng-Kruelle et a., 2003). With the proliferation of mobile devices comes the risk associated with securing personal information located on these devices. How one percei...
We report the design and implementation of a remote control system and administration of Mexican Array Radio Telescope (MEXART) using a website and a 3G mobile device. The project's goal is the control of the system of steering of the set beams used by the radio telescope to scann the sky using the facilities that at the moment offer the mobile pho...
Citations
... Lastly, the mobile-focused TouchDevelop [22] envisioned a visual programming style targeting the Windows Phone with many of our work's goals, such as a runtime to execute programs ondevice, a visualization close to text-based code and a calculator-like interface for building expressions. However, TouchDevelop deliberately does not feature error handling to simplify programming for beginners, nor does it include automatic evaluation or difficulty adjustment in the context of quizzes. ...
... However, DartBlock uses a more bespoke design for for-loops, where the various components (pre-initialization step, condition, body, post-execution step) are clearly distinguished in the UI to better teach the different steps and their order of execution. Additionally, while TouchDevelop [22] relies on pagination, DartBlock keeps the canvas visible in the background while statement editors are shown as floating views on top of it. The goal is to not confuse the user with multiple levels of pagination while editing statements. ...
Block-based programming has been used as an introductory gateway to programming thanks to its simpler, visual approach for composing code. This work re-imagines this style of coding through the mobile-first framework DartBlock, which is intended to be integrated in a quiz application. It targets an older audience aiming to more quickly transition to the conventional programming language Java, by adopting a syntax visualization and interaction design inspired by integrated development environments. DartBlock focuses on teaching debugging through its included runtime which allows the execution of faulty code with descriptive exception throwing, as well as supporting automatic evaluation of programs given a sample solution to serve as feedback. To suit the smaller screen of mobile devices, the library relies on calculator-like visual editors for each primitive data type to facilitate the composition of complex boolean and numeric expressions without the need for textual input. Finally, we present preliminary student impressions of DartBlock from an initial use case study in a university class and provide organizational recommendations for introducing new frameworks to students.
... Only one study (1/261) presents an approach that is implemented specifically for the iOS platform. Other less popular platforms are almost completely absent, with only one study (1/261) implementing the proposed analysis on TouchDevelop scripts [233]. We speculate that the reason for this disproportion, in addition to the ones already evidenced in the discussion of the platform specificity parameter, stem from the fact that some of the most popular static analysis frameworks (e.g., Soot [238] and WALA [208]) are adapted to support analysis of Android apps. ...
Mobile platforms are rapidly and continuously changing, with support for new sensors, APIs, and programming abstractions. Static analysis is gaining a growing interest, allowing developers to predict properties about the run-time behavior of mobile apps without executing them. Over the years, literally hundreds of static analysis techniques have been proposed, ranging from structural and control-flow analysis to state-based analysis.
In this paper, we present a systematic mapping study aimed at identifying, evaluating and classifying characteristics, trends and potential for industrial adoption of existing research in static analysis of mobile apps. Starting from over 12,000 potentially relevant studies, we applied a rigorous selection procedure resulting in 261 primary studies along a time span of 9 years. We analyzed each primary study according to a rigorously-defined classification framework. The results of this study give a solid foundation for assessing existing and future approaches for static analysis of mobile apps, especially in terms of their industrial adoptability.
Researchers and practitioners can use the results of this study to (i) identify existing research/technical gaps to target, (ii) understand how approaches developed in academia can be successfully transferred to industry, and (iii) better position their (past and future) approaches for static analysis of mobile apps.
... Prior research has examined multi-device programming in mobile contexts. Tillman et al. [56,57] introduced TouchDevelop, a mobile programming environment powered only by touchscreen interactions on the phone. Nguyen et al. [44] explored a similar approach for on-phone debugging. ...
... Our study provides insight into understanding the role of mobile programming tools in practice. Prior research targets how mobile programming can be enhanced with novel touchbased interfaces for the cumbersome nature of text entry on mobile phones [56,57], and cross-device techniques for supporting programmers across multiple mobile devices while stationary [22]. Here, we find that a mobile work experience designed around microproductivity can not only help programmers continue their work on-the-go, but also instill comfort in pausing work unexpectedly. ...
There has been considerable research on how software can enhance programmers' productivity within their workspace. In this paper, we instead explore how software might help programmers make productive use of their time while away from their workspace. We interviewed 10 software engineers and surveyed 78 others and found that while programmers often do work while mobile, their existing mobile work practices are primarily exploratory (e.g., capturing thoughts or performing online research). In contrast, they want to be doing work that is more grounded in their existing code (e.g., code review or bug triage). Based on these findings, we introduce Mercury, a system that guides programmers in making progress on-the-go with auto-generated microtasks derived from their source code's current state. A study of Mercury with 20 programmers revealed that they could make meaningful progress with Mercury while mobile with little effort or attention. Our findings suggest an opportunity exists to support the continuation of programming tasks across devices and help programmers resume coding upon returning to their workspace.
... Generic programming: This category applies to many types of programmers including students, hobbyists, mobile application (app for short) developers, end users, and people who program for fun or as a small part of their work. Mobile devices, which are present with users at almost all times, are seen as good candidates to support self-contained programming anywhere and for simple program entry and editing tasks [19,61,67]. Auxiliary support, e.g., programming tasks; collaborative programming Self-contained programming for end-users, students, mobile app developers ...
... App development on mobile devices: App development environments have been developed on smartphones and tablets for enabling the creation of customized apps using the device resources and for deployment on the devices themselves. For example, TouchDevelop [67] is tailor-made to use the phones' content, sensors, and features to create apps. Newer versions of TouchDevelop can be used on a variety of devices including tablets [7]. ...
... Structured editing: The syntax-directed or structured editing enabled by adaptive keypads and templates for program constructs in TouchDevelop [7,67] and the custom Java keyboard [2] provide a middle ground between the spaceinefficient VP [44] and editing of "raw text" as done on desktops. They also leverage selection using finger taps, which is the most familiar touchscreen interaction known to users and also considered as a unitary act [72]. ...
"What design innovations can the ubiquity and features of mobile devices bring to the programming realm?" has been a long-standing topic of interest within the human-computer interaction community. Yet, the important design considerations for using mobile devices in programming contexts have not been analyzed systematically. Towards this goal, we review a sample of the existing research work on this topic and present a design space covering (i) the target contexts for the designed programming tools, (ii) the types of programming functionality supported, and (iii) the key design decisions made to support the programming functionality on the mobile devices. We also review the design processes in the existing work and discuss objectives for future research with respect to (i) the trade-offs in enabling programming support given the constraints of mobile devices and (ii) applying human-centered methods particularly in the design and evaluation of programming tools on mobile devices.
... Hesenius et al. [13] proposed Factor, a concatenative programming language, to be used in a development environment for tablets. TouchDevelop [31] allowed developers to program and edit applications using the touchscreen of a Windows Phone device. Debugging on mobile devices has been addressed in GROPG [25], a graphical debugging tool. ...
Software developers typically use multiple large screens in their office setup. However, they often work away from the office where such a setup is not available, instead only working with a laptop computer and drastically reduced screen real estate. We explore how developers can be better supported in ad-hoc scenarios, for example when they work in a cafe, an airport, or at a client's site. We present insights into current work practices and challenges when working away from the usual office desk sourced from a survey of professional software developers. Based on these insights, we introduce an IDE that makes use of additional personal devices, such as a phone or a tablet. Parts of the IDE can be offloaded to these mobile devices, for example the application that is being developed, a debugging console or navigational elements. A qualitative evaluation with professional software developers showed that they appreciate the increased screen real estate.
... C 4 is a back end that can be used by various front ends. We implemented two such analyses, one for TouchDevelop [16,34] and one for Cassandra/Java [28] (discussed later). ...
Many distributed databases provide only weak consistency guarantees to reduce synchronization overhead and remain available under network partitions. However, this leads to behaviors not possible under stronger guarantees. Such behaviors can easily defy programmer intuition and lead to errors that are notoriously hard to detect.
In this paper, we propose a static analysis for detecting non-serializable behaviors of applications running on top of causally-consistent databases. Our technique is based on a novel, local serializability criterion and combines a generalization of graph-based techniques from the database literature with another, complementary analysis technique that encodes our serializability criterion into first-order logic formulas to be checked by an SMT solver. This analysis is more expensive yet more precise and produces concrete counter-examples.
We implemented our methods and evaluated them on a number of applications from two different domains: cloud-backed mobile applications and clients of a distributed database. Our experiments demonstrate that our analysis is able to detect harmful serializability violations while producing only a small number of false alarms.
... C 4 is a back end that can be used by various front ends. We implemented two such analyses, one for TouchDevelop [16,34] and one for Cassandra/Java [28] (discussed later). ...
Many distributed databases provide only weak consistency guarantees to reduce synchronization overhead and remain available under network partitions. However, this leads to behaviors not possible under stronger guarantees. Such behaviors can easily defy programmer intuition and lead to errors that are notoriously hard to detect.
In this paper, we propose a static analysis for detecting non-serializable behaviors of applications running on top of causally-consistent databases. Our technique is based on a novel, local serializability criterion and combines a generalization of graph-based techniques from the database literature with another, complementary analysis technique that encodes our serializability criterion into first-order logic formulas to be checked by an SMT solver. This analysis is more expensive yet more precise and produces concrete counter-examples.
We implemented our methods and evaluated them on a number of applications from two different domains: cloud-backed mobile applications and clients of a distributed database. Our experiments demonstrate that our analysis is able to detect harmful serializability violations while producing only a small number of false alarms.
... [8] have shown the feasibility of creating programming environments designed around the interfaces that the modern developer community is used to. Touch Develop [15], for example, was designed with the idea of using only touchscreen input rather than the traditional keyboard. A visual programming environment specifically designed for the creation of Android applications, App Inventor [17], has had significant uptake, and has been used to, e.g., introduce computing science concepts [6], and study how developers' general and domain-specific skill progresses as they develop more apps [18]. ...
In this vision paper, we focus on a key aspect of the modern software developer's potential to write secure software: their (lack of) success in securely using cryptography APIs. In particular, we note that most ongoing research tends to focus on identifying concrete problems software developers experience, and providing workable solutions, but that such solutions still require developers to identify the appropriate API calls to make and, worse, to be familiar with and configure sometimes obscure parameters of such calls. In contrast, we envision identifying and employing targeted visual metaphors to allow developers to simply select the most appropriate cryptographic functionality they need.
... To substantiate the usefulness of our criterion, we built a dynamic analyzer that checks whether the criterion holds on program executions , and evaluated our analyzer on two application domains. First, we analyzed 33 small mobile apps written in TOUCHDEVELOP [35], a framework that uses weakly consistent cloud types [9] . The experimental results indicate that our serializability criterion is able to detect violations that lead to some difficult-to-catch errors. ...
... In this section, we describe and evaluate a dynamic analysis tool for checking serializability violations in TOUCHDEVELOP [35] applications and show that our criterion is precise enough such that violations are likely to indicate actual bugs. TOUCHDEVELOP is a platform for mobile device applications providing direct integration of replicated cloud-backed storage. ...
Developing and reasoning about systems using eventually consistent data stores is a difficult challenge due to the presence of unexpected behaviors that do not occur under sequential consistency. A fundamental problem in this setting is to identify a correctness criterion that precisely captures intended application behaviors yet is generic enough to be applicable to a wide range of applications.
In this paper, we present such a criterion. More precisely, we generalize conflict serializability to the setting of eventual consistency. Our generalization is based on a novel dependency model that incorporates two powerful algebraic properties: commutativity and absorption. These properties enable precise reasoning about programs that employ high-level replicated data types, common in modern systems. To apply our criterion in practice, we also developed a dynamic analysis algorithm and a tool that checks whether a given program execution is serializable.
We performed a thorough experimental evaluation on two real-world use cases: debugging cloud-backed mobile applications and implementing clients of a popular eventually consistent key-value store. Our experimental results indicate that our criterion reveals harmful synchronization problems in applications, is more effective at finding them than prior approaches, and can be used for the development of practical, eventually consistent applications.
... Researchers have also designed syntactic structure editors for more sophisticated languages with non-trivial static type systems. Contemporary examples include mbeddr, a structure editor for a C-like language [63], TouchDevelop, a structure editor for an object-oriented language [60], and Lamdu, a structure editor for a functional language similar to Haskell [33]. Each of these editors presents an innovative user interface, but the non-trivial type and binding structure of the underlying language complicates its design. ...
... Alice [12] is a 3-D programming language with an integrated structure editor for teaching novice CS undergraduate students. Scratch [51] is a structure editor targeted at children ages 8 to 16. TouchDevelop [60] incorporates a structure editor for programming on touch-based devices, and is used to teach high school students. An implementation of Hazelnut might be useful in teaching students about the typed lambda calculus, though that has not been our explicit aim with this work. ...
Structure editors allow programmers to edit the tree structure of a program directly. This can have cognitive benefits, particularly for novice and end-user programmers. It also simplifies matters for tool designers, because they do not need to contend with malformed program text.
This paper introduces Hazelnut, a structure editor based on a small bidirectionally typed lambda calculus extended with holes and a cursor. Hazelnut goes one step beyond syntactic well-formedness: its edit actions operate over statically meaningful incomplete terms. Naïvely, this would force the programmer to construct terms in a rigid âoutside-inâ manner. To avoid this problem, the action semantics automatically places terms assigned a type that is inconsistent with the expected type inside a hole. This meaningfully defers the type consistency check until the term inside the hole is finished.
Hazelnut is not intended as an end-user tool itself. Instead, it serves as a foundational account of typed structure editing. To that end, we describe how Hazelnutâs rich metatheory, which we have mechanized using the Agda proof assistant, serves as a guide when we extend the calculus to include binary sum types. We also discuss various interpretations of holes, and in so doing reveal connections with gradual typing and contextual modal type theory, the Curry-Howard interpretation of contextual modal logic. Finally, we discuss how Hazelnutâs semantics lends itself to implementation as an event-based functional reactive program. Our simple reference implementation is written using js_of_ocaml.
