Showing papers by "James Noble published in 2019"

Agile Practices in Practice: Towards a Theory of Agile Adoption and Process Evolution

Abstract: As teams and organisations make the difficult shift to agile ways of working, there has been relatively little investigation of how they adopt and use agile practices. To aid those teams looking to move to agile we should examine how others have done so and what practical value they found. We studied teams which adopted agile practices across a spectrum from taking on a whole methodology to a couple of practices at a time, and then committed to continuous assessment and improvement of their ways of working. Those teams favoured adapting agile-based, team-oriented practices suited to their particular needs over technical practices and defined methodologies.

Interventions for software security: creating a lightweight program of assurance techniques for developers

Abstract: Though some software development teams are highly effective at delivering security, others either do not care or do not have access to security experts to teach them how. Unfortunately, these latter teams are still responsible for the security of the systems they build: systems that are ever more important to ever more people. We propose that a series of lightweight in-terventions, six hours of facilitated workshops delivered over three months, can improve a team's motivation to consider security and awareness of assurance techniques, changing its security culture even when no security experts are involved. The interventions were developed after an Appreciative Inquiry and Grounded Theory survey of security professionals to find out what approaches work best. They were then validated in fieldwork with a Participatory Action Research study that de-livered the workshops to three development organizations. This approach has the potential to be applied by many development teams, improving the security of software worldwide.

Agile Self-selecting Teams Foster Expertise Coordination

Abstract: Aim/Purpose: This paper aims to discuss the activities involved in facilitating self-selecting teams for Agile software development projects. This paper also discussed how these activities can influence the successful expertise coordination in Agile teams. Background: Self-selecting teams enable Agile team members to choose teams based on whom they prefer to work with. Good team bonding allows Agile team members to rely on each other in coordinating their expertise resources effectively. This is the focal point where expertise coordination is needed in Agile teams. Methodology: This study employed Grounded Theory by interviewing 48 Agile practitioners from different software organizations mainly based in New Zealand. This study also carried out several sessions of observations and document analysis in conjunction with interviews. Contribution: This study contributes to the body of knowledge by identifying the way self-selecting teams support expertise coordination. Findings: Our findings indicated that the activities involved tend to influence the successful expertise coordination in Agile teams. Self-selecting teams are essential to supporting expertise coordination by increasing inter-dependencies between Agile team members, ensuring a diverse range of knowledge and skills in teams. Recommendations for Practitioners: The self-selecting team activities can be used as a guideline for Agile software organizations in forming self-selecting teams in the fastest and most efficient way. It is vital for management to facilitate the process of self-selecting teams in order to optimize successful expertise coordination. Recommendation for Researchers: There is potential for further Grounded Theory research to explore more activities and strategies involved in self-selecting teams. Impact on Society: Self-selecting teams in Agile software developments projects tend to boost the productivity of software development. Future Research: Several hypotheses can be tested through a deductive approach in future studies.

Transient Typechecks Are (Almost) Free

Abstract: Transient gradual typing imposes run-time type tests that typically cause a linear slowdown. This performance impact discourages the use of type annotations because adding types to a program makes the program slower. A virtual machine can employ standard just-in-time optimizations to reduce the overhead of transient checks to near zero. These optimizations can give gradually-typed languages performance comparable to state-of-the-art dynamic languages, so programmers can add types to their code without affecting their programs' performance.

First-class dynamic types

Abstract: Since LISP, dynamic languages have supported dynamically-checked type annotations. Even in dynamic languages, these annotations are typically static: tests are restricted to checking low-level features of objects and values, such as primitive types or membership of an explicit programmer-defined class. We propose much more dynamic types for dynamic languages — first-class objects that programmers can customise, that can be composed with other types and depend on computed values — and to use these first-class type-like values as types. In this way programs can define their own conceptual models of types, extending both the kinds of tests programs can make via types, and the guarantees those tests can provide. Building on a comprehensive pattern-matching system and leveraging standard language syntax lets these types be created, composed, applied, and reused straightforwardly, so programmers can use these truly dynamic first-class types to make their programs easier to read, understand, and debug.

Which of My Transient Type Checks Are Not (Almost) Free

Abstract: One form of type checking used in gradually typed language is transient type checking: whenever an object 'flows' through code with a type annotation, the object is dynamically checked to ensure it has the methods required by the annotation. Just-in-time compilation and optimisation in virtual machines can eliminate much of the overhead of run-time transient type checks. Unfortunately this optimisation is not uniform: some type checks will significantly decrease, or even increase, a program's performance. In this paper, we refine the so called "Takikawa" protocol, and use it to identify which type annotations have the greatest effects on performance. In particular, we show how graphing the performance of such benchmarks when varying which type annotations are present in the source code can be used to discern potential patterns in performance. We demonstrate our approach by testing the Moth virtual machine: for many of the benchmarks where Moth's transient type checking impacts performance, we have been able to identify one or two specific type annotations that are the likely cause. Without these type annotations, the performance impact of transient type checking becomes negligible. Using our technique programmers can optimise programs by removing expensive type checks, and VM engineers can identify new opportunities for compiler optimisation.

Design patterns for angular hotdraw

Abstract: The number of web frameworks available for use is growing. Web developers need to learn how to use them effectively and efficiently. Working through the design patterns presented in this paper for the Angular Hotdraw application assists web developers in this task. Web developers should be able to make a start with a the Angular web framework and have a foundation to learn from.

Which of my transient type checks are not (almost) free

Abstract: One form of type checking used in gradually typed language is transient type checking: whenever an object ‘flows’ through code with a type annotation, the object is dynamically checked to ensure it has the methods required by the annotation. Just-in-time compilation and optimisation in virtual machines can eliminate much of the overhead of run-time transient type checks. Unfortunately this optimisation is not uniform: some type checks will significantly decrease, or even increase, a program’s performance. In this paper, we refine the so called “Takikawa” protocol, and use it to identify which type annotations have the greatest effects on performance. In particular, we show how graphing the performance of such benchmarks when varying which type annotations are present in the source code can be used to discern potential patterns in performance. We demonstrate our approach by testing the Moth virtual machine: for many of the benchmarks where Moth’s transient type checking impacts performance, we have been able to identify one or two specific type annotations that are the likely cause. Without these type annotations, the performance impact of transient type checking becomes negligible. Using our technique programmers can optimise programs by removing expensive type checks, and VM engineers can identify new opportunities for compiler optimisation.

CallE: An Effect System for Method Calls

Abstract: Effect systems are used to statically reason about the effects an expression may have when evaluated. In the literature, such effects include various behaviours as diverse as memory accesses and exception throwing. Here we present CallE, an object-oriented language that takes a flexible approach where effects are just method calls: this works well because ordinary methods often model things like I/O operations, access to global state, or primitive language operations such as thread creation. CallE supports both flexible and fine-grained control over such behaviour, in a way designed to minimise the complexity of annotations. CallE's effect system can be used to prevent OO code from performing privileged operations, such as querying a database, modifying GUI widgets, exiting the program, or performing network communication. It can also be used to ensure determinism, by preventing methods from (indirectly) calling non-deterministic primitives like random number generation or file reading.

Towards Gradual Checking of Reference Capabilities

Abstract: Concurrent and parallel programming is difficult due to the presence of memory side-effects, which may introduce data races. Type qualifiers, such as reference capabilities, can remove data races by restricting sharing of mutable data. Unfortunately, reference capability languages are an all-in or nothing game, i.e., all the types must be annotated with reference capabilities. In this work in progress, we propose to mix the ideas from the reference capability literature with gradual typing, leading to gradual reference capabilities.