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.

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.

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.

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.

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.

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.

This panel explores experiences and insights from three successful propagators into how others can successfully encourage more wide-spread use of their innovations. Issues covered include designing for dissemination, techniques for recruiting potential adopters, suggestions for convincing faculty to try an innovation and continue using it, and identifying points of friction and overcoming resistance from administrators, students, and/or peers. These topics are discussed and illustrated with personal experiences and anecdotes from our illustrious panelists.

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 types of programming errors that novice programmers make and struggle to resolve have long been of interest to researchers. Various past studies have analyzed the frequency of compiler diagnostic messages. This information, however, does not have a direct correlation to the types of errors students make, due to the inaccuracy and imprecision of diagnostic messages. Furthermore, few attempts have been made to determine the severity of different kinds of errors in terms other than frequency of occurrence. Previously, we developed a method for meaningful categorization of errors, and produced a frequency distribution of these error categories; in this article, we extend the previous method to also make a determination of error difficulty, in order to give a better measurement of the overall severity of different kinds of errors. An error category hierarchy was developed and validated, and errors in snapshots of students source code were categorized accordingly. The result is a frequency table of logical error categories rather than diagnostic messages. Resolution time for each of the analyzed errors was calculated, and the average resolution time for each category of error was determined; this defines an error difficulty score. The combination of frequency and difficulty allow us to identify the types of error that are most problematic for novice programmers. The results show that ranking errors by severity—a product of frequency and difficulty—yields a significantly different ordering than ranking them by frequency alone, indicating that error frequency by itself may not be a suitable indicator for which errors are actually the most problematic for students.

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.

Teach students how to program is the main goal of most introductory CS courses. In fact, programming is one of the basic skills a professional in CS should have. However, there are many difficulties students face when they are learning how to program and, consequently, it is common introductory programming courses have high dropout rates. The purpose of this paper is to identify and discuss the most common fixes students use to improve the correctness of their programs. The findings can be useful to help students to produce more correct programs and highlight issues about possible difficulties they are having. To do so, we used the BLACKBOX data collection, which stores the actions of the BLUEJ programming environment users. The main idea was to observe the modifications students did in their source codes that made a failed JUNIT test case become succeeded. The results suggest the majority of fixes students use in their source codes are related either to the change of expressions or to the restructuring of code, reflecting difficulties in logic and problem solving among students.

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.

Summary form only given. Early programming education is undergoing substantial change: Once a discipline taught primarily at university level, most learners now encounter computer science and especially programming long before leaving school. At the beginning, attempts dominated using existing tools for teaching and learning at younger age groups. In the last few years, this has been replaced by widespread use of programming tools custom designed for young learners both for organised teaching and for self study. In this talk, I will discuss this development, what it means for our teaching and for tool development, and present thoughts, ideas and predictions about the future of educational programming tools. Influences on general (professional) development environments are also discussed.

The past few years has seen a proliferation of novice programming tools. The availability of a large number of systems has made it difficult for many users to choose among them. Even for education researchers, comparing the relative quality of these tools, or judging their respective suitability for a given context, is hard in many instances. For designers of such systems, assessing the respective quality of competing design decisions can be equally difficult. Heuristic evaluation provides a practical method of assessing the quality of alternatives in these situations and of identifying potential problems with existing systems for a given target group or context. Existing sets of heuristics, however, are not specific to the domain of novice programming and thus do not evaluate all aspects of interest to us in this specialised application domain. In this article, we propose a set of heuristics to be used in heuristic evaluations of novice programming systems. These heuristics have the potential to allow a useful assessment of the quality of a given system with lower cost than full formal user studies and greater precision than the use of existing sets of heuristics. The heuristics are described and discussed in detail. We present an evaluation of the effectiveness of the heuristics that suggests that the new set of heuristics provides additional useful information to designers not obtained with existing heuristics sets.

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/

The frequency of different kinds of error made by students learning to write computer programs has long been of interest to researchers and educators. In the past, various studies investigated this topic, usually by recording and analysing compiler error messages, and producing tables of relative frequencies of specific errors diagnostics produced by the compiler. In this paper, we improve on such prior studies by investigating actual logical errors in student code, as opposed to diagnostic messages produced by the compiler. The actual errors reported here are more precise, more detailed and more accurate than the diagnostic produced automatically. In order to present frequencies of actual errors, error categories were developed and validated, and student code captured at time of compilation failure was manually analysed by multiple researchers. The results show that error causes can be manually analysed by independent researchers with good reliability. The resulting table of error frequencies shows that prior work using diagnostic messages tended to group some distinct errors together in single categories, which can now be listed more accurately.

Comprehension of programming and programs is known to be a difficult task for many beginning students, with many computing courses showing significant drop out and failure rates. In this paper, we present a new notional machine design and implementation to help with understanding of programming and its dynamics for beginning learners. The notional machine offers an abstraction of the physical machine designed for comprehension and learning purposes. We introduce the notional machine and a graphical notation for its representation. We also present Novis, an implementation of a dynamic real-time visualiser of this notional machine, integrated into BlueJ.

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 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.

Tools to support and improve the learning and teaching of programming have been developed, used and researched for many years. Yet, sometimes it seems we are still faced with exactly the same problems we were trying to tackle a decade ago, or two decades ago.

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.

Many initiatives in improving learning of programming are based on gut instinct or localised experience. Gathering data as a basis for interventions, especially on a large scale, is hard. The BlueJ environment is being instrumented to collect data useful to a variety of educational programming researchers. BlueJ is ideally placed to collect such data: Users number in the millions, situated all over the world. This volume and diversity is unique in the history of such investigations and presents a significant opportunity for researchers. The data will be open to interested research groups, which will enable a wide variety of investigations that were previously impractical. This session presents work to date and solicits input from researchers about the design of the data collection.

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.

This panel will showcase and compare three leading Initial Learning Environments (ILE): Alice, Greenfoot and Scratch.

Greenfoot is an educational integrated development environment aimed at learning and teaching programming. It is aimed at a target audience of students from about 14 years old upwards, and is also suitable for college- and university-level education. Greenfoot combines graphical, interactive output with programming in Java, a standard, text-based object-oriented programming language. This article first describes Greenfoot and then goes on to discuss design goals and motivations, strengths and weaknesses of the system, and its relation to two environments with similar goals, Scratch and Alice.

This article distills a discussion about the goals, mechanisms, and effects of three environments which aim to support the acquisition and development of computing concepts (problem solving and programming) in pre-University and non-technical students: Alice, Greenfoot, and Scratch. The conversation started in a special session on the topic at the 2010 ACM SIGCSE Symposium on Computer Science Education and continued during the creation of the resulting Special Issue of the ACM Transactions on Computing Education.

This panel will showcase and compare three leading Initial Learning Environments (ILE): Alice, Greenfoot and Scratch.

Programming is recognized as one of seven grand challenges in computing education. Decades of research have shown that the major problems novices experience are composition-based---they may know what the individual programming language constructs are, but they do not know how to put them together. Despite this fact, textbooks, educational practice, and programming education research hardly address the issue of teaching the skills needed for systematic development of programs. We provide a conceptual framework for incremental program development, called Stepwise Improvement, which unifies best practice in modern software development such as test-driven development and refactoring with the prevailing perspective of programming methodology, stepwise refinement. The conceptual framework enables well-defined characterizations of incremental program development. We utilize the conceptual framework to derive a programming process, STREAM, designed specifically for novices. STREAM is a carefully down-scaled version of a full and rich agile software engineering process particularly suited for novices learning object-oriented programming. In using it we hope to achieve two things: to help novice programmers learn faster and better while at the same time laying the foundation for a more thorough treatment of more advanced aspects of software engineering. In this article, two examples demonstrate the application of STREAM. The STREAM process has been taught in the introductory programming courses at our universities for the past three years and the results are very encouraging. We report on a small, preliminary study evaluating the learning outcome of teaching STREAM. The study indicates a positive effect on the development of students’ process competences.

Learning to work in teams is essential for every software professional. Developing software as a team project is the standard practice in industry, and should be practiced in university courses. Starting effective group work practices early can lead to better acceptance of group work as a standard development mode.

Greenfoot is an educational IDE that makes it easy to write interactive graphical applications. It helps to solve several problems in the teaching and learning of object-oriented programming: It provides educational tools that aid in understanding fundamental object-oriented concepts, and it is highly motivational through instant graphical feedback.

No abstract available.

Is it possible to teach dynamic polymorphism early? What techniques could facilitate teaching it in Java. This panel will bring together people who have considered this question and attempted to implement it in various ways, some more completely than others. It will also give participants an opportunity to explore the topic and to share their own ideas.

While the introduction of object-oriented programming slowly moves down the age groups - starting from advanced university courses, to introductory courses, and now into high schools - many attempts are being made to make object-oriented programming introduction less abstract and theoretical. Visualisation and interaction techniques are being applied in an attempt to give students engaging and concrete experiences with objects. Recently, the greenfoot environment has been proposed as another step in this development. In this paper, we describe new functionality in the greenfoot environment, especially the addition of user interaction programming via direct state manipulation. Direct state manipulation provides very low overhead graphical I/O handling at a level that makes it feasible to guide students to simple graphical game programming within a few weeks, while concentrating on fundamental object-oriented concepts in the structure of the program.

The participants will use a debate format with a provocative thesis to explore the pedagogical approach known as "objects early" or "objects first." By arguing in the affirmative, Elliot Koffman and Stuart Reges will point out concerns that have been raised about the approach. By arguing in the negative, Kim Bruce and Michael Kölling will describe schools that are succeeding with the approach and ways to address significant concerns. Owen Astrachan as moderator will ensure that the debate remains civil and will provide some humorous and possibly even insightful commentary on the evidence presented by both sides.

Various software tools have been proposed or developed for use in introductory programming courses. Usually, presentation of a new tool at the SIGCSE symposium occurs when a tool is first developed, leaving it to interested observers to identify success or failure of tools over their lifetime.For teachers, it can be difficult to compare available tools and judge potential application in their courses.In this session, three tools with an established track record of successful classroom use are presented: Karel J Robot [1], objectdraw [2], and BlueJ [2]. In addition to considering each tool individually, opportunities for combinations of these tools are also discussed.The focus of this session will be on concrete, hands-on advice that teachers can immediately apply in their classrooms.

Various methods have been proposed in the past to improve student learning by introducing new styles of working with assignments. These include problem-based learning, use of case studies and apprenticeship. In most courses, however, these proposals have not resulted in a widespread significant change of teaching methods. Most institutions still use a traditional lecture/lab class approach with a strong separation of tasks between them. In part, this lack of change is a consequence of the lack of easily available and appropriate tools to support the introduction of new approaches into mainstream courses.In this paper, we consider and extend these ideas and propose an approach to teaching introductory programming in Java that integrates assignments and lectures, using elements of all three approaches mentioned above. In addition, we show how the BlueJ interactive programming environment [7] (a Java development environment aimed at education) can be used to provide the type of support that has hitherto hindered the widespread take-up of these approaches. We arrive at a teaching method that is motivating, effective and relatively easy to put into practice. Our discussion includes a concrete example of such an assignment, followed by a description of guidelines for the design of this style of teaching unit.

The environment chosen to teach Java can have a profound effect on students' abilities to learn the language. Panelists will report on their experiences using different Java Interactive Development Environments (IDEs) to teach Java and what they identify as the strengthens and weaknesses of each IDE. Each panelist will discuss the most important features of the IDEs and related teaching pedagogies to address "what works and what doesn't" when teaching Java.

The teaching of testing has never been easy. The introduction of object orientation into first year courses has made it even more difficult, since more and smaller units need to be tested more often. In professional contexts this is addressed by the use of testing support software. Unfortunately, no adequate software to support testing for introductory students is widely available, leaving teachers and students of first year courses struggling.In this paper we describe an attempt to address this problem by combining two existing systems that partly address our needs. We describe an integration of JUnit into BlueJ, which creates a testing tool that exhibits the flexibility and ease-of-use of the BlueJ system combined with the structured unit test approach provided by JUnit.

How to best teach object orientation to first year students is currently a topic of much debate. One of the tools suggested to aid in this task is BlueJ, an integrated development environment specifically designed for teaching. BlueJ supports a unique style of introduction of OO concepts. In this paper we discuss a set of problems with OO teaching, present some guidelines for better course design and show how BlueJ can be used to make significant improvements to introductory OO courses. We end by presenting a description of a possible project sequence using this teaching approach.

Object-oriented languages have been taught for some time at universities. The most common approach has been to teach those constructs required for imperative programming first and to introduce the notion of classes and objects somewhat later in the course. More recently, many educators have been promoting the notion of teaching about classes and objects first. This helps students to adopt the object-oriented paradigm at an early stage and encourages them to focus on the application structure before beginning coding. Most new textbooks have followed such an approach.

No abstract available.

One of the major diJ%xdties facing anyone trying to teach the first programming course is how to encourage students to thoroughly test their programs.We would argue that the main reasons for this are the lack of suitable tools for testing and the need to write extra "debug" code in order to verify correct operation.Wefurther argue that the problem is even worse with object-oriented languages because of multiple classes and encapsulation.In this paper we describe the testing tools within the Blue programming environment which allow object-oriented programs to be thoroughly tested without writing a single line of new code, ___---..

Over the last ten years there has been a major shift in programming language design from procedural languages to object-oriented languages. Most universities have adopted an object-oriented language for their first programming course. However, far less consideration has been given to the program development environment. In this paper we argue that the environment is possibly more important than the language and existing environments fail to fully support the object-oriented paradigm. We describe a new program development environment and show how it has been specifically designed to support object-oriented design and programming.

Teaching object-oriented programming has clearly become an important part of computer science education. We agree with many others that the best place to teach it is in the CS1 introductory course. Many problems with this have been reported in the literature. These mainly result from inadequate languages and environments. Blue is a new language and integrated programming environment, currently under development explicitly for object-oriented teaching. We expect clear advantages from the use of Blue for first year teaching compared to using other available languages. This paper describes the design principles on which the language was based and the most important aspects of the language itself.

Interest in teaching object-oriented programming in first year computer science courses has increased substantially over the last few years. While the theoretical advantages are clear, it is not obvious that the available object-oriented languages are suitable for this purpose. None of the existing languages is appropriate for teaching object-oriented principles. In this paper we discuss the requirements for an object-oriented teaching language and draw attention to the deficiencies of existing languages. In particular, the paper examines C++, Smalltalk, Eiffel and Sather. Finally we outline characteristics of a new language, specifically designed for teaching purposes.

: The objects accessible by a user at a particular time in an object-oriented system form a working environment. The invocation language via which this environment is viewed and manipulated can be regarded as semantically flexible since the set of operations available to the user is the union of the methods of all currently visible classes. In this paper we present a language system in which class definitions are extended to include appropriate syntax rules for the methods and which is consequently also syntactically flexible. The requirements for such a system both from the point of view of a user and with regard to an efficient implementation are discussed. An implementation of such a flexible invocation language within a persistent objectbased operating system is then presented. 1 1. Introduction An interactive language is a means of communication between a user and a software system. The first interactive languages were command languages. The software system involved was an ope...