Scientists in the MIST: Simplifying Interface Design for End Users

We are building a Malleable Interactive Software Toolkit (MIST), a tool set and infrastructure to simplify the design and construction of dynamically-reconfigurable (malleable) interactive software. Malleable software offers the end-user powerful tools to reshape their interactive environment on the fly. We aim to make the construction of such software straightforward, and to make reconfiguration of the resulting systems approachable and manageable to an educated, but non-specialist, user. To do so, we draw on a diverse body of existing research on alternative approaches to user interface (UI) and interactive software construction, including declarative UI languages, constraint-based programming and UI management, reflection and data-driven programming, and visual programming techniques

Emerging from the MIST: A Connector Tool for Supporting Programming by Non-programmers

Software development is an iterative process. As user re-quirements emerge software applications must be extended to support the new requirements. Typically, a programmer will add new code to an existing code base of an application to provide a new functionality. Previous research has shown that such extensions are easier when application logic is clearly separated from the user interface logic. Assuming that a programmer is already familiar with the existing code base, the task of writing the new code can be considered to be split into two sub-tasks: writing code for the application logic; that is, the actual functionality of the application; and writing code for the user interface that will expose the functionality to the end user. The goal of this research is to reduce the effort required to create a user interface once the application logic has been created, toward supporting scientists with minimal pro-gramming knowledge to be able to create and modify pro-grams. Using a Model View Controller based architecture, various model components which contain the application logic can be built and extended. The process of creating and extending the views (user interfaces) on these model components is simplified through the use of our Malleable Interactive Software Toolkit (MIST), a tool set an infrastructure intended to simplify the design and extension of dynamically reconfigurable interfaces. This paper focuses on one tool in the MIST suite, a connec-tor tool that enables the programmer to evolve the user interface as the application logic evolves by connecting related pieces of code together; either through simple drag-and-drop interactions or through the authoring of Python code. The connector tool exemplifies the types of tools in the MIST suite, which we expect will encourage collabora-tive development of applications by allowing users to inte-grate various components and minimizing the cost of de-veloping new user interfaces for the combined compo-nents

Edition synchrone de plusieurs objets : services et interaction

International audienceGraphical interactions that modify many objects at once have not been studied systematically. Based on contextual inquiries of designers, and on previous systems and work, we have identified the services required for an efficient interaction with multiple objects: set management, action management, and support for exploratory design. We present a number of interactions that provide a subset of the identified services, by relying on an improved property sheet. This work may enable designers to design more consistent and more powerful interactions

The practices of programming

© 2016 IEEE.How diverse are the ways that programming is done? While a variety of accounts exist, each appears in isolation, neither framed in terms of a distinct practice, nor as one of many such practices. In this work we explore accounts spanning software engineering, bricolage/tinkering, sketching, live coding, code-bending, and hacking. These practices of programming are analyzed in relation to ongoing research, and in particular HCI's 'practice turn', offering connections to accounts of practice in other contexts than programming. The conceptualization of practice helps to interpret recent interest in program code as craft material, and also offers potential to inform programming education, tools and work as well as future research