Informatics in schools is in a different situation in each country, whether barely present or fully integrated into a national curriculum. In this position paper we discuss the reasons (''why'') behind teaching informatics to all students (''who''), the shape that this should take (''what''), and offer case studies of two countries that have implemented it in differing ways (and to differing extents): England and Denmark, including ''how'' they initiated this change. We find that although England has been successful at introducing informatics at all ages, it is very programming focused. Denmark offers a more rounded curriculum suitable for all students, but progress has been slow at implementing it nationwide. Important issues of equity remain unsolved and overlooked, especially around special educational needs and disabilities.

Data privacy and software accessibility are important issues. In order to enforce correct practice, many American states (and other countries) are introducing legislation to enforce data privacy and software accessibility for tools that are used in school classrooms. This has widespread implications for the use of programming tools in computer science classrooms in the USA and globally. The makers of such tools must ensure compliance with these laws and typically school districts are requiring certification of this before teachers can use them. This applies even if the tool is making no direct or indirect revenue, which adds a technical and legal burden even for free open-source tools. This birds-of-a-feather session is intended to bring together everyone affected by these changes -- teachers, school districts, policy-makers, and programming tool makers -- to discuss the ramifications of these issues and form ideas for best practices.

We present Menagerie, an open-ended project-scale second-semester CS1 Java assignment dataset that ran over four academic years (18/19 - 21/22). It comprises 667 submissions, with 273 being subsequently graded post hoc. The assignment was open-ended, with the students being asked to implement a 'predator/prey' simulator and to meet specific criteria, which included adding five species, competing for the same food source and keeping track of the time of day. The submissions were assessed as part of a separate study on the correctness of the solution, how well the code was designed, how readable the code is, and the quality of the documentation.

The traditional way to publish scientific research is to design, conduct, analyse and write-up the study before submitting to any kind of peer review. However, some issues with studies (such as the choice of data to collect) can only be fixed at the design stage. Therefore some reviewer comments (and rejections) reveal a huge waste of time: the authors cannot fix the issue without re-designing and re-running the study, so the authors', participants' and reviewers' time was wasted. Registered Reports are a new way to publish where the peer review is done after the design stage, but before the study is conducted. This allows design issues to be corrected early in the research process, when it is still possible to do so. At this point, a decision is made to reject the paper, or accept it in-principle. This means that authors can know if their study will be published before they have even begun data collection. This is beneficial for authors, and reduces incentives to fish for significant results or fudge the analysis. In this talk I will explain the registered reports process, as well as why and how authors of computer science education research studies can participate in this new way of publishing.

There are now many large datasets available for programming education research. They tend to be very large-scale, but often lack context or detailed participant information. This ''big data'' is in contrast to the ''rich data'' that has generally been collected from smaller, qualitative studies, with detailed context and participant information. Big data is often criticised for its lack of context, while rich data is often criticised for its small sample size which makes generalisable conclusions dubious. In this position paper we examine the constraints, advantages, and disadvantages of each type of data, and discuss how they can provide differing information on phenomena in programming education research. We argue that both types of data are useful and that we should value the potential findings of each, as well as encourage their combination in order to provide a complete picture of how people learn to program.

Novices frequently learn to program using text-based programming, in languages such as Java. Programs can be constructed in a variety of different ways. Novices may write them sequentially, one line after another, or they may use top-down design to write outlines then fill them in. They may do a lot of trial and error: writing and deleting as they receive errors, or they may use a lot of copy-and-paste. This level of detail -- higher than keystroke-level editing but below plan-composition analysis -- has rarely been explored in programming education research, but it can provide insight into how novices tackle program construction, and offer hints as to how they wrestle with the challenges of constructing an error-free program. In this paper we used thematic analysis to create a reliable set of tags for Java program construction, and then used them to tag over 100 programming sessions lasting over 300 hours. We empirically find that novices rarely comment, rarely plan, and frequently program by copying code they already wrote in the project and pasting it then adjusting it -- which we think indicates a way to transfer the knowledge of the code they just wrote to the next code they are constructing. We offer thoughts on the viability of this work and the difficulty of tagging higher-level behaviours such as responses to errors.

Background and Context: The designers of programming editors aimed at learners have long experimented with different styles of code presentation. The idea of syntax highlighting – coloring specific words – is very old. More recently, some editors (including text-, frame- and block-based editors) have added forms of scope highlighting – colored rectangles to represent programming scope – but there have been few studies to investigate whether this is beneficial for novices when reading and understanding program code.

Research into automated grading has increased as Computer Science courses grow. Dynamic and static approaches are typically used to implement these graders, the most common implementation being unit testing to grade correctness. This paper expands upon an ongoing systematic literature review to provide an in-depth analysis of how machine learning (ML) has been used to grade and give feedback on programming assignments. We conducted a backward snowball search using the ML papers from an ongoing systematic review and selected 27 papers that met our inclusion criteria. After selecting our papers, we analysed the skills graded, the preprocessing steps, the ML implementation, and the models' evaluations.

Statistical tests, such as t-tests, are in widespread use in computer science education research. However, without a formal statistical background, many researchers find themselves applying statistical tests while being uncertain about the principles behind them. This in-person workshop will help any researchers who use frequentist statistics and want a firmer understanding of the underlying principles: what is a p-value, what does statistical significance really mean, what is a confidence interval, what is good practice and what should be avoided? It is suitable for anyone with an interest in using statistics in their research.

Python is a very popular programming language in high schools for teaching programming. It is often used as the first text-based programming language after earlier teaching with blocks. This shift to textual syntax can prove to be a bump in the road for learners. Frame-based editing is a hybrid between blocks and text, which can thus smooth this transition. Strype is a frame-based editor for Python that can now be used to program entirely within the web browser. Strype is free and publicly available (at https://strype.org/), and in this demo we will show how it can be used to write and execute code.

In traditional scientific publishing, studies are designed, conducted and written-up, then submitted to a conference or journal for peer review. This means that any feedback from reviewers on the design of the study is too late to be acted upon. It also means that reviewers cannot detect questionable practices such as bending of the written-up study aims to match the found data, or modification of the analysis to produce a statistically significant result. Registered Reports are a new kind of scientific publication process where the study design is written-up and peer reviewed before the study is conducted. This way, changes to data collection or procedure can still be made in response to reviewer comments, and the analysis has been stated on the record. The accept/reject decision is also made in principle at this stage, which avoids the decision being based on whether results are significant and can increase researcher confidence that the work will be published. At the time of writing, Registered Reports are available at the Computer Science Education journal and are being added at ACM Transactions on Computer Education. If not publishing at these venues, preregistration is a voluntary alternative where the design is published at a trusted third-party site like the Open Science Foundation (with an embargo), but without the peer review and early accept/reject. This birds of a feather session will bring together researchers with an interest in registering their study, reviewing such studies, or who have questions or interest in this new process.

Java had a long period of little change in its features: between Java 5 in 2004 and Java 9 in 2017, lambda functions were the only major addition to the language. However, Java's development pace has suddenly quickened, and not just in version numbers: by the time Java 17 was released in September 2021, new features in the language since Java 9 included record types, switch expressions, sealed classes, var declaration types, text blocks and pattern-matching instanceof. More new features are also on the horizon. Java remains one of the most popular languages for teaching in high-school and university/college, but many educators will not have had the time to learn these new features, let alone consider whether they should adjust their teaching to include any of these features. In this in-person workshop we will explain the new features to attendees and then facilitate discussion on whether the features should be incorporated into Java teaching at the introductory or advanced level, if at all.

Background and Context. The quality of a research field is greatly determined by the quality of its publications. However, in many research fields this quality is endangered because of biases towards publishing positive results, which have led to questionable research practices that negatively impact the reliability of the reported findings. Objectives. We explored two approaches that could guard against these questionable research practices for computer science education research: 1. The replication of prior studies to confirm (or refute) previous findings and 2. requiring authors to submit a registered report, containing hypotheses, methods, and analytic procedures, before conducting the studies. Method. Over the span of 18 months, we organized a special issue of the Computer Science Education journal that only accepted registered reports that replicated a previous computer science education research study. Registered reports involve peer review and approval at the research design stage, before data collection begins. The editorial process was thus modified to accommodate multiple rounds of review and a longer time period between original and final submissions. We believe this is the first use of registered reports in computer science education research. A questionnaire gathering feedback on the new process was also administered to the authors of the accepted reports. Findings. We found seven author teams willing to submit a manuscript for the special issue. Out of this pool, preregistered reports from five teams were accepted to be taken forwards. One team then withdrew because the ethics procedure at their institution exceeded the special issue timeline. The remaining four author teams conducted their studies and resubmitted full papers that were accepted, pending some final corrections. Authors’ feedback about the registered reports process was positive. Implications. We demonstrated that it is possible to attract interest for registered report replications in a computer science education journal issue, and to successfully conduct the necessary editorial steps. Future efforts should attend to challenges related to modified research and journal submission timelines and consider adding a second review cycle for the first stage of registered reports. While the procedures used in this special issue may be suitable for many research approaches, further discussion is warranted on how they can be combined with exploratory research (as opposed to hypothesis testing research) and how they can be adapted to non-positivist research.

Strype is a frame-based editor for a Python-like language that can target execution either in the browser or on the micro:bit device. Frame-based editing sits between block-based and text-based editing, featuring the easy graphical structuring of block-based editing but also the fast keyboard entry/manipulation of text-based editing. Thus frame-based editing in Strype can act as a bridge between block-based editing and text-based editing, especially if the latter involves programming in Python. In our courseware presentation we will provide a demonstration of the Strype editor. We will showcase Strype's unique features and show what it can bring to the educational community. We also hope that the presentation will permit a fruitful exchange between Strype's developers and teachers who may use it.

Block-based programming languages are very popular for introducing young novices to programming. The drag-and-drop interface, with large palettes of blocks, aids initial manipulation and discoverability. When novices continue with programming, they will likely do so by transitioning to a text-based programming language where they are confronted by a blank page and a blinking cursor. The move can be quite a shock. It is important for educators to be able to help with this transition. There are several elements to managing this transition: pedagogical, or tool-based. There exist tools that can show blocks and text, and there also exist tools occupying a middle space between blocks and text.

Interesting ideas for computing education research often involve analysis of source code written by beginners. The process is often difficult to carry out: data must be collected from learners and then the code must be analysed. This can be daunting and time-intensive. In this workshop we will show how to get started with syntactic source analysis using a pre-provided data set and an easier analysis technique. The dataset is Blackbox Mini; the Blackbox project has been collecting data from Java novices for the last eight years and a subset of the data, named Blackbox Mini, has been extracted into a SrcML data format. SrcML is an XML-based format for storing program code so that the syntax tree can be navigated using existing powerful XML libraries. This makes source code analysis easier and more accessible to a wider audience. Attendees at the workshop will learn how to use SrcML to work with the Blackbox Mini data set, including basic statistics gathering, and basic syntactic source code analysis. As a result, attendees will be able to design and execute their own source-based research studies. Attendees should bring their own device with an SSH client installed.

Frame-Based Editing (FBE) is a novel programming style which encompasses the good features of both Block and Text based editing. Moreover, FBE is designed as a middle step between Block and Text based editing, in order to ease the transition from the first to the latter. Strype is a new online editor which implements the FBE idea for Python and is used for programming the micro:bit. This demo will showcase the unique characteristics of Strype and demonstrate its use. Also, this demo will introduce Strype, and FBE generally, to the educational community in order to initiate fruitful discussions, get feedback and also promote its adoption to the educational community.

Java is a popular programming language for teaching at university level. BlueJ is a popular tool for teaching Java to beginners. We provide several analyses of Java use in BlueJ to answer three questions: what use is made of different parts of Java by beginners when learning to program; how has this pattern of use changed between 2013 and 2019 in a longstanding language such as Java; and to what extent do beginners follow the specific style that BlueJ is designed to guide them into? These analyses allow us to see what features are important in object-oriented introductory programming languages, which could inform language and tool designers -- and see to what extent the design of these programming tools can have an effect on the way the language is used. We find that many beginners disobey the guidelines that BlueJ promotes, and that patterns of Java use are generally stable over time -- but we do see decreased exception use and a change in target application domains away from GUI programming towards text processing. We conclude that programming languages for novices could have fewer built-in types but should retain rich libraries.

The term "the machine" is commonly used to refer to the complicated physical hardware running similarly complex software that ultimately executes programs. The idea that programmers write programs for a notional machine - an abstract model of an execution environment - not the machine itself, has risen to the point of gaining acceptance as a useful device in computing education. This has seeded a growing discussion about how explicitly utilizing notional machines in teaching can help students construct more accurate mental models, which is essential for learning programming. Much of the existing literature necessarily involves specific languages, visualization, and/or facilitating tools, and is not very accessible to many practitioners. Less focus has been put on how teachers can make explicit use of notional machines in their teaching. In this paper we describe notional machines and their use in a manner that is more accessible to a general educator audience in order to facilitate more effective computing education at all levels. We advocate explicitly delineating between visualization tools and the notional machines they depict, isolating and clarifying the notional machine so that it is conspicuous, apparent and useful. We present examples of how this approach can facilitate a more consistent method of teaching computing, and be used in more effective pedagogical practice for teaching computing.

BlueJ is a Java IDE for beginners that has been in widespread use for over twenty years. It is designed specifically for novices, to minimise the amount of cognitive load when learning to program and provide a productive learning experience that supports the teaching of key object-oriented concepts such as the class/object distinction, encapsulation, construction and inheritance.

The Blackbox project collects programming activity data from users of BlueJ, a Java IDE aimed at novices. The Blackbox data set has grown very large, with several terabytes of source code data. This is a double-edged sword; it provides large amounts of data for analysis, but it can be difficult for newcomer researchers to get started with analysis. In this workshop we will introduce attendees to analysing the data by using Blackbox Mini: a new curated subset of the Blackbox data set, designed to help researchers try out their source code analyses on a smaller data set.

Block-based programming languages and environments have several benefits for introductory programming courses, compared to more traditional text-based languages. In particular, blocks remove the burden of learning language syntax and dealing with syntax-related errors. Many blocks-based environments are tightly focused on developing graphical games, stories and simulations, while the more general programming environments are typically text-based. In this tool paper, we describe the incorporation of a Stride editor within the BlueJ programming environment. Stride is a frame-based programming language, intended to combine the best of blocks and text programming, usable both as a stepping stone towards text-based languages and as a comprehensive language in its own right. The incorporation of Stride into BlueJ brings some aspects of block programming into a general purpose educational environment.

The Blackbox project has been collecting programming activity data from users of BlueJ (a novice-targeted Java development environment) for nearly five years. The resulting dataset of more than two terabytes of data has been made available to interested researchers from the outset. In this paper, we assess the impact of the Blackbox project: we perform a mapping study to assess eighteen publications which have made use of the Blackbox data, and we report on the advantages and difficulties experienced by researchers working with this data, collected via a survey. We find that Blackbox has enabled pieces of research which otherwise would not have been possible, but there remain technical challenges in the analysis. Some of these -- but not all -- relate to the scale of the data. We provide suggestions for the future use of Blackbox, and reflections on the role of such data collection projects in programming research.

Research from educational psychology suggests that teaching and learning are subject-specific activities: learning programming has a different set of challenges and techniques than learning physics or learning to read and write. Computing is a younger discipline than mathematics, physics, or biology, and while there have been correspondingly fewer studies of how best to teach it, there is a growing body of evidence about what works and what doesn’t. This paper presents ten quick tips that should be the foundation of any teaching of programming, whether formal or informal.

BlueJ is a beginner's IDE for Java which has been in popular use for over ten years. But it continues to improve and evolve: BlueJ 4.0.0 was recently released with several new features. Git support has been added in a user-friendly way, and the support for writing JavaFX GUI applications has been improved. BlueJ 4 also includes the frame-based Stride editor (previously seen in Greenfoot), which allows for block-like programming. BlueJ 4 also retains all its existing functionality such as interactive object creation and method invocation, a "REPL"-like code pad, a debugger and testing support. This workshop, run by the developers of BlueJ, will take the participants, whether new to BlueJ and Java or long-time users, through the new features while also providing an introduction/refresher on the existing capabilities of the software. Participants will learn how to share BlueJ projects via Github, create a new JavaFX application, dabble with Stride and get a tour of the existing BlueJ functionality. A laptop with BlueJ 4.0 installed is required.

As more programming environments add logging features and programming data becomes more accessible, it is important to have a conversation about how we share and use this data. Uses of programming log data range from big-picture analyses to dashboards for instant teacher feedback, to intelligent, data-driven learning environments. The goal of this BOF is to talk about what data is important to collect, where it can be gathered and shared, what general data formats make sense, how to handle privacy and anonymization, and what ultimately we want to see the data used for. The BOF welcomes both producers of programming log data and current or potential consumers, interested in how it could be applied in their classrooms or research. One hopeful outcome of this BOF is a commitment to documenting and sharing existing programming data in an accessible location and format.

Teaching is the process of conveying knowledge and skills to learners. It involves preventing misunderstandings or correcting misconceptions that learners have acquired. Thus, effective teaching relies on solid knowledge of the discipline, but also a good grasp of where learners are likely to trip up or misunderstand. In programming, there is much opportunity for misunderstanding, and the penalties are harsh: failing to produce the correct syntax for a program, for example, can completely prevent any progress in learning how to program. Because programming is inherently computer-based, we have an opportunity to automatically observe programming behaviour -- more closely even than an educator in the room at the time. By observing students’ programming behaviour, and surveying educators, we can ask: do educators have an accurate understanding of the mistakes that students are likely to make? In this study, we combined two years of the Blackbox dataset (with more than 900 thousand users and almost 100 million compilation events) with a survey of 76 educators to investigate which mistakes students make while learning to program Java, and whether the educators could make an accurate estimate of which mistakes were most common. We find that educators’ estimates do not agree with one another or the student data, and discuss the implications of these results.

Plain text has always been the predominant medium for writing and editing programs for expert users. Text is powerful and flexible, but requires more careful manipulation than structural editors, such as those found in block-based environments. In addition, in textual editors programmers are responsible for managing detailed orthography and layout - when beginners work with text, significant time is spent managing syntax problems, indentation and spacing. Frame-based editing is a new editing paradigm that combines the structural editing of block-based systems with the flexibility and keyboard-focus of text editing. In this paper, we empirically examine how much time and effort is spent by beginners on managing syntax errors and indentation, which can be automatically saved by switching to frame-based editing. The data is obtained using the Blackbox dataset, the results predict a clear advantage of frame-based editing over traditional text editors.

Frame-based editing is a novel way to edit programs, which claims to combine the benefits of textual and block-based programming. It combines structured `frames' of preformatted code, designed to reduce the burden of syntax, with `slots' that allow for efficient textual entry of expressions. We present an empirical evaluation of Stride, a frame-based language used in the Greenfoot IDE. We compare two groups of middle school students who worked on a short programming activity in Greenfoot, one using the original Java editor, and one using the Stride editor. We found that the two groups reported similarly low levels of frustration and high levels of satisfaction, but students using Stride progressed through the activity more quickly and completed more objectives. The Stride group also spent significantly less time making purely syntactic edits to their code and significantly less time with non-compilable code.

The Blackbox project collects data from opted-in users of the BlueJ beginners' Java IDE. This data includes source code edits, compilation results, and use of various tools within BlueJ (such as the debugger). Interested researchers may sign up either to use the global database, and/or to use Blackbox as a data collection platform for their local BlueJ-based studies. Blackbox has been running for over two years and contains the results of over 100 million compilation events from over 1 million users. Over 50 researchers have already signed up for access to the data. This session will allow interested researchers, whether already using Blackbox or not, to come together and talk to each other and to the Blackbox team about using the Blackbox data in their research. The Blackbox team will provide a brief overview of the project, and the research opportunities it provides, followed by lots of time for questions and discussion.

Blocks-based programming has become a very popular technology for teaching introductory programming in schools, but it still faces some issues as learners progress. The large transition gap between blocks-based and text-based programming is a source of worry for many educators. However, the difficulties learners have with developing and maintaining progressively larger and more complex programs in block-based systems force teachers to move students on to text-based systems rather than remain with blocks. Greenfoot 3 introduces frame-based programming, a hybrid of blocks-based and text-based programming. Frame-based programming adds comprehensive keyboard support, along with several other usability improvements aimed at removing frustrations for intermediate and experienced programmers, while also providing a way to fill the gap in the transition process.

Blocks-based programming is becoming the way that learners are being introduced to programming and computer science. Led by the popularity of tools like Scratch, Alice, and Code.org's Hour of Code activities, many new programming environments and initiatives are employing the blocks-based modality. This trend can be seen in the growing number of classroom computer science curricula incorporating blocksbased environments into their materials. Despite this rise in use, many open questions remain surrounding blocks-based programming. In this panel, we discuss the current state of blocks-based programming environments, review what we know about learning with blocks-based tools, and look to the future, discussing what form next-generation blocks-based, or blocks-inspired, programming environments might take. Research looking at blocks-based programming is revealing that modality matters: that the representations used to present programming concepts affect learners' conceptual understanding [6], programming practices [3], and perceptions of programming and computer science [5]. This panel brings together leading designers and researchers looking to advance graphical, blocks-based programming through new, innovate designs. The panel will open with a review of current research literature on learning with blocks-based programming and then continue with presentations of three recently designed blocks-based programming environments (Greenfoot 3, GP, Pencil Code), each of which look to push the boundaries of the approach in diffierent directions. These short presentations will frame the discussion of pertinent questions facing designers and educators who use blocksbased programming environments.

Previous investigations of student errors have typically focused on samples of hundreds of students at individual institutions. This work uses a year's worth of compilation events from over 250,000 students all over the world, taken from the large Blackbox data set. We analyze the frequency, time-to-fix, and spread of errors among users, showing how these factors inter-relate, in addition to their development over the course of the year. These results can inform the design of courses, textbooks and also tools to target the most frequent (or hardest to fix) errors.

The Raspberry Pi is an affordable and powerful (for its size) credit-card sized computer that has become very popular since its launch two years ago. It functions as a desktop machine but with easy access to peripheral hardware, such as buttons, sensors and LEDs, via its GPIO pins. Using a Java IDE like Eclipse or NetBeans is out of the question as the Pi is not powerful enough to run those. However, the beginners' Java IDE BlueJ is ideal in this situation: lightweight enough to run on the Pi, but well-featured and designed for education. This demo will show how BlueJ's features such as the object bench allow easy exploration and manipulation of the Pi's GPIO pins, and how easy it can be to write some Java to interact with peripherals connected to the Pi. More information on BlueJ and the Raspberry Pi is available at http://bluej.org/raspberrypi/

Educators often form opinions on which programming mistakes novices make most often - for example, in Java: "they always confuse equality with assignment", or "they always call methods with the wrong types". These opinions are generally based solely on personal experience. We report a study to determine if programming educators form a consensus about which Java programming mistakes are the most common. We used the Blackbox data set to check whether the educators' opinions matched data from over 100,000 students - and checked whether this agreement was mediated by educators' experience. We found that educators formed only a weak consensus about which mistakes are most frequent, that their rankings bore only a moderate correspondence to the students in the Blackbox data, and that educators' experience had no effect on this level of agreement. These results raise questions about claims educators make regarding which errors students are most likely to commit.

The Blackbox project, launched in 2013, collects large amounts of data about beginner student behaviour in the BlueJ IDE. In this this workshop, we will introduce researchers to the Blackbox data and show them how to get started with analyzing it to answer their own research question(s). The workshop provides an ideal opportunity to find out what can be done with the Blackbox data, and will be run by the system's architect and maintainer. The data set includes Java source code as well as information about compilations, debugger usage and other compiler interactions. The Blackbox project has over 150,000 users, over 10,000,000 compilations and tens of gigabytes of source code. (For more detailed information, see the paper "Blackbox: A Large Scale Repository of Novice Programmers' Activity" by Brown et al. in the SIGCSE 2014 proceedings.) Computing education researchers may apply for free, permanent access to the data, but is not necessary to do so before this workshop. The session will be hands-on, and participants should bring a laptop that is capable of running an SSH terminal (e.g. Mac OS X, Linux, or PuTTY on Windows) over a wireless connection.

Automatically observing and recording the programming behaviour of novices is an established computing education research technique. However, prior studies have been conducted at a single institution on a small or medium scale, without the possibility of data re-use. Now, the widespread availability of always-on Internet access allows for data collection at a much larger, global scale. In this paper we report on the Blackbox project, begun in June 2013. Blackbox is a perpetual data collection project that collects data from worldwide users of the BlueJ IDE -- a programming environment designed for novice programmers. Over one hundred thousand users have already opted-in to Blackbox. The collected data is anonymous and is available to other researchers for use in their own studies, thus benefitting the larger research community. In this paper, we describe the data available via Blackbox, show some examples of analyses that can be performed using the collected data, and discuss some of the analysis challenges that lie ahead.

Computer science in UK schools is undergoing a remarkable transformation. While the changes are not consistent across each of the four devolved nations of the UK (England, Scotland, Wales and Northern Ireland), there are developments in each that are moving the subject to become mandatory for all pupils from age 5 onwards. In this article, we detail how computer science declined in the UK, and the developments that led to its revitalisation: a mixture of industry and interest group lobbying, with a particular focus on the value of the subject to all school pupils, not just those who would study it at degree level. This rapid growth in the subject is not without issues, however: there remain significant forthcoming challenges with its delivery, especially surrounding the issue of training sufficient numbers of teachers. We describe a national network of teaching excellence which is being set up to combat this problem, and look at the other challenges that lie ahead.

Computer science educators, especially those in schools, often work in small departments which allow little support or sharing. This problem can be alleviated via virtual online communities that allow educators to support each other and share knowledge and teaching materials. Virtual communities experience varying levels of success or failure, and it is often not easy to determine the causes for these differences. Factors include social and technical aspects, and it is typically not trivial to attribute community behaviour clearly to one or the other. In this paper we describe the "ColourRoom" software, a web-based platform to support virtual communities of educators. This software has been deployed to three distinct communities -- educators using BlueJ, educators using Greenfoot, and UK computer science school teachers (regardless of software) -- which affords a rare opportunity to analyse the usage of the same software in different communities, providing insights into both the communities and the design of software to support them.

Computer science in UK schools is a subject in decline: the ratio of Computing to Maths A-Level students (i.e. ages 16--18) has fallen from 1:2 in 2003 to 1:20 in 2011 and in 2012. In 2011 and again in 2012, the ratio for female students was 1:100, with less than 300 female students taking Computing A-Level in the whole of the UK each year. Similar problems have been observed in the USA and other countries, despite the increased need for computer science skills caused by IT growth in industry and society. In the UK, the Computing At School (CAS) group was formed to try to improve the state of computer science in schools. Using a combination of grassroots teacher activities and policy lobbying at a national level, CAS has been able to rapidly gain traction in the fight for computer science in schools. We examine the reasons for this success, the challenges and dangers that lie ahead, and suggest how the experience of CAS in the UK can benefit other similar organisations, such as the CSTA in the USA.

Many investigations of students' initial learning of programming are based on small-scale studies of their interactions with a learning environment. Although this research has led to significant improvements in the understanding of student behaviour (and tool support), it has often been restricted to small numbers of students at single institutions. This paper describes an initiative to instrument the widely-used BlueJ environment to collect data on a much larger scale, and make that data available to Computing Education researchers. The availability of this data has the potential to enable research not previously possible. This paper discusses the type of data that will be gathered, the restrictions placed on identifying students, and mechanisms for associating the data with contextual data gathered outside the scope of the initiative.

The Microsoft Kinect is a sensor module that allows accurate tracking of humans moving in front of it. Greenfoot is an introductory Java programming environment that makes it easy to create animated graphical projects. By combining Greenfoot and the Kinect students can write programs where the user's body is used for input. Users interact with games by waving their hands, jumping, running, dancing, .... These kinds of programs are incredibly good fun and engage target groups who would not normally be interested in programming. The workshop is aimed at teachers of introductory programming courses (high school/university) who have some programming experience and want to incorporate new kinds of projects into their teaching. Laptop recommended but not required. Kinect hardware will be provided.

Teaching material can be time-consuming and difficult to develop, even for those with experience. Teaching repositories permit the sharing of material and can thus potentially save time and enable re-use of good material. Many teaching repositories have been created for this reason, but they often see limited use and we believe there is a missed opportunity to learn lessons and improve the design of repositories accordingly. This paper reports an investigation of the use of the "Nifty Assignments" repository, in an attempt to discern reasons for the success and failure of teaching repositories to enable effective sharing. We go on to discuss the design of a new online community, the Greenroom, for teachers using the Greenfoot environment. The Greenroom attempts to focus on personal interactions and collaborative development of resources in order to increase engagement and sharing, rather than the traditional download-upload models of other repositories. The comparison and contrast of these two approaches reveal interesting insights about techniques which can contribute to the success of repositories

Developing and sharing teaching material is a significant challenge for users and developers of novel teaching tools and techniques. The Greenroom is a community web site for teachers using the Greenfoot software that provides a novel design to overcome various problems associated with sharing resources and supporting teachers. The Greenroom is of immediate interest for Greenfoot teachers, but also for designers of similar teacher community sites.

Abstract Communicating Sequential Processes for Java (JCSP) is a mature library that implements CSP‐derived concurrency primitives in Java. A JCSP system is a hierarchical network of autonomous processes communicating over synchronous (optionally buffered) channels, and multiway synchronising through barriers. This paper presents a significant extension to the barrier mechanism: the fast resolution of choice between any number of barrier events, channel communications (in either direction) and timeouts. Previously, and in line with all currently released libraries and languages offering the CSP concurrency model, choice was restricted to channel inputs and timeouts. The paper demonstrates an application of alting barriers and explains the mechanisms used in their implementation that enables their use as guards in a choice. It also shows how choice over channel outputs becomes possible, as a simple consequence of having choice over barriers. Finally, an efficient implementation of CSP's broadcasting channels is presented (using a phased barrier synchronisation pattern) and a mechanism for allowing choice over these is discussed. With this extended JCSP, almost all CSP‐specified systems can now be directly implemented. The new library is available under LGPL open source. Copyright © 2010 PH Welch, NCC Brown, J Moores, KV Chalmers & B Sputh.

Data-type generic programming can be used to traverse and manipulate specific parts of large heterogeneously-typed tree structures, without the need for tedious boilerplate. Generic programming is often approached from a theoretical perspective, where the emphasis lies on the power of the representation rather than on efficiency. We describe use cases for a generic system derived from our work on a nanopass compiler, where efficiency is a real concern, and detail a new generics approach (Alloy) that we have developed in Haskell to allow our compiler passes to traverse the abstract syntax tree quickly. We benchmark our approach against several other Haskell generics approaches and statistically analyse the results, finding that Alloy is fastest on heterogeneously-typed trees.