---
title: "Educational Influencers"
author: "Geoffrey Challen"
date: "2026-11-12"
description: "Computing educators should be excited to spread the good news about natural language programming."
canonical: "https://www.geoffreychallen.com/essays/2026-11-12-educational-influencers"
---

# Educational Influencers

In the spring of 2000 I took my second computing course: CS 51 at Harvard.
It’s not as well-known as [CS 50](https://cs50.harvard.edu/), which I had taken the semester before and loved, mostly because I had found something I was good at[^1].
CS 51 was taught by [Henry Leitner](https://cs.harvard.edu/~leitner/)[^2], and it introduced us to several new programming languages, including Java and C++.

The one distinct memory I have of that class is writing a Java program, running it, and having it not crash.
Pretty much every C program I wrote in CS 50 crashed the first time I ran it.
That was just what you expected to happen.
My Java program didn’t solve the problem.
But it ran.
I remember thinking: maybe this is a little bit easier.
Maybe this lets me focus on what my program is trying to do.
Java didn’t require you to manage memory by hand, and memory was exactly what I kept getting wrong in C and C++.

In 2000, Java was a young language.
[JDK 1.0](https://en.wikipedia.org/wiki/Java_version_history) had been released in January 1996, only four years before.
Teaching it to hundreds of students in an early course was a bold move, one that would be considered radical today.
I know because I tried something similar.
When I introduced [Kotlin into my CS1 course in 2021](https://www.geoffreychallen.com/essays/2021-11-21-cs1-in-kotlin), Google had already [made it the preferred language for Android development](https://techcrunch.com/2019/05/07/kotlin-is-now-googles-preferred-language-for-android-app-development/).
I wanted to teach the course only in Kotlin, a language that represents a significant improvement over Java.
My department refused: ten years after its debut[^3], Kotlin was too new, unproven, too radical.
The compromise we’ve kept ever since is that we [teach the course in both Java and Kotlin](https://www.cs124.org/educators#one_course_two_languages).

As I understand the history of Java, educators played a role in its dissemination[^4].
Because people like Professor Leitner taught it, and others adopted it for their courses[^5], students graduated knowing that Java existed and what it was good for.
They brought that knowledge to work, and pushed for a language that let them solve problems faster by avoiding the pitfalls of the alternatives.

Today we’re seeing a new way of creating technology emerge with coding agents.
Educators have the same role to play in spreading it.
The big innovation in Java was that you didn’t have to manage memory.
Being able to create technology in natural language is an improvement on a completely different scale—a dream as old as computing coming true around us.

But I worry that in the 25 years since I took that course, the people teaching early computing courses have changed.
As I’ve [written before](https://www.geoffreychallen.com/essays/2026-03-05-teaching-and-doing), many of them don’t do computing.
They don’t write code, other than as a live demo in class.
They don’t build technology or maintain it.
So it’s hard for them to [appreciate what coding agents can do](https://www.geoffreychallen.com/essays/2026-11-05-taking-flaky-farther).

It strikes me as at least possible that one reason Professor Leitner taught Java in 2000 was that he used Java.
He had problems he was solving with it, he was excited that it worked better than what he’d used before, and he wanted to share that with us.
Today we’re living through a generational shift in how technology gets made.
But educators don’t seem excited.
That worries me.

I also hear concerns about how these tools might be used.
But those concerns have an educational response.
It used to take years of training to build even a simple app to solve a problem.
Now you can do it in a week by talking to a coding agent.
That is hugely exciting news, and our job is to share it, and to use it as a chance to teach people to use these tools responsibly.
The ability to build quickly creates more opportunities for students to use and reflect on the things they create, and for educators to guide them toward good solutions and away from harmful approaches.

The speed at which students can now build is a strong argument for teaching this technology early.
It belongs in our first computing courses, not later ones.
I’ll write more about that soon.

Educators have a lot of influence over what our students see and how these ideas are presented to them.
We don’t have to lead with ineffective ways of using the tools—like [checking their output by hand](https://www.geoffreychallen.com/essays/2026-11-05-taking-flaky-farther).
We don’t have to lead with fear about the future.
We can influence that future!
Professor Leitner shared the good news about Java in 2000.
Twenty-five years later, it’s our turn to share the good news about natural language programming.
If we teach our students these tools, and teach them to use them well, then in ten years we may see a much larger, more diverse, and more interesting community of people using technology to solve problems, answer questions, and make the world a better place.

And maybe, someday, someone will write about how exciting it was to learn coding agents in [CS 124](https://www.cs124.org) in 2026.

[^1]: This was well before the [Malan era](https://en.wikipedia.org/wiki/David_J._Malan): David Malan took over CS 50 in fall 2007.

[^2]: A Senior Lecturer on Computer Science at Harvard since 1986, who has [taught](https://cs.harvard.edu/~leitner/Teaching.html) CS 1, CS 50, and CS 51, among many others.

[^3]: JetBrains [unveiled](https://en.wikipedia.org/wiki/Kotlin_(programming_language)) Project Kotlin in July 2011 and [released Kotlin 1.0](https://blog.jetbrains.com/kotlin/2016/02/kotlin-1-0-released-pragmatic-language-for-jvm-and-android/) on February 15, 2016.

[^4]: Sun was counting on it. In January 1997, a year after JDK 1.0, [InfoWorld reported](https://www.infoworld.com/article/2076867/educators-embrace-java.html) that “the growing adoption of Java in the education market is not mere coincidence”: Sun wanted “schools to teach Java as a first programming language” and “to boost Java’s stature as a mainstream, general-purpose programming language.” Industry pulled too. One professor chose Java partly because “Java-literate programmers are quite marketable.”

[^5]: By 2003 Java was common enough in introductory university courses that the College Board [moved](https://webpages.scu.edu/ftp/dsmolarski/smolar-e.pdf) the AP Computer Science exam to it, starting in the 2003–04 school year.