Educational Programming Languages and Systems
( 24. Jul – 29. Jul, 2022 )
- Neil Brown (King's College London, GB)
- Mark J. Guzdial (University of Michigan - Ann Arbor, US)
- Shriram Krishnamurthi (Brown University - Providence, US)
- Jens Mönig (SAP SE - Walldorf, DE)
- Marsha Kleinbauer (für wissenschaftliche Fragen)
- Susanne Bach-Bernhard (für administrative Fragen)
- Dagstuhl Materials Page (Use personal credentials as created in DOOR to log in)
To the world at large, programming is one of the most visible and valuable aspects of computing. Yet learning to program has been well documented as challenging and a barrier to entry. The way that a computer interprets a program literally and the complex interdependencies within programs are surprising to novices, who have a rather limited understanding of things that can go wrong in programs and what can be done to protect against these problems.
Thinking about computing (and specifically programming) education is particularly timely for several reasons:
- Numerous countries, states, and other geographic entities are making a big push to put computing into curricula for all students.
- Computing tools are now making a serious dent into several disciplines, not just traditional sciences (like physics and biology) but also in social sciences (like history and sociology). New hybrid areas like bioinformatics and data science are being created. People in numerous disciplines now would benefit from, and in some cases need to, learn how to program.
- People outside traditional academic structures are being given the power to program. Everything from spreadsheets to home automation systems are providing "scripting" interfaces that people can use to simplify or enrich their lives. At the same time, those who do not adapt to these trends risk being left behind in their jobs.
In response to the challenges that programmers face, computer scientists have created numerous programming languages and systems, such as interactive development environments (IDEs). To a professional, the more the tools, usually, the better. Tools that can compute advanced analyses, whose meaning may take a great deal of training to understand (as just one example, a worst-case execution time analysis to aid in building a real-time system, or a dependent type system that can statically analyze rich program invariants) can be well worth the investment.
Beginners, however, have a very different set of concerns. For instance:
- Basic matters of syntax can be problematic. Beginners can struggle with the notion that the computer requires very precise utterances (something they have not had to deal with before in writing, math, and other disciplines, where a human reader is usually able to deal with ambiguity, and is forgiving). They may also struggle with basic tasks like typing.
- Graduated Introduction
- A typical textbook will introduce concepts slowly and gradually: each chapter, for instance, might introduce one new concept. Our tools, however, do not typically offer this same graduation. Instead, a student put in front of (say) a Java IDE must confront all of Java: a typo could result in an indecipherable error, strange behavior, and so on. This can result in a very confusing, and unfriendly, learning environment.
- Computing is relatively unique in confronting learners with a large number of errors. But errors are intimidating to beginners (many of whom worry that they can ``break the computer''), and can at any rate be a deflating experience. At the same time, errors can be viewed as a learning opportunity. How do we design errors -- and more broadly, system feedback -- in such a way that it is constructive, comprehensible, and encouraging?
- Computing has traditionally had a rather shameful relationship with users who have special needs. For example, the number of blind professional developers is negligible, and in not at all representative of the percentage of blind people in the population. However, spending a few minutes with our programming tools will make clear why this is not surprising at all: so much is oriented towards visual inspection and manipulation. Similarly, our tools are rarely tested against, for instance, the needs and capabilities of learners with cognitive impairments. While it may take a long time before the entire computing ``pipeline'' can adjust to such needs, we can still start to make progress in this direction. Furthermore, the community of beginners who do not need much computing sophistication can immediately benefit from advances in this area.
Our seminar was successful in bringing together attendees with expertise in computing education, programming language design, and human-computer interaction. The presentation and discussions explored a wide range of issues, from language and environment design, to teaching methods and assessment issues. In particular, we studied and discussed:
- Tools and Languages
- A wide variety of tools and languages were presented - from block-based to textual, from imperative to functional, to those embedded in games, and to those explicitly designed for programmer's whose native language is not English. Some of the tools were explicitly for learning and teaching of programming, like tutors and ebooks. We discussed tools for understanding program execution, such as debuggers.
- Many of the attendees are exploring block-oriented programming in some way, so we had several sessions focused on novel uses of block-based programming and applying the blocks modality in different kinds of programming languages and paradigms.
- Increasingly, we recognize that learning programming is not just about the language and the IDE, but also about data - what data students use and how data are described and structured. Data can be motivating for students. Carefully selected data sets can play an important role in supporting learning in contexts outside of computing, e.g., about social issues or about scientific phenomena). Data can be complex and messy, which can take more time to explain and "clean."
- Learning Issues
- Our discussion included the cognitive issues when learning programming and the challenges in helping students to transfer knowledge to new contexts. We discussed the strategies to be taught to students to help them succeed at reading, writing, and debugging programs. We saw teaching techniques that are unique to programming, like Parsons problems. We particularly focused on the cognitive tasks of planning and identifying goals, which are critical to student success in programming. We discussed learning trajectories that explain how we might expect student learning to occur.
- Computer science has been called the study of algorithmic processes, and computer science education research needs to also be concerned with students learning computational processes in the context of other processes. Some of the processes we discussed include learning processes (i.e., what has to happen to make sure that learning is successful and is retained and possibly transferred), classroom processes (i.e., how does programming fit into the classroom context, including how work is evaluated), and student programming processes (i.e., students are learning design, development, and debugging processes, and need scaffolding to help them succeed and develop their processes to be more expert-like).
- Practical Issues of Sustainability
- Building software has always been difficult to fit into most national research infrastructures. Funding agencies are often reticent to pay for software development, let alone maintenance. Maintaining software over time is expensive but is critical to test educational hypotheses in ecologically-valid contexts (i.e., classrooms vs laboratories) and to gain the benefits of novel software implementations in education. A key area of maintenance of educational software is the fit between the curriculum, the teacher, the school context, and the software. Software may need to change as teaching goals and teachers change, which is a new and complex area for software maintenance.
Programming languages and environments designed for educating beginners should be very different from those designed for professionals. Languages and environments for professionals are usually packed with complex powerful features, with a focus on productivity and flexibility. In contrast, those designed for beginners have quite different aims: to reduce complexity, surprise, and frustration.
Designing such languages and environments requires a mix of skills. Obviously, some knowledge of programming language issues (semantics and implementation) is essential. But the designer must also take into account human-factors aspects (in the syntax, development environment, error messages, and more), cognitive aspects (in picking features, reducing cognitive load, and staging learning), and educational aspects (making the language match the pedagogy). In short, the design process is a broad and interdisciplinary problem.
In this Dagstuhl Seminar we aim to bring together attendees with a wide variety of expertise in computer education, programming language design and human-computer interaction. Because of the diverse skills and experiences needed to create effective solutions, we believe that we will all be able to learn from each other about the challenges – and some of the solutions – that each discipline can provide.
Our aim is that attendees can come and tell others about their work and the interesting challenges that they face – and solutions that they have come up with. We hope to distill lessons from the differing experiences of the attendees, and record the challenges that we jointly face. The seminar will allow attendees to share details of their work with each other, followed by discussions, and finally some plenary sessions to summarize and record this shared knowledge.
- Kenichi Asai (Ochanomizu University - Tokyo, JP) [dblp]
- Michael Ball (University of California - Berkeley, US)
- Neil Brown (King's College London, GB) [dblp]
- Youyou Cong (Tokyo Institute of Technology, JP) [dblp]
- Barbara Ericson (University of Michigan - Ann Arbor, US) [dblp]
- Kathi Fisler (Brown University - Providence, US) [dblp]
- Diana Franklin (University of Chicago, US) [dblp]
- Elena Leah Glassman (Harvard University - Allston, US) [dblp]
- Mark J. Guzdial (University of Michigan - Ann Arbor, US) [dblp]
- Bastiaan Heeren (Open University - Heerlen, NL) [dblp]
- Felienne Hermans (Leiden University, NL) [dblp]
- Jadga Hügle (SAP SE - Walldorf, DE)
- Johan Jeuring (Utrecht University, NL) [dblp]
- Amy Ko (University of Washington - Seattle, US) [dblp]
- Tobias Kohn (Utrecht University, NL)
- Shriram Krishnamurthi (Brown University - Providence, US) [dblp]
- Michael J. Lee (NJIT - Newark, US) [dblp]
- Eva Marinus (Pädagogische Hochschule Schwyz, CH) [dblp]
- Jens Mönig (SAP SE - Walldorf, DE) [dblp]
- R. Benjamin Shapiro (University of Colorado - Boulder, US) [dblp]
- Janet Siegmund (TU Chemnitz, DE) [dblp]
- Ethel Tshukudu (University of Botswana - Gaborone, BW)
- Computers and Society
- Human-Computer Interaction
- Programming Languages
- programming environments
- learning progressions
- computer science education research