Daniel Patterson

PLMW @ ICFP/SPLASH 2025 - ICFP/SPLASH 2025 The SPLASH-ICFP Programming Languages Mentoring Workshop encourages graduate students (PhD and MSc) and senior undergraduate students to pursue research in programming languages. This workshop will pr...

PLMW is calling for student applications -- if you are a student interested in ICFP/SPLASH 2025, consider applying!

Deadline: July 15, AoE

conf.researchr.org/home/icfp-sp...

Bleak state of peer review (a minor thing, in the grand scheme of things, but anyway) -- getting a message saying "please don't use AI tools to write your reviews".

Innocent

Probably your PL students won’t have this problem, but I remember doing a similar thing at the end of our accel intro class (simple interpreter, compiler, type checker) and sums ended up being way more challenging to students than we (ignorant PL people we are) thought they would be.

Sorry, what’s tricky? Is the issue you want to be able to write interesting programs? If it’s supposed to be “little”, just add sums and products to STLC? But maybe that’s too simple?

Trying to describe it all here is impossible (but those of us designing the courses will be releasing lots very soon), but -- 1. it's not about following trends; 2. I'm deeply committed to design orientation (it's why I'm teaching & why I'm teaching _here_), and don't see this as a departure.

The reply is also something that drives me crazy. Yes, oil majors (and other corporations) are responsible for most emissions. They are responsible for much of the economy! Which you are part of! Organize to make systemic change (duh), but also... realize systemic change involves whole systems!

I guess I'd argue that code should be written primarily to be read & secondarily to work! (so the analogy isn't perfect, but isn't horrible?) And what seems odd is: the largest artifacts students see (in our courses) are their own! And we could give them similarly sized ones that are well designed!

Sure, either of those!

The analogy (if I can continue it), would be if writing classes showed great examples of sentences, but no great essays, or books. Maybe its too hard for students, but... is it?

Thanks! Peer review (even when done _pervasively_, like CaptainTeach), while related, is slightly different than what I was wondering about. e.g., in (English) writing class, you read examples of much better writing than you are currently capable of! We often show little examples, but not big ones.

Here’s a question: if we believe reading code is as important as writing code (we do), why isn’t it a much more explicit part of our introductory classes? Students read examples, but not whole projects, and writing about / critiquing code is not typically an _explicit_ task. Unless others do this?

Among many interesting parts are how/what these brilliant writers learned in order to teach. All were involved in the same remedial writing program, and so, e.g., Lorde talking of grammar to her students: "Guess what I found out last night. Tenses are a way of ordering the chaos around time."

Picture of book Open Admissions by Danica Savonick

Rich was the first to admit that City College catalyzed "a profound change in [her] conception of teaching and learning." On first arriving, she had hoped to discover an unlikely Shakespeare buried among mediocre students, whose gifts she could help cultivate. But immersed in the SEEK community, she came to see "compensatory" (or "remedial") education as part of a broader "movement for social change," the goal of which was to "break down false barriers of class & color to make all education truly open to all people who want it?" There, she realized that the "veins of possibility" run through all students and that the political potential of teaching lies not necessarily in mentoring a select handful of highly skilled individuals but in developing teaching strategies that would benefit all, regardless of their previous academic training, ability, or interest.

Winter break reading—wonderful book about a brief period when CUNY opened up to all NYC high school graduates (made it free, had explicit programs for people without strong backgrounds, etc), told through the teaching of four incredibly influential writers who all overlapped at City College.

I’d honestly love to try (something in this space). Not quite sure how I’d be able to spin it though. Hard to offer an introductory elective. Maybe an alternate to one of the intros for non majors (which are dead ends in terms of dependencies, so lower stakes)

Hmm. Thats an interesting idea. I feel like for the _beginning_ (ie only writing types, purposes, tests), you need the speed of automation. But for the latter parts, where you are actually reading & discussing code, having (carefully constructed, by hand) implementations should work — and be better!

I agree with you to the extent that “taught themselves with an LLM” means using tools intended for people who know how to code (or to prevent them from needing to). But I wonder if we are still thinking too small (not sure if the ideas of my thread are useful, but they are _not_ just Copilot)

Addendum: Obviously, there are also significant issues with the tools -- energy use, concerns about where the data comes from, etc -- but they exist, and students are using them, so to me I'd rather foreground them and discuss these issues, alongside the tools themselves.

I'm not sure if this would be a good idea at all... but I'm also not sure if it makes sense to continue as we are, designing courses / learning as if these tools don't exist (or considering them as an after thought), when we know many/most students will use them.

We could ask the models for different implementations, and study the differences -- compare and contrast, discuss which we liked better, and why (develop taste early!) After learning to read & discuss code, we then learn to write it -- mimicking styles that we've seen. CS as writing class!

Later, we could start to look at the code that was generated -- reading code that worked, and code that didn't work, and discussing the difference. LLMs could be used to help explain how the code worked, but students would also be tasked with explaining the code. CS as English class!

One of the challenges in teaching the design recipe (htdp.org) is getting people to actually focus on those first three steps (signature, purpose, examples/tests), rather than just diving into code and getting themselves lost in the muck. Powerful synthesis might allow students to really get that.

This process could continue with more sophisticated data, and we could explore problem decomposition, challenges in data representation, etc -- all before thinking about _code_ at all.

i.e., start building programs by _only_: describing input / output data for problems, describing clearly how the input should be transformed to the output, and writing examples of how it should work. The code that is generated can then be validated, by hand or automatically, against those examples.

But back to the thought experiment. If we did want to do this, rather than just adding Copilot (which effectively thinks for students, nvm relying no them to have a sophisticated understanding of code to identify problems!), what if we used synthesis to alter the order in which we approach material.

CS1-LLM: Integrating LLMs into CS1 Instruction | Proceedings of the 2024 on Innovation and Technology in Computer Science Education V. 1

Their results aren't bad (dl.acm.org/doi/10.1145/...), but I'm still pretty skeptical of this approach -- and whether it gives students the foundation to move on, etc. Learning happens when students are challenged (within reason!) and I'm skeptical if this sufficiently challenges them.

GitHub - copilotbook/CS1-LLM: Courseware for CS1 courses that incorporate LLMs Courseware for CS1 courses that incorporate LLMs. Contribute to copilotbook/CS1-LLM development by creating an account on GitHub.

e.g., experiments like github.com/copilotbook/... don't sit quite right with me -- giving copilot to beginners and saying lets not worry about the low-level details of programming.

Thought experiment: what if we _did_ teach intro CS with LLMs from the very beginning? Conventional wisdom is that this is a bad idea (students need to learn fundamentals, and LLMs can stand in for this), but I wonder if this is because we are thinking about it wrong.

Identifying errors is a nice use, since they can usually be validated and we’re used to incomplete analyses. We did this last semester identifying first step (if any) in design recipe with issues (given function or data); it worked remarkably well (working on writing up little experience report now)