Showing papers by "James Noble published in 2014"

Combining Tiled and Textual Views of Code

Abstract: Jigsaw puzzle programming environments manipulate programs primarily by drag-and-drop. Generally these environments are based on their own special-purpose languages, meaning students must move on to another language as their programs grow. Tiled Grace is a tile-based editor for Grace, an educational programming language with a conventional textual syntax. Using Tiled Grace, programmers can move seamlessly between visualising their programs as tiles or source code, editing their programs via tiles or text, and continue on to traditional textual environments, all within the same programming language. We conducted a user experiment with Tiled Grace, and present the results of that experiment showing that users find dual views helpful.

Collaboration and learning through live coding (Dagstuhl Seminar 13382)

Abstract: This report documents the program and the outcomes of Dagstuhl Seminar 13382 "Collaboration and learning through live coding". Live coding is improvised interactive programming, typically to create electronic music and other digital media, done live with an audience. Our seminar was motivated by the phenomenon and experience of live coding. Our conviction was that those represent an important and broad, but seldom articulated, set of opportunities for computer science and the arts and humanities. The seminar participants included a broad range of scholars, researchers, and practitioners spanning fields from music theory to software engineering. We held live coding performances, and facilitated discussions on three main perspectives, the humanities, computing education, and software engineering. The main outcome of our seminar was better understanding of the potential of live coding for informing cross-disciplinary scholarship and practice, connecting the arts, cultural studies, and computing.

Graceful Dialects

Abstract: Programming languages are enormously diverse, both in their essential concepts and in their accidental aspects. This creates a problem when teaching programming. To let students experience the diversity of essential concepts, the students must also be exposed to an overwhelming variety of accidental and irrelevant detail: the accidental differences between the languages are likely to obscure the teaching point. The dialect system of the Grace programming language allows instructors to tailor and vary the language to suit their courses, while staying within the same stylistic, syntactic and semantic framework, as well as permitting authors to define advanced internal domain-specific languages. The dialect system achieves this power though a combination of well-known language features: lexical nesting, lambda expressions, multi-part method names, optional typing, and pluggable checkers. Grace's approach to dialects is validated by a series of case studies, including both extensions and restrictions of the base language.

How to Break the Bank: Semantics of Capability Policies

Abstract: The object capability model is a de-facto industry standard widely adopted for the implementation of secure software. We call capability policies the policies enforced by programs using object capabilities. Such policies tend to restrict the objects and the circumstances which may access services. In this paper we argue that capability policies should be made explicit and written separately from the code implementing them. We also argue that the specification of capability policies requires concepts that go beyond the features of current specification languages. Moreover, we argue that we need methodologies with which to prove that programs adhere to their capability policies as specified.

Tinygrace: A Simple, Safe, and Structurally Typed Language

Abstract: Grace is a new gradually, structurally typed object-oriented programming language. Formal models of existing languages provide a rigorous base for claiming type soundness, so we have set about creating a model of a subset of Grace. While much of the formal literature of objects has used structural typing, models of popular modern languages such as Featherweight Java have had to use nominal typing to match the language they are modelling. In contrast to this, we present Tinygrace: a subset of Grace with a structural type system, feature-parity with FJ, and an accompanying proof of soundness.

Rationally Reconstructing the Escrow Example

Abstract: The Escrow Exchange Contract has been used as a case study of building up complex and trustworthy systems from basic object capabilities, in the context of concurrent and distributed programming. In this short paper we present a Rational Reconstruction of the Escrow Exchange Contract case study, expressed in Grace, concentrating on the most essential issues of trustworthiness, and ignoring issues to do with distribution or more complex protocols. We then use our notation for capability policies to specify the key features of the reconstructed case study.

Distributing Expertise in Agile Software Development Projects

Abstract: The distribution of expertise in Agile teams is vital to enable team knowledge to be shared, preserved, and accessed when it is needed. Most studies emphasize knowledge sharing but a few empirical studies focus on skills. Integrating knowledge and skills is vital to leverage expertise in Agile teams. Moreover, it is not easy to leverage expertise by distributing expertise in Agile teams. Through a Grounded Theory study involving 18 Agile practitioners based in New Zealand and Australia, we revealed five approaches to distributing expertise in Agile teams: embracing a master-apprentice model, coaching and mentoring, engaging hands-on learning, establishing discussion platforms and disseminating explicit knowledge. Distributing expertise will provide insight into how Agile team members disseminate available expertise and pull new expertise into Agile teams.

Locating expertise in agile software development projects

Abstract: Agile software development projects rely on the diversity of team members' expertise. It is vital to develop the meta-knowledge of the available expertise in Agile teams. However, locating the internal expertise in Agile teams is not explicitly reported in the literature. Through a Grounded Theory study involving 16 Agile practitioners based in New Zealand and Australia, we revealed four ways to identify internal expertise in Agile software development projects: communicating frequently, working closely together, declaring self-identified expertise, and using an expertise directory. The outcome of this study will provide significant insight into how Agile team members depend on each other in locating their peers' expertise, as well as quantify the level of expertise.

[Demo abstract] LittleBits synth kit as a physically-embodied, domain specific functional programming language

Abstract: littleBits (littleBits.cc) is an open-source hardware library of pre assembled analogue components that can be easily assembled into circuits, disassembled, reassembled, and re-used. In this demo, we consider littleBits --- and the littleBits synth kit in particular ---as a physically-embodied domain specific functional programming language, and how littleBits circuits can be considered as monadic programs.

Livecoding the SynthKit: Little Bits as an Embodied Programming Language

Abstract: LittleBits (little Bits.cc) is an open-source hardware library of pre-assembled analogue components that can be easily assembled into circuits, disassembled, reassembled, and re-used. In this paper, we consider littleBits -- and the littleBits SynthKit in particular -- as a physically-embodied domain specific programming language. We describe the littleBits system, explain how littleBits "programs" are constructed as configurations of physical modules in the real world, and describe how they are typically used to control physical artefacts or constructions. We then argue that littleBits constructions essentially "visualise themselves". We describe how littleBits' liveness, embodiment, and plasticity assists both learning and debugging, and then evaluate littleBits configurations according to the cognitive dimensions of notations.