SIGPLAN Workshop on Undergraduate Programming Language Curriculum

SIGPLAN Workshop on Undergraduate Programming Language Curriculum.

Programming languages play a critical role in computer science by providing a flexible and robust means by which human beings interact with and control computer systems. Programming language design and implementation has advanced significantly in the recent past in response to the increasing pervasiveness of computer science and technology. Unfortunately, higher-education curriculum has not kept pace, and so it does not appropriately reflect the expansive growth and evolution. This lag is a critical challenge because an up-to-date curriculum is essential to prepare a globally competitive workforce, able to generate and to apply new knowledge, and to take the lead in advancing computer science and technology.

The goal of this workshop is to bring together leaders in the field of programming languages with expertise in research, teaching, and industrial use to discuss the role of programming language design, implementation, and application in modern, undergraduate, computer science education. Our objective with this effort is to build a community for these experts to discuss, critically evaluate, and identify the transformational changes needed to best prepare undergraduates to participate in the rapidly changing field of computer science and technology.

In particular, this workshop should provide a forum for the community (1) to evaluate recent changes and likely trends in computing technology and their impact on programming language design, implementation, and application (and vice versa), (2) to discuss the implications of these changes on programming language curricula, and (3) to explore strategies for designing new curricula. For the first task, we will consider trends that include the looming ubiquity of multi-processing systems, the proliferation of domain-specific languages, the increasing diversity of relevant programming languages, infrastructures, and support tools, the growing heterogeneity of device architectures (high-performance computing systems, desktops, game consoles, mobile phones, hand-held devices, etc.), and the increasing complexity of systems (operating, runtime, and application-level). For the second task, we will consider how these trends impact what and how we should be teaching our undergraduates about programming languages. Finally, for the third task, we will explore various tactics for designing new programming language curricula that incorporate the insights from these discussions and yet fit within the constraints of existing undergraduate programs.

We only rarely post links to conference or workshop announcements, but this seems like something worth calling out particular attention to. Many universities use ACM curriculum recommendations to structure their undergraduate programs, so it's very important to make sure that the programming languages recommendations are in good shape.

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

Fundamental distinction

One of the items buried in the list of topics for discussion is discussion of the relationship between programming and programming language instruction. I think this is one of the problematic aspect of the ACM recommendations in this area. The premise of this work should be a distinction between teaching a programming language, and teaching about programming languages. The two should be made distinct as far as curricula are concerned, and the recommendations should stick to the latter, rather than the former.

Just my two cents, as they say...

What about implementation?

When you say: "teaching about programming languages" I think you include implementation although it's not explicitly stated. I personally am all for an implementation course as opposed to a language survey course. In my undergraduate program we were taught from a previous edition of this book:

And my oh my, what a depressing experience that was. One day in class a student asked the instructor "but how is machine code created from the AST?" The instructor had no answer.

I am also no fan of survey

I am also no fan of survey courses. But it is important to distinguish implementation (in the two sense of (1) compiler construction and (2) machine code generation) from the interpreter based, "essentials", approach. The latter is, I think, recognized by most to be the best practice for teaching PL concepts to CS students (and the best gateway to PLT). Implementation, in the former sense, is useful an important, and provides marketable skills, but from a PL educational perspective is of lesser importance, I think (as opposed to being important in its own right for well rounded CS education).

The PL educational

The PL educational perspective is crucial in developing a well-rounded programmer, and many employers value this skill above compiler implementation.

Survey courses are a viable way of learning PL, and provide different benefits from the interpreter-based approach. Survey courses allow students to use a language paradigm in a supporting ecosystem, including IDEs and libraries. Compare learning OO through Visual Age smalltalk with its rich IDE and library that really buys into OO versus implementing Scheme OO extensions in an ecosystem that doesn't really support OO programming. The former really allows you to play around with and understand how to use OO, while the former is mostly for understanding the mechanics behind OO.

Both approaches are valuable, but unfortunately are often not taught together. Many professors just assumes that either approach is better and subsumes the other, and of course there often isn't time to both survey and go into PL details.