Figure 3 - uploaded by Manuel Fähndrich
Content may be subject to copyright.
TouchDevelop action editor. (left) Main action view; note that return type is hidden, as it is Nothing . (middle) Statement editing options. (right) 

TouchDevelop action editor. (left) Main action view; note that return type is hidden, as it is Nothing . (middle) Statement editing options. (right) 

Source publication
Article
Full-text available
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
... main action view shows the source code of a single action. The font is easily readable, but not big enough for precise selection (left screen shot in Figure 3). The user can tap anywhere on the action to select the statement to operate on. ...
Context 2
... action editor also offers the possibility (Figure 3 left, at the bottom) of executing the currently edited action, adding a new statement at the end of the action (to save one tap), and editing action properties (e.g., the name, formal parameters and return type; in the future we plan to have event bindings here) using a dedicated dialog. ...
Context 3
... the most often used identifiers valid in the current context are immediately available on the main keypad, greatly speeding up expression entry. As an example, entering the program from Figure 3 takes a minimum of 20 taps (including all navigation), which is about 35 seconds for one of the authors, whereas typing it using a regular laptop keyboard takes about 25 seconds. The first line takes 5 taps, second 11, and the last one 4. ...
Context 4
... we add statement after statement with the (+) button at the action level. Now we get presented a list of different statement kinds to choose from, similar to the right screen in Figure 3. For example, to add the second statement (at line 3), we tap the assignment-statement kind, which will implicitly introduce a new local variable pic to hold the result. ...

Similar publications

Conference Paper
Full-text available
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...
Conference Paper
Full-text available
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...
Conference Paper
Full-text available
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

... 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. ...
Article
Full-text available
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. ...
Conference Paper
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]. ...
Conference Paper
"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. ...
Conference Paper
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). ...
Conference Paper
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). ...
Article
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]. ...
Conference Paper
Full-text available
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. ...
Conference Paper
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. ...
Conference Paper
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.
... The automatic generation of mobile applications is a growing research area. Several proposals have been oriented towards end-user development exploiting service composition for general application [1,[6][7][8][9][10][11][12]and mobile application generators for specific domains, including health and tourism/culture [13,14]. In [15], the development methodology for generating mobile applications exploiting mobile service composition has been evaluated through an empirical analysis that revealed that, in spite of the reduced size of the screen, the use of the MicroApp Generator tool improves the effectiveness in terms of time and editing errors with respect to the use of the MIT App Inventor [6]. ...
... Support to speech (i.e., speech-to-text, and text-to-speech) is provided through suitable block components. Microsoft TouchDevelop [7] is a programming environment running on smartphones. It offers built-in primitives, making it easy to get the data provided by the mobile device sensors and by the cloud (via services, storage, computing, and social networks). ...
Article
Full-text available
Mobile devices can be exploited for enabling people to interact with Internet of Things (IoT) services. The MicroApp Generator [1] is a service-composition tool for supporting the generation of mobile applications directly on the mobile device. The user interacts with the generated app by using the traditional touch-based interaction. This kind of interaction often is not suitable for elderly and special needs people that cannot see or touch the screen. In this paper, we extend the MicroApp Generator with an interaction approach enabling a user to interact with the generated app only by using his voice, which can be very useful to let special needs people live at home. To this aim, once the mobile app has been generated and executed, the system analyses and describes the user interface, listens to the user speech and performs the associated actions. A preliminary analysis has been conducted to assess the user experience of the proposed approach by a sample composed of elderly users by using a questionnaire as a research instrument.