We must retain liveness and exploratory practices within the programming systems that make us feel most productive. However, the temptation to just reuse black boxes through limited interfaces is pervasive. We expect ...
详细信息
ISBN:
(纸本)9781450399098
We must retain liveness and exploratory practices within the programming systems that make us feel most productive. However, the temptation to just reuse black boxes through limited interfaces is pervasive. We expect time savings and better performance at the cost of poor repairability. Fortunately, we also know about the benefits of having an open implementation constructed from familiar materials, integrated with familiar tools. Consequently, it is primarily a matter of "just building it" ... again? Piece of cake. What could possibly go wrong?
Data analysts use computational notebooks to write code for analyzing and visualizing data. Notebooks help analysts iteratively write analysis code by letting them interleave code with output, and selectively execute ...
详细信息
ISBN:
(纸本)9781450359702
Data analysts use computational notebooks to write code for analyzing and visualizing data. Notebooks help analysts iteratively write analysis code by letting them interleave code with output, and selectively execute cells. However, as analysis progresses, analysts leave behind old code and outputs, and overwrite important code, producing cluttered and inconsistent notebooks. This paper introduces code gathering tools, extensions to computational notebooks that help analysts find, clean, recover, and compare versions of code in cluttered, inconsistent notebooks. The tools archive all versions of code outputs, allowing analysts to review these versions and recover the subsets of code that produced them. These subsets can serve as succinct summaries of analysis activity or starting points for new analyses. In a qualitative usability study, 12 professional analysts found the tools useful for cleaning notebooks and writing analysis code, and discovered new ways to use them, like generating personal documentation and lightweight versioning.
When experimenting on solutions to Machine Learning problems, data scientists often integrate non-linear workflows into Jupyter Notebooks to explore different approaches and evaluate the impact of changes such as usin...
详细信息
ISBN:
(纸本)9798350344172
When experimenting on solutions to Machine Learning problems, data scientists often integrate non-linear workflows into Jupyter Notebooks to explore different approaches and evaluate the impact of changes such as using different Machine Learning models or adjusting parameters. This mode of working leads to Notebooks that are cluttered and difficult to navigate which complicates refining and reusing previous experiments later on. Jupyter Notebooks lack inherent support for such a mode of working. Therefore, we propose the JupyterLab extension HISTREE that provides an interactive tree-based representation of the experiment history in Jupyter Notebooks. Hereby, Notebook versions triggered by specified Notebook operations, are automatically saved and arranged in a tree structure. In this way, HISTREE allows data scientists to explore, compare, organize, and refine their past experiment approaches. In this paper, first, we introduce the concept of an experiment history tree model. This is followed by a comprehensive description of the functionality of HISTREE, which aims to support data scientists in organizing experiments in Jupyter Notebooks. Initial feedback from user experiments shows that the tree-based experiment model is very promising and that the HISTREE extension is both useful and usable to conduct ML experiments in Jupyter Notebooks.
Data scientists are responsible for the analysis decisions they make, but it is hard for them to track the process by which they achieved a result. Even when data scientists keep logs, it is onerous to make sense of t...
详细信息
ISBN:
(纸本)9781450359702
Data scientists are responsible for the analysis decisions they make, but it is hard for them to track the process by which they achieved a result. Even when data scientists keep logs, it is onerous to make sense of the resulting large number of history records full of overlapping variants of code, output, plots, etc. We developed algorithmic and visualization techniques for notebook code environments to help data scientists forage for information in their history. To test these interventions, we conducted a think-aloud evaluation with 15 data scientists, where participants were asked to find specific information from the history of another person's data science project. The participants succeed on a median of 80% of the tasks they performed. The quantitative results suggest promising aspects of our design, while qualitative results motivated a number of design improvements. The resulting system, called Verdant, is released as an open-source extension for JupyterLab.
Programmers often use examples with concrete values to better understand code. Code by itself is abstract, which empowers it to be used for a variety of uses, but can be difficult to grasp by developers. Babylonian Pr...
详细信息
ISBN:
(纸本)9781450396561
Programmers often use examples with concrete values to better understand code. Code by itself is abstract, which empowers it to be used for a variety of uses, but can be difficult to grasp by developers. Babylonian programming addresses this by allowing programmers to concretize their code by defining and visualizing examples directly in the code itself while editing. Currently, Babylonian programming implementations such as Babylonian/S require programmers to define examples manually. For examples containing small objects this is straightforward, however when creating large or complex objects it is not. Sometimes, workarounds such as copying existing code pieces or trying to recreate existing objects are used to reuse information already present in the system, but these workarounds can be error-prone and also time-consuming. In this paper, we propose Example Mining to address this issue by providing techniques and integrated tools to mine examples from existing sources similar to concepts from run-time tracing and test case extraction. Example mining introduces concepts to mine examples from tests, debugging sessions, and traces of actual usage of the system under development. All tools were implemented for Babylonian/S in Squeak/Smalltalk. We demonstrate the usefulness of the tools through walkthroughs. Our tools provide examples for many methods immediately and automatically. As a consequence, programmers have more immediate access to dynamic feedback on their abstract code, making code comprehension and debugging more effective.
End-User Developers program to meet some goal other than the code itself. This includes scientists, data analysts, and the general public when they write code. We have been working for many years on various ways to ma...
详细信息
ISBN:
(纸本)9781450371186
End-User Developers program to meet some goal other than the code itself. This includes scientists, data analysts, and the general public when they write code. We have been working for many years on various ways to make end-user development more successful. In this talk, I will focus on two new projects where we are applying intelligent user interfaces to this long-standing challenge. In SUGILITE, the user can teach an intelligent agent new skills interactively with the user interfaces of relevant smartphone apps through a combination of programming by example (PBE) and natural language instructions. For instance, a user can teach SUGILITE how to order the cheaper car between Uber and Lyft, even though SUGILITE has no access to their APIs, no knowledge about the task domain, and no understanding of the concept "cheap" in advance. Another project, called Verdant, is focusing on helping data scientists, including those using Machine Learning and AI, to do exploratory programming. Verdant supports micro-versioning in computational notebooks for understanding the difference among the output and code of different versions, backtracking, provenance of output to its code, and searching the history. A goal for Verdant is to intelligently organize and summarize the raw history data to help data scientists make effective choices from it.
Traditional behavior-centric debuggers are organized around an extensive call stack, making it hard for programmers to navigate and explore large programs. We present object traces, a novel, object-centric approach to...
详细信息
ISBN:
(纸本)9798400707551
Traditional behavior-centric debuggers are organized around an extensive call stack, making it hard for programmers to navigate and explore large programs. We present object traces, a novel, object-centric approach to time-travel debugging that enables programmers to directly interact with recorded states of objects and explore their evolution in a simplified call tree. Our approach allows programmers to send messages to the object trace to ask questions of different granularity, from single variable values to custom representations of object graphs. We demonstrate practicability by applying it to the TraceDebugger, a time-travel debugger for Squeak/Smalltalk. We examine the practical opportunities and limitations of object traces and suggest directions for future work.
Diplomová práce se věnuje nástrojům, které jsou běžně používané vývojáři v explorativních prostředích jazyků Smalltalk a Self. Tyto jazyky osvobozují uživatele...
详细信息
Diplomová práce se věnuje nástrojům, které jsou běžně používané vývojáři v explorativních prostředích jazyků Smalltalk a Self. Tyto jazyky osvobozují uživatele od nestrukturovaných zdrojových textů. Na druhé straně obsahují nástroje s bohatšími vlastnostmi. Práce obsahuje analýzu, návrh a popis implementace nástroje Object Viewer, který vychází z prostředí jazyka Self a je určený pro jazyky C a C++. Nástroj graficky zobrazuje fragmenty programu (objekty a ukazatele) a umožňuje jejich manipulaci během ladění programu. Na konci práce jsou shrnuty výsledky a navrhnuta další možná rozšíření.
Rendering performance is an everlasting goal of computer graphics and significant driver for advances in both, hardware architecture and algorithms. Thereby, it has become possible to apply advanced computer graphics ...
详细信息
Rendering performance is an everlasting goal of computer graphics and significant driver for advances in both, hardware architecture and algorithms. Thereby, it has become possible to apply advanced computer graphics technology even in low-cost embedded appliances, such as car instruments. Yet, to come up with an efficient implementation, developers have to put enormous efforts into hardware/problem-specific tailoring, fine-tuning, and domain exploration, which requires profound expert knowledge. If a good solution has been found, there is a high probability that it does not work as well with other architectures or even the next hardware generation. Generative DSL-based approaches could mitigate these efforts and provide for an efficient exploration of algorithmic variants and hardware-specific tuning ideas. However, in vertically organized industries, such as automotive, suppliers are reluctant to introduce these techniques as they fear loss of control, high introduction costs, and additional constraints imposed by the OEM with respect to software and tool-chain certification. Moreover, suppliers do not want to share their generic solutions with the OEM, but only concrete instances. To this end, we propose a light-weight and incremental approach for meta programming of graphics applications. Our approach relies on an existing formulation of C-like languages that is amenable to meta programming, which we extend to become a lightweight language to combine algorithmic features. Our method provides a concise notation for meta programs and generates easily sharable output in the appropriate C-style target language.
We describe Slisp (pronounced 'Ess-Lisp'), a hybrid Lisp-C programming toolkit for the development of scriptable and distributed applications. Computationally expensive operations implemented as separate C-cod...
详细信息
We describe Slisp (pronounced 'Ess-Lisp'), a hybrid Lisp-C programming toolkit for the development of scriptable and distributed applications. Computationally expensive operations implemented as separate C-coded modules are selectively compiled into a small Xlisp interpreter, then called as Lisp functions in a Lisp-coded program. The resulting hybrid program may run in several modes: as a stand-alone executable, embedded in a different C program, as a networked server accessed from another Slisp client, or as a networked server accessed from a C-coded client. Five years of experience with Slisp, as well experience with other scripting languages such as Tcl and Perl are summarized. These experiences suggest that Slisp will be most useful for mid-sized applications in which the kinds of scripting and embeddability features provided by Tcl and Perl can be extended in an efficient manner to larger applications, while maintaining a well-defined standard (Common Lisp) for these extensions. In addition, the generality of Lisp makes Lisp a good candidate for an application-level communication language in distributed environments.
暂无评论