Sketching is one of the oldest techniques humans use to express themselves. We sketch to visualize concepts, externalize memory, and communicate ideas. However, we barely use sketching to interact with computers. Given how naturally sketching comes to humans, we believe untapped potential exists in being able to simply draw commands onto a user interface. In this paper, we present results of an elicitation study about expressing common operations in spreadsheets through sketching. Spreadsheets are an interesting class of applications because they are widely used, support complex data and operations, and are available on touch-enabled devices. Our results show that despite considerable variation in syntactic details, participants gravitate towards recurring patterns (e.g., enclosures and arrows, examples and cross-references, and temporal sequences of strokes). The sketch patterns we identified can be a first step towards developing interpreters of sketched commands, and thus enable new means of interacting with spreadsheets and other applications.

Given that touch- and pen-enabled screens are becoming more ubiquitous - not just in mobile devices, but also in laptop computers and large interactive display walls - we are exploring the potential for using digital ink sketches as a novel interaction modality that would allow users to express commands by drawing on top of an application's user interface with a pen or stylus. We hypothesize that such sketch-based interaction could be particularly useful when several people are collaborating at a large wall-mounted display where a mouse and keyboard are not in convenient reach, e.g. when software engineers undertake a code review. As a step towards building a prototype to evaluate that vision, this paper reports on two studies with professional software engineers to elicit and rate sketched expressions of a variety of commands in an integrated software development environment (IDE). We describe the experimental setup and discuss how the findings can help to define a sketchbased command language for IDEs.

The design, development, and deployment of scientific computing applications can be quite complex, in particular when involving Machine Learning (ML) or High-Performance Computing (HPC). They require scientific and software engineering expertise and in addition HPC or ML knowledge. Often, such applications are however developed by scientists who are experts in their domain, but need support for the software engineering, ML, and HPC aspects. The cooperation and communication between experts from these quite different disciplines can be difficult though. We therefore propose to employ the Interaction Room (IR), a method that facilitates interdisciplinary collaboration in complex software projects. An IR uses annotated drawings to exchange information and stimulate discussion between project stakeholders, in order to improve common understanding and identify uncertainties, risks, and other aspects that are critical to a project's success early on. We suggest different drawing canvases and annotations that focus on different viewpoints and issues of the project. These canvases are specific to the project type, such as ML applications or HPC simulations.

A wide variety of Remote Sensing (RS) missions are continuously acquiring a large volume of data every day. The availability of large datasets has propelled Deep Learning (DL) methods also in the RS domain. Convolutional Neural Networks (CNNs) have become the state of the art when tackling the classification of images, however the process of training is time consuming. In this work we exploit the Layer-wise Adaptive Moments optimizer for Batch training (LAMB) optimizer to use large batch size training on High-Performance Computing (HPC) systems. With the use of LAMB combined with learning rate scheduling and warm-up strategies, the experimental results on RS data classification demonstrate that a ResNet50 can be trained faster with batch sizes up to 32K.

Similarly to other scientific domains, Deep Learning (DL) holds great promises to fulfil the challenging needs of Remote Sensing (RS) applications. However, the increase in volume, variety and complexity of acquisitions that are carried out on a daily basis by Earth Observation (EO) missions generates new processing and storage challenges within operational processing pipelines. The aim of this work is to show that High-Performance Computing (HPC) systems can speed up the training time of Convolutional Neural Networks (CNNs). Particular attention is put on the monitoring of the classification accuracy that usually degrades when using large batch sizes. The experimental results of this work show that the training of the model scales up to a batch size of 8,000, obtaining classification performances in terms of accuracy in line with those using smaller batch sizes.

Software engineers routinely use sketches (informal, ad-hoc drawings) to visualize and communicate complex ideas for colleagues or themselves. We hypothesize that sketching could also be used as a novel interaction modality in integrated software development environments (IDEs), allowing developers to express desired source code manipulations by sketching right on top of the IDE, rather than remembering keyboard shortcuts or using a mouse to navigate menus and dialogs. For an initial assessment of the viability of this idea, we conducted an elicitation study that prompted software developers to express a number of common IDE commands through sketches. For many of our task prompts, we observed considerable agreement in how developers would express the respective commands through sketches, suggesting that further research on a more formal sketch-based visual command language for IDEs would be worthwhile.

Summary Sooner or later, in almost every company, the maintenance and further development of large enterprise information technology (IT) applications reaches its limit. From the point of view of cost as well as technical capability, legacy applications must eventually be replaced by new enterprise IT applications. Data migration is an inevitable part of making this switch. While different data migration strategies can be applied, incremental data migration is one of the most popular strategies, due to its low level of risk: the entire data volume is split into several data tranches, which are then migrated in individual migration steps. The key to a successful migration is the strategy for decomposing the data into suitable tranches. This paper presents a method for data decomposition where the entire data volume of a monolithic enterprise IT application is split into independent data migration tranches. Each tranche comprises the data to be migrated in one migration step, which is usually executed during the application's downtime window. Unlike other methods, which describe data migration in a highly abstract way, we propose specific heuristics for data decomposition into independent data packages (tranches). The data migration approach described here is being applied in one of the largest migration projects currently underway in the European health care sector, comprising millions of customer records.

Component trees are region-based representations that encode the inclusion relationship of the threshold sets of an image. These representations are one of the most promising strategies for the analysis and the interpretation of spatial information of complex scenes as they allow the simple and efficient implementation of connected filters. This work proposes a new efficient hybrid algorithm for the parallel computation of two particular component trees-the max- and min-tree-in shared and distributed memory environments. For the node-local computation a modified version of the flooding-based algorithm of Salembier is employed. A novel tuple-based merging scheme allows to merge the acquired partial images into a globally correct view. Using the proposed approach a speed-up of up to 44.88 using 128 processing cores on eight-bit gray-scale images could be achieved. This is more than a five-fold increase over the state-of-the-art shared-memory algorithm, while also requiring only one-thirty-second of the memory.

The accuracy of effort estimates is an important factor for the success of a project. In agile projects, these estimates are often obtained through the structured group estimation process of planning poker. To increase the accuracy of such estimates, we propose to annotate user stories with symbols that highlight risk and effort drivers and thus give all team members a better understanding of a project's challenges. In this paper, we report on the results of a study that examines the effect of using risk and effort annotations on project teams' level of shared understanding, estimation accuracy and estimation bias. Our results show that the use of annotations in planning poker increases estimation accuracy.

In complex business modelling and software development projects, we often observe that teams focus on those aspects of a system that are well understood or easy to resolve, while a blind eye is turned (consciously or subconsciously) to the actual value and effort drivers – i.e. those components that require higher effort due to their intrinsic value, risk, complexity or uncertainty. In this paper, we introduce a pragmatic approach for highlighting elements of high-level business and system models with visual annotations that mark particular issues, requirements or complexities that would otherwise not immediately meet the eye, and would thus present risks to a project's successful completion if uncovered too late.

Large-scale information system development is often plagued by defects and deadline overruns that can be traced to insufficient communication within the project team, particularly between stakeholders from the business, technical and management side. Although agile process models put a strong emphasis on team communication, they provide only little support for focusing the communication on the most relevant issues. We therefore introduce the concept of so-called "interaction rooms", where teams work with a pragmatic combination of model sketches and annotations to foster understanding of the system and its business domain, to reveal risks and uncertainties, and discuss those system aspects that are most critical for project success.

The complexity of data-intensive business processes is typically reflected in the user interfaces of the information systems supporting them. To facilitate ease of use despite the visual and semantic complexity of dialog forms, users should be guided in ways such as highlighting and describing invalid input, showing/hiding or enabling/disabling particular UI widgets. Manual implementation of the rules governing these user interface responses typically requires considerable effort, as they involve business and presentation concerns, and are often dependent on each other. In addition, users expect the interface to respond immediately to any input, which can be especially challenging in web applications. In this paper, we formalize the aspects that must be considered in formulating input evaluation rules, and present a run-time framework that encapsulates the necessary logic, enabling domain experts to specify the business rules instead of requiring developers to implement them.

Development and maintenance of complex web interfaces containing hundreds of input fields typically causes huge development effort. Changing the layout or adding input fields to complex user interfaces are especially tedious tasks are, because these changes affect the alignment of many other interface elements. To reduce this effort, we developed a ruler guide-based approach that combines the efficiency of automatic generation of complex user interfaces from an XML-based specification with the flexibility of a manually layouted user interface. First experiences with a proof-of-concept implementation show that the effort needed for development and maintenance can be significantly reduced.

Information systems for the support of complex business processes are often equipped with web-based front-ends to allow convenient user access. To produce executable specifications of the users' interactions with such web-based applications, we use a visual language that enables developers to model their complex dialog structures. In this paper, we introduce the formal semantics of the core constructs of this Dialog Flow Notation: We define its syntax in terms of invariants about the permitted elements and their relations, and show how any words of the language (i.e. any syntactically correct dialog flow specifications) can be mapped to a deterministic pushdown automaton whose behavior defines the notation's semantics. This gives us and other tool developers a formal basis for the design and implementation of tools and frameworks that mirror the precise meaning of all DFN constructs.

Today, we are seeing an increasing number of software applications that users want to use anywhere, anytime. Such mobile applications often deliver their user interfaces (UIs) to client devices over the World Wide Web. However, Web-based UIs cannot provide the same level of usability as window-based UIs on mobile devices with their small screens and occasional network dropouts. To address this challenge, we present a UI framework that combines the usability of a full-featured UI with the flexibility of a thin presentation logic: We exchange interface specifications and events between the application logic on the server and a generic UI rendering engine on the client device using an instant messaging infrastructure. The paper gives an overview of the framework architecture and the features of the communication protocol, and discusses performance measurements obtained on a public network.

In Web-based applications, most user interactions take the form of navigating between Web pages. The structure of the navigation model thus has a strong impact on a Web application's usability. However, specifying a user-friendly navigation model for complex applications can be time-consuming, especially when designing for multiple presentation channels. We therefore present the formal semantics of the dialog flow notation (DFN) that provides constructs for the design of modular navigation models, and especially focus on constructs that reduce the specification redundancy within and between channels, thus reducing the design effort for Web-based user interfaces

When building enterprise applications that need to be accessed through a variety of client devices, developers usually strive to implement most of the business logic device-independently while using a Web browser to display the user interface. However, when those Web-based front-ends shall be rendered on different devices, their differing I/O capabilities may require device-specific interaction patterns that still need to be specified and implemented efficiently. We present an approach for specifying the dialog flows in multichannel Web interfaces with very low redundancy and introduce a framework that controls Web interfaces' device-specific dialog flows according to those specifications, while keeping the enterprise application logic completely device-independent

When building web applications for use on different devices, developers need to deal with a wide range of input/output capabilities that affect how users interact with the application: A dialog that can be completed in one step on a desktop client may have to be broken up into a number of steps on a small-screen mobile device. Since it is time-consuming to define all the possible dialog masks and dialog flow variants for different channels manually, it would be desirable to automate the adaptation of dialog masks and flows.To address this need, we introduce the DiaDef language for the abstract, device-independent definition of the widgets in a dialog, and the DiaGen framework that automatically breaks this abstract dialog definition down into sufficiently small dialog masks for the users' mobile devices and incorporates them into suitable micro dialog flows that are generated at run-time in order to be handled by our Dialog Control Framework.

Today, thin client applications often rely on the infrastructure of the WWW to deliver their user interfaces (UIs) to clients. While this approach does not require the deployment of application logic on the client, Web-based UIs typically do not provide the same level of usability as window-based UIs. We therefore present a UI framework that combines the flexibility of a thin presentation logic with the usability of a full-featured UI: Our approach uses an XMPP-based instant messaging infrastructure to exchange XUL interface descriptions and events between the application logic on the server and a generic UI rendering engine on the client

When considering the addition of a mobile presentation channel to an existing web-based application, a key question that has to be answered even before development begins is how the mobile channel's characteristics will impact the user experience and the cost of using the application. If either of these factors is outside acceptable limits, economical considerations may forbid adding the channels, even if it would be feasible from a purely technical perspective. Both of these factors depend considerably on two metrics: The time required to transmit data over the mobile network, and the volume transmitted. The PETTICOAT method presented in this paper uses the dialog flow model and web server log files of an existing application to identify typical interaction sequences and to compile volume statistics, which are then run through a tool that simulates the volume and time that would be incurred by executing the interaction sequences on a mobile channel. From the simulated volume and time data, we can then calculate the cost of accessing the application on a mobile channel, and derive suitable approaches for optimizing cost and response times.

We present a dialog-driven process model for the development of Web-based applications that uses a graphical notation to model and iteratively refine the application's dialog flow, and communicate with non-technical stakeholders in the development process. This way, the user interface can drive the design and implementation of the application logic and data model instead of being dictated by it. After an introduction of the underlying notation and dialog control framework, we present how these tools can support the phases of the development process and discuss experiences gained from the implementation of a Web application that was built using this approach.