Parallelism and concurrency are important topics that, according to ACM guidelines, should be part of every undergraduate computer science education. At Grinnell College, these concepts are covered in CSC 213, the operating systems course. In this course, students complete a series of four labs on concurrency to learn the basics of threads and data-parallel computation, how to deal with concurrency errors, and how to write efficient, scalable parallel code. This paper describes these labs and our experience using them for three sections of CSC 213.
Microsoft MakeCode (https://www.makecode.com) is a platform and accompanying web app for simplifying the programming of microcontroller-based devices in the classroom. For each device, MakeCode provides a customized end-to-end experience in the web browser consisting of code editors, device simulator, debugger, compiler to machine code, and linker to a pre-compiled C++ runtime, as well as a documentation and tutorial system. We present an overview of MakeCode and detail the major design decisions behind the platform.
Students learning to program often need help completing assignments and understanding why their code does not work as they expect it to. One common place where they seek such help is at teaching assistant office hours. We found that teaching assistants in introductory programming (CS1) courses frequently answer some variant of the question ``Am I on the Right Track?''. The goal of this work is to develop an automated tool that provides similar feedback for students in real-time from within an IDE as they are writing their program. Existing automated tools lack the generality that we seek, often assuming a single approach to a problem, using hand-coded error models, or applying sample fixes from other students. In this paper, we explore the use of program synthesis to provide less constrained automated answers to ``Am I on the Right Track'' (AIORT) questions. We describe an observational study of TA-student interactions that supports targeting AIORT questions, as well as the development of and design considerations behind a prototype integrated development environment (IDE). The IDE uses an existing program synthesis engine to determine if a student is on the right track and we present pilot user studies of its use.
We examine whether augmenting traditional coding environments with ProDirect manipulation improves several learning measures. ProDirect manipulation is a novel user interaction model that provides a bidirectional link between code and outputs. Instead of reasoning abstractly about the output a program might produce, users instead directly manipulate outputs (e.g., using a keyboard and mouse). Program text is then updated to reflect the change.
We report the effects on learning using a ProDirect manipulation environment versus a standard development environment for more than one hundred middle school students. To conduct the study, we built SWELL, a programming language with ProDirect manipulation features. We conclude that within the context of an Hour-of-Code course, ProDirect manipulation does not offer a significant advantage. We also make several observations regarding the way students interact with SWELL, which may inform future language design for this age group.
Understanding how students' prior knowledge affects their learning of new concepts is essential for effective teaching. The same learning activity, or the same explanation, may have very different effects on students with different prior knowledge.
In the context of teaching programming, prior knowledge includes the programming languages students studied in prior courses. In this experience report we describe our observations in teaching object-oriented programming in Java to students who previously learned functional programming in Racket's student languages. We highlight four concrete problems we encountered in teaching the second course in this sequence. We detected and addressed these problems primarily thanks to a teaching assistant who assisted in both of the courses.
This experience made us realize the importance of explicitly bridging between languages in introductory programming course sequences. It also showed that the sharing of teaching staff across courses can be an effective way to detect aspects that need bridging.
ChocoPy is a programming language designed for teaching an undergraduate course on programming languages and compilers. ChocoPy is a restricted subset of Python 3.6, using static type annotations to enforce compile-time type safety. ChocoPy is fully specified using formal grammar, typing rules, and operational semantics. Valid ChocoPy programs can be executed in a standard Python interpreter, producing results consistent with ChocoPy semantics. A major component of CS164 at UC Berkeley is the project: students develop a full compiler for ChocoPy, targeting RISC-V, in about twelve weeks. In other exercises, students extend the syntax, type system, and formal semantics to support additional features of Python. In this paper, we outline (1) the motivations for creating the ChocoPy project, (2) salient features of the language, (3) the resources provided to students to develop their compiler, (4) some insights gained from teaching two semesters of ChocoPy-based courses by different instructors. Our assignment resources are available for re-use by other instructors and institutions.
Program state visualizations (PSVs) help programmers understand hidden program state like objects, references, and closures. Unfortunately, existing PSV tools do not support custom language semantics, which educators often use to introduce programming languages gradually. They also fail to visualize key pieces of program state, which can lead to incorrect and confusing visualizations.
Theia, a generic PSV framework, uses formal abstract machine definitions to produce complete, continuous, and consistent (CCC) PSVs.
To produce CCC visualizations with Theia, an educator only needs to specify an abstract machine and optionally customize the resulting web page, allowing her to visualize custom language semantics without developing a language-specific tool.
λ calculus is a great formal introduction to functional programming. However, its abstract nature poses a challenge for many students as they struggle both with the unfamiliarity of functional programming and with the high abstraction and minimalism of λ calculus. As a result, functional programming classes are often delayed to older students who are hoped to be better prepared for appreciating its qualities, as was the case at the authors’ university as well. 3 years ago, as part of a redesigned curriculum around programming languages education, we have decided to introduce students to various programming paradigms much sooner than before. In doing so, we faced the problem of explaining very theoretical foundational concepts to very young students in a very short time. We have monitored the achievements and shortcomings of the new course over the past years and as a result of our findings have developed Lambdulus, an interactive and visual evaluator of λ calculus expressions that encourages students to explore the mechanisms of λ calculus by treating it not as a theoretical concept, but as a programming language in its own right.