Quintin I. Cutts

Persistent Hyper-Programs

The traditional representation of a program as a linear sequence of text forces a particular style of program construction to ensure good programming practice. Tools such as syntax directed editors, compilers, linkers and file managers are required to translate and execute these linear sequences of text. At some stage in the execution sequence the source text is checked for type correctness and its translated form linked to values in the environment. When this is performed early in the execution process confidence in the correctness of the program is raised, at the cost of some flexibility of use.

Exploiting Persistent Linkage in Software Engineering Environments

This paper examines some of the advantages of providing software engineering environments within a persistent object system with strong typing and referential integrity. Persistent linkage allows persistent objects to be included in the binding process. Strong typing guarantees that objects are only manipulated in a manner consistent with their type system descriptions. Referential integrity ensures that once a link (reference) to an object is established, its identity is unique and it persists over time. As a consequence no object can be deleted while another refers to it. It is shown how the integration of system specifications, programs, configuration management tools and documentation all within a single persistent environment leads to powerful new techniques. This new power is achieved by sharing structured persistent data across the hitherto enclosing boundaries of system components.

Manipulating mindset to positively influence introductory programming performance

Introductory programming classes are renowned for their high dropout rates. The authors propose that this is because students learn to adopt a fixed mindset towards programming. This paper reports on a study carried out with an introductory programming class, based on Dwecks mindset research. Combinations of three interventions were carried out: tutors taught mindset to students; growth mindset feedback messages were given to students on their work; and, when stuck, students were encouraged to use a crib sheet with pathways to solve problems. The study found that the mixture of teaching mindset and giving mindset messages on returned work resulted in a significant change in mindset and a corresponding significant change in test scores - improvements in test scores were found in a class test given immediately after the six-week intervention and at the end-of-year exam. The authors discuss the results and the strengths and weaknesses of the study.

Peer instruction: a teaching method to foster deep understanding

How the computing education community can learn from physics education.

Enthusing & inspiring with reusable kinaesthetic activities

We describe the experiences of three University projects that use a style of physical, non-computer based activity to enthuse and teach school students computer science concepts. We show that this kind of activity is effective as an outreach and teaching resource even when reused across different age/ability ranges, in lecture and workshop formats and for delivery by different people. We introduce the concept of a Reusable Outreach Object (ROO) that extends Reusable Learning Objects. and argue for a community effort in developing a repository of such objects.

Partial redundancy elimination for access path expressions

Pointer traversals pose significant overhead to the execution of object‐oriented programs, since every access to an objects state requires a pointer dereference. Eliminating redundant pointer traversals reduces both instructions executed as well as redundant memory accesses to relieve pressure on the memory subsystem. We describe an approach to elimination of redundant access expressions that combines partial redundancy elimination (PRE) with type‐based alias analysis (TBAA). To explore the potential of this approach we have implemented an optimization framework for Java class files incorporating TBAA‐based PRE over pointer access expressions. The framework is implemented as a class‐file‐to‐class‐file transformer; optimized classes can then be run in any standard Java execution environment. Our experiments demonstrate improvements in the execution of optimized code for several Java benchmarks running in diverse execution environments: the standard interpreted JDK virtual machine, a virtual machine using ‘just‐in‐time’ compilation, and native binaries compiled off‐line (‘way‐ahead‐of‐time’). Overall, however, our experience is of mixed success with the optimizations, mainly because of the isolation between our optimizer and the underlying execution environments which prevents more effective cooperation between them. We isolate the impact of access path PRE using TBAA, and demonstrate that Javas requirement of precise exceptions can noticeably impact code‐motion optimizations like PRE. Copyright

The Napier88 Persistent Programming Language and Environment

Persistent programming systems are designed as an implementation technology for long lived, concurrently accessed and potentially large bodies of data and programs, known here as persistent application systems (PASs). Within a PAS the persistence concept is used to abstract over the physical properties of data such as where it is kept, how long it is kept and in what form it is kept. As such it is seen as having a number of benefits in simplifying the task of PAS programming. Here, we describe the integrated design of the Napier88 persistent programming system and how Napier88 may be used to develop PASs.

Using persistence technology to control schema evolution

The content of these chapters derives from two papers which explore further the possibilities of the hyperprogramming and hypercode concept. Neither paper describes engineered systems, but rather both are workshop papers which explore long-range possibilities of systems built around the hyperprogramming model. Although most FIDE research is based upon engineering practice as well as ideas, these papers are purely conjectural; the hyperprogramming and hypercode systems are built and in use, but a second generation of such systems is a prerequisite before the engineering aspects of systems such as those outlined here can be investigated, and so at the time of writing these remain descriptions of potential research projects.

Persistent Program Construction through Browsing and User Gesture with some Typing

One method of evaluating programs is for them to be prepared as self contained pieces of source, then compiled, linked and executed. The last phase may involve binding to and manipulating persistent values. When the persistent store is supported by a user interface, the program construction can be augmented by the use of tokens as denotations for persistent values. That is, the manipulation of the persistent store by gesture, for example by an iconic interface linked to a mouse, can be used to provide tokens for persistent values. These tokens can be resolved to provide bindings at run-time, compile-time, program construction time or any mixture of these.

The abstraction transition taxonomy: developing desired learning outcomes through the lens of situated cognition

We report on a post-hoc analysis of introductory programming lecture materials. The purpose of this analysis is to identify what knowledge and skills we are asking students to acquire, as situated in the activity, tools, and culture of what programmers do and how they think. The specific materials analyzed are the 133 Peer Instruction questions used in lecture to support cognitive apprenticeship -- honoring the situated nature of knowledge. We propose an Abstraction Transition Taxonomy for classifying the kinds of knowing and practices we engage students in as we seek to apprentice them into the programming world. We find students are asked to answer questions expressed using three levels of abstraction: English, CS Speak, and Code. Moreover, many questions involve asking students to transition between levels of abstraction within the context of a computational problem. Finally, by applying our taxonomy in classifying a range of introductory programming exams, we find that summative assessments (including our own) tend to emphasize a small range of the skills fostered in students during the formative/apprenticeship phase.