Principles of Educational Programming Language Design | Hacker News Reader

Principles of Educational Programming Language Design

infedu.vu.lt

85 pointsazhenley66 comments

I disagree with the premise of the article. We absolutely do not know how to teach programming both pedagogically and andragogically, you can see that 80% of the students after getting their masters in CS absolutely can not program, do not understand computation, or the computer, not to mention higher order abstractions and their interactions.

There are university students now in their 3rd year that paste chatgpt's javascript program into their c# code (also written by chatgpt) and ask me why is everything red and its not "working".

I think it is a problem of designing for the 'average' student, which of course does not exist.

The academia focuses too much on the abstract languages and constructs, but the reality is, the code will run on a man-made digital computer, which has certain properties, it uses memory in a certain way, has a clock, and is discrete, certain things are possible, and others are not. No matter how much we pretend, the equal sign (=) leaks through, and that in itself creates infinite confusion in people who pretend to get it.

I think hyper individualistic approach is the solution. My daughter for example really dislikes scratch and various graphical languages, but she does really well with machine code and assembly and c. When we were working on a chess game, and she said: "WAIT! the queen is just rook + bishop", we went into how can we actually structure our code to express that. The journey is completely non linear. Sometimes we go back, sometimes forward.

Hopefully AI + teacher can help with that. But the truth is, some kids get various concepts, like recursion or references and values, naturally, some never get it. And we are trying to teach them the same thing at the same time for the same duration, and just move on.

SICP is best for some, PDP11 machine code for others, godot or roblox lua for third, and so on. The problem is we don't know which is which :)

PS: Some of the things I made to teach my daughter: https://punkx.org/

> No matter how much we pretend, the equal sign (=) leaks through, and that in itself creates infinite confusion in people who pretend to get it.

I have a feeling that this issue might be amplified by the facts that

1. many US-American students are monolingual.

2. I have observed that many native English speakers are less interested in their own language than native speakers of other languages for their mother tongue.

For 1: If you are used to learn multiple (natural) languages, you are very used to the fact that (nearly) identical words can have very different meanings in different languages (false friends).

Examples:

sensible [en] vs sensibel [de] ("sensitive" in English)

bite [en] vs bite [fr] (a vulgar word)

So for me there is nothing surprising about the fact that "=" means different things in mathematics vs programming languages that use = as an assignment operator.

For 2: There exist quite a lot of English words that can have very different meanings depending on the context (arbitrary example: "left" can both mean a direction, and be the simple past and past participle of "to leave"). So what is so difficult about the fact that = means something different in a C/C++/Java/C#/Python program than in a math equation?

This isn't what the article says...

The articles says roughly that "while we know what to strive for, we are falling short of achieving our goals." It doesn't make the claim that we know how to teach programming.

Now, unrelated to what the article says, I wanted to bring up this point: there are several ways we know how to teach something, and they apply better to different disciplines. For instance, the approach where we do lecture-lecture-lecture-seminar-test is what's used to teach subjects that require very little hands-on work (eg. law, history etc.) Then, there's lecture-lab-lecture-lab-lecture-lab-test approach, which is better suited to subjects like biology or electrical engineering etc.

Some subjects have their own tradition of teaching that's mostly unique to them. Eg. painting is taught by assigning students to the professor's workshop, where they, basically, live for a few years. No formal "teaching" takes place, but the workshop's master interacts with students whenever he/she feels fit. Or, conservatory students who, usually, spend hours in one-on-one training with their teacher practicing their instrument of choice.

What I think is happening in teaching to program is that because the field originated in math + engineering faculties, the tradition of how to teach it was borrowed from that space too: lectures + labs + tests. But, I think, that programming is more similar to painting in the way how it's done and how it could potentially be taught. So, instead of short-term labs and tests, it would be beneficial for the students to have long-term projects, possibly worked on in groups, where interaction with the teacher happens when the teacher inspects the work done so far and decides to provide feedback.

The drawback of this approach is the grading that will not be defined formally and will be grounds for disputes between the students and the teachers. But, I still think it would've been better than the sequence of short-term assignments that must be worked on alone, because the later doesn't welcome and sometimes precludes the use of industry tools (s.a. version control systems, bug trackers). Essentially, today, those who are taught to program aren't taught how to use programming tools at all. Which is very weird to anyone coming from a school with a practical slant, where studying the tools would've been an essential part of the training.

> This isn't what the article says...

thats not the only thing it says, but it does say it:

> The conclusions to be drawn from the points made throughout this paper are reasonably obvious: We need a new language for teaching novices at secondary school and introductory university level.

It also does states that somehow we know how to teach programming, and the discussion is around finding an incremental improvement given the learnings so far.

That's taken out of context. The article says that in order to become good at programming students will need to learn multiple languages, including those popular in the industry. But, since students are going to learn multiple languages anyways, it's also necessary to have a language that is useful to teach programming concepts rather than the ropes of the "real world". And this is the language it's talking about in your quote.

I concur, but it's even worse: I have a son who's doing a master in engineering (not CS). He had several programming courses in python and R. When looking at the example solutions, I noticed that whoever wrote them can't code, doesn't understand programming and certainly should not be allowed to teach it.

I never went to university, but in high school I had two different teachers, and one was hundreds of times better than the other.

I am not really sure how teachers get hired, how they are interviewed and assessed, but the system is clearly not working; particularly in subjects that the learning curve is not a curve (like math, or physics or cs)

I find the core position of the author unconvincing - that is, the author advocates for non-professional languages for beginners, instead using languages designed specifically for teaching. The main argument put forward in favor of professional languages is crossover: if a student learns a language in class, they may be able to use that language professionally. The author then argues against that main point.

I think students should be taught in "professional" languages, but crossover is not my main reason. Rather, it's that professional languages have an enormous corpus of examples that students can look up. If a student is learning on a teaching language without much adoption, there's just not much else a student can do but use the materials that part of the course. Teaching languages don't let students expand their universe of examples.

I agree with the author's point about real insight coming on learning the second (and third, etc.) language and systems. But I don't find it as a compelling point in favor of teaching languages - quite the opposite. To me it means there's no need to obsess over first languages.

Designing programming languages is fun. Designing a programming language which meets some platonic ideal of teachability is moreso because it feels possible to "solve" the design and craft the perfect jewel of a language. But I'm unconvinced it's useful research.

For the record, my first language was C++, and I'd default to teaching beginners in Python.

I also find it more useful to teach something real, not a toy.

Even PASCAL was never a toy, though it was designed motivated by teaching purpose, it became professional because it was capable of that.

When I told some friends I was going to teach 11-year-olds to program, and that I was considering some BASIC versus Python, they suggested Scratch. But 11-year-olds aren't babies. They can understand a lot, and they should be enabled to talk about their code (which textual representations enable, but not Scratch-style visual programs).

So I picked Python (with pyturtle for easy turtle graphics), and it worked well.

I actually think Scratch is fine for 10ish year olds, mainly because all of my above holds true: scratch.mit.edu is an online community where kids can copy, tweak and in general be inspired by and learn from what other kids have done. Your universe can expand with your curiosity. When my nephew was 10, he started with Scratch. My brother guided him towards using Python on a Raspberry Pi soon after.

For kids around 10, I think it's all about what the kid thinks is more fun.

exactly... just getting rid of boilerplate on syntax feels so friendly with the tiny humans

we should also don't forget that learning for its own sake, sometimes, is the meaning/end of pedagogy; not luring them to the professional path of computer science/programming

And with devices like micro:bit, and platforms like makecode and tinkercad, you can actually take block-based programming really far.

I would be surprised if your first program was C++? Specifically, getting a decent C++ toolchain that can produce a meaningful program is not a small thing?

I'm not sure where I feel about languages made for teaching and whatnot, yet; but I would be remiss if I didn't encourage my kids to use https://scratch.mit.edu/ for their early programming. I remember early computers would boot into a BASIC prompt and I could transcribe some programs to make screensavers and games. LOGO was not uncommon to explore fractals and general path finding ideas.

Even beyond games and screensavers, MS Access (or any similar offering, FoxPro, as an example) was easily more valuable for learning to program interfaces to data than I'm used to seeing from many lower level offerings. Our industries shunning of interface builders has done more to make it difficult to get kids programming than I think we admit.

Edit to add: Honestly, I think my kids learned more about game programming from Mario Builder at early ages than makes sense.

> I would be surprised if your first program was C++? Specifically, getting a decent C++ toolchain that can produce a meaningful program is not a small thing?

Visual C++ (some version) was in a book I received as a gift in high school, it was my second language after BASIC (some version on a Tandy running MS-DOS). It was not hard to set up. You ran the installer, you had the language set up. If someone had ended up in the same situation as me but without the BASIC experience, I could see it being an easy to set up (not easy to learn) first language.

Apologies for making you prove the statement. That wasn't my intention.

I was musing on how expensive a C++ capable setup was back when I was learning. I was probably closer to having it as an opportunity than I realize. But MS Access and the like was already something that was beyond my realistic budget for things. That was largely helping out with business software friends of the family were using.

I am probably also more sour on just how silly difficult it is to put pixels on a screen nowadays. Python's turtle graphics kind of works ok, if you are only doing turtle graphics. But just getting a sprite and moving it around can be surprisingly involved, it seems. I wanted my kids to learn with the Code the Classics book. May have them give that a try again, soon. First pass, they all have far more mileage with Scratch.

> I am probably also more sour on just how silly difficult it is to put pixels on a screen nowadays.

It seems like it's always been this way. I messed around with VB6 as a kid. It was an amazingly intuitive experience to work with forms, buttons, and hooking up simple actions to them.

However, when it came time to do some simple 2d graphics, like moving balls around the screen, you'd be in the deep end, trying to figure out BitBlt and double-buffering and the like. You might as well have been using C++.

Agreed that getting into the weeds has always been difficult. Especially if you needed it to go fast. Just setting up a double buffered set of screens was easy enough, though?

>Our industries shunning of interface builders has done more to make it difficult to get kids programming than I think we admit.

I'd be very glad of an agreed-upon IDE which:

- made it easy to draw up a UI

- was cross-platform

- opensource

- easy to install/compile/distribute compiled programs

Bonus points if it is also uses standard widgets and is accessible to screen readers and the like.

Livecode (Hypercard clone previously known as Runtime Revolution) was sort of that until the community edition was pulled.

Fully agreed. I'd be happy with a stable API that lets me treat a window as an array of pixels.

I'll put another plug in for scratch, if you are ok with any of the limitations it has.

I seem to recall there were more options installed on a default Raspberry Pi than I expected. I think many of them fail the open source criteria? It even has a student edition of Mathematica, which is quite impressive for what it does.

Not really easy to make a traditional application/program and distribute it stand-alone from Scratch.

I'd love to see a Lisp compiler w/ GUI toolkit which would just compile to a stand-alone .exe or .app or .apk or even .html file w/ matching JavaScript library.

I think distributing a stand-alone application is beyond most any beginner level needs. They want to share, sure; but with a much more limited audience.

Not that I wouldn't love the same, mind you. I think a lot of toolkits and compilers make the mistake of trying to be universally distributable. Regardless of how much effort that happens to be.

You've now learned that the internet will provide counterexamples whenever you make a categorical statement :)

My first language wasn't C++, it was BASIC, but by the time I got hold of Microsoft QuickC and Borland Turbo C++ they were available as self-contained IDEs that Just Worked.

My first program was indeed C++. In 1998, my high school had a computer lab setup with Turbo C++, and I took a non-AP computer science class. In college, starting in 1999, after entering as a computer science major, we were guided to use Visual C++ on Windows. We got Visual C++ from our department - I can't remember if we paid or if it was just provided to us.

Ah, I see that not only did I accidentally force you to prove this, but I accidentally got others to do so. My humble apologies on that!

I'm not super shocked that some people got started with Visual C++ sooner than I would have had access to it. It remains surprising to me, though. See my other post on more of the why, for that.

Visual C++ is actually very easy to get started with (it wasn't my first though) You run a wizard which generates a full, runnable, skeleton application into which you can then easily plugin code from a book (thank you David Kruglinski). I had done Win32 C programming (thank you Charles Petzold) prior to getting into Visual C++ and it was shocking to see how the IDE/Wizards really made complicated things extremely easy. In fact many of the noob programmers in my team didn't even know how to run the compiler, assembler, linker separately (they did not come from a Unix background) since the IDE did it all for you at the press of a function key.

Yeah, my view was Visual C++ was not so difficult to use; but that it was difficult to have access to. You had to have a computer that could run it, and then you had to be able to afford it. Am I shocked that some people had access to it? No. It is surprising that it would be someone's first access, though.

Actually it was the norm for Microsoft technology programmers (there was/is a huge number of them) and not surprising at all. You went from MS-DOS to Win16/Win32 to Visual C++ as MS kept releasing them, specifically the transition from 16-bit to 32-bit was a major checkpoint. IIRC the first version of VC++ was released on Windows NT 3.51 (or was it 4?) on a Intel 386 platform. The PC clones were available everywhere and in true hacker fashion people ran cracked copies of Windows NT and VC++ if they could not afford to buy it. For many programmers VC++/MFC was their first introduction to C++ language programming and i still remember trying to explain to noob programmers the distinction between MS' libraries/additions vs. plain vanilla C++ language.

That makes sense. It just barely post-dates my experiences.

This happened to my sister at Florida State University, and she lost her mind.

The problem I have with this is "professional languages have an enormous corpus of examples that students can look up."

The problem is that especially for common languages like Javascript, complex ones like C++ and changing ones like Java the published code follows Sturgeon's Law "ninety percent of everything is crap" Made worse by the languages and libraries have changed over time so even good code 20 years ago is not good code now. (This is also the problem with AI generated code - it learns from rubbish) Experienced programmers can look at code and see what is crap so the way we look is different to beginners.

For teaching you want curated examples.

> If a student is learning on a teaching language without much adoption, there's just not much else a student can do but use the materials that part of the course.

I think that is the biggest advantage of using a teaching language. You can give them curated, high-quality examples and make sure they not led astray by crap code they find on the internet.

And in the ChatGPT era it forces them to actually learn how to code instead of relying on AI.

The main problem is that student motivation is what drives learning success. Just because something is good for them and theoretically the best way to learn does not mean they will like this. It is difficult to sell young people long term benefits that you can only see after many years of experience.

It seems to me that the majority of students prefers "real world" languages to more elegant teaching languages. I guess it is a combination of suspected career benefits and also not wanting to be patronized with a teaching language. I wish people were more open to learning language for the fun of it but it is what it is. Teach them the languages they want to learn.

Agree on this. That's a big problem I have with using Python. There are so many ways of doing things (this is also mentioned in the paper) it is almost impossible for the students to do it properly.

I think the problem with teaching languages is also of neurological nature, basically "student motivation is what drives learning success". Our brain constantly filters out non relevant information. A teaching language, having no use outside of the course, scores very low on relevance in our brain making it very hard to learn and find motivation.

I think you overestimate the ability of a tiny community of curators to generate examples to meet the curiosity of students.

That is why I think the solution would be to use Lisp, and to have the students develop a custom language during the course which would then be used for assignments.

The Racket distribution has many languages, in particular a few "Student Languages" that are simplified versions of the main language and are degigned to use with the book "How to Design Programs" [1].

They have some artificial restictions to avoid common errors of beginers, and give better hints in case of common errors. They are (almost) a subset, so you can just change the language declaration at the top and get the full power.

  #lang beginer ; <-- I'm not sure which is the magic keyword [2]
  (define (f x y) (+ x y))
  (display (f 2 3)) ;==> 5
  (display f) ;==> error: it's probably an error of a beginer

  #lang racket
  (define (f x y) (+ x y))
  (display (f 2 3)) ;==> 5
  (display f) ;==> #<procedure:f>

[1] https://docs.racket-lang.org/drracket/htdp-langs.html

[2] There is some magic in the editor to hide the declaration in the students languages and I don't use them, so I'm not sure how to summon them in the text version.

> I think students should be taught in "professional" languages, but crossover is not my main reason. Rather, it's that professional languages have an enormous corpus of examples that students can look up.

PHP fits this description, and lots of self-learners get it as their first language. I am not sure we want to go that direction

My hot take on this topic is that one should introduce programming through spreadsheets, Google sheets or even MS excel.

Assuming it’s done at the high school level students can immediately find value in using it for household budgeting, school or business inventory management, small business accounting, event management and what not. Combine it with Google Forms and you have a near complete product.

> I find the core position of the author unconvincing - that is, the author advocates for non-professional languages for beginners

Based on my experience of teaching 10-16 year old kids to program, a non-professional language does help. Is it necessary? Absolutely not. Does it increase chances of success for a child struggling with their first programming experience? I believe so. Even 10% increase makes a huge difference when applied at scale in schools.

How does an artificial education-focused language help concretely? In my experience there are two big problems well-meaning kids experience when they learn stuff: insufficient attention and insufficient resilience.

1) Attention. If you want to explain something to kids you better get to the point damn quick otherwise in 10 minutes you get that blank stare from 8 out of 10 kids (even if you managed to keep them from looking into the window, talking to each other or playing with their phones). When you see these glassy eyes you know it's already lost, no matter what you say next it just won't stick. You have to reboot the lesson with some distraction and start over again. When teaching the first programming language this means that you absolutely cannot explain properly how scanf("%d",&i) works. It takes variadic parameters, in this instance it's two pointers and pointers typically take 3-4 dedicated lessons to truly understand, much later in the curriculum. You'll never get to these pointer lessons if you didn't even manage to write your first program that reads a number from the keyboard. And I'm not even getting into #include <stdio.h> and preprocessor stuff. So what you have to do is to say "trust me, just memorize it as a spell, you will understand it later". When teaching C to non-programmers you say that phrase a lot.

2) Resilience. Not all kids are the same but many of them (can't say if majority or not, depends on the composition) give up rather quickly in the face or problems, judging either themselves or the subject to be stupid (depending on personality). There are 10 different ways in which you can write scanf("%d",&i) incorrectly when you don't understand the mechanics behind it, which increases the chance of mistakes and increases the number of kids who give up. When teaching C to non-programmers you see desperate people struggling with even simplest programs quite often.

Is it possible to overcome all this and learn C++ as your first language on a Dvorak keyboard while learning English in parallel, like one of commenters here unironically suggests? Yes, it is possible. Is it likely to happen? I don't think so, such curriculum will have very low success rates even with a good teacher. And an average school teacher would probably fail at it himself. You can also try teaching a child to count by starting from Peano axioms I guess.

So these learning-focused languages (like Logo from my childhood) help to maintain attention and resilience by building a proper progression curve: you don't need to understand complex concepts to be able write simple programs. Game designers know this very well: you never throw all the complexity at the player at level 1, you gradually introduce game mechanics and tricks so that they have time to adapt and learn. If you make a game where level 1 is overly complicated, will people still manage to play it? Some will, but most will give up.

Overall I'm quite depressed with the state of programming for kids where I live right now (Paris). At the age of 10 they didn't even begin, while at the same age we already drawing chessboards in Logo. And that was 1999 in the middle of Russia, not 2024 in the middle of Europe.

I'm surprised the author doesn't mention LISP, despite recognizing at some point that programming also IS language design (without explicitly calling it meta-linguistic abstraction, unlike SICP).

LISP is the language/notation most easily/flexibly extended, and this is one of the reasons why it may never disappear as long as we still have programming languages around.

Omitting an entire class of languages with a strong history in pedagogy damages my opinion of the article.

No mention of Racket, Scheme or SICP!?

Interestingly, an Oberon successor came up here recently:

https://news.ycombinator.com/item?id=42413343

Having just watched:

https://ocw.mit.edu/courses/6-001-structure-and-interpretati...

and recalling a comparative programming language class from college, I'd be inclined to argue for Lisp and the idea of the students creating a programming language during the course of the class.

The thing I find most striking is that the book:

_How to Think Like a Computer Scientist_

(now _Think Python_)

has had many different versions for different languages, but apparently not for Lisp.

Well, I'm still waiting for something to beat the MSWLogo which defined my childhood between 8 and 12 years old. By now I've tried quite a few things with my kids and most of them IMO display a complete lack of understanding of what can be good for a 8-10 year old child. E.g. typing "player.move_forward()" instead of "fw" (hi, codingforkids) is complete insanity: kids typically do not master touch typing by that age. Furthermore, with kids using tablets instead of PCs nowadays I doubt most of them will master touch typing at all. Nor do they care about the syntax of ".member" and "func()" for that matter, that's beyond the point when you're just trying to figure out what a procedural program even is.

I'm open to recommendations of programming languages and programming-related games for kids between 4 and 12 years old, for Android and PC. This is what I've tried so far:

* Scratch is interesting but simple programs like "add two numbers" require crazy levels of dedication of drawing sprites for every digit and programming a character for every decimal place (unless I got it wrong, open for advice). I think it will come handy later to teach about eventloops, signals and threads, but not as a first language.

* codingforkids.io -- "papa, but this sucks, you do it all day?" was hard to argue with that

* Human Resource Machine -- incredible game and does drill some good concepts but is too remote from programming (I still recommend it though)

* Mindustry -- also a good game but is even further away from what programming is compared to HRM

* Any other recommendations?

Blockly?

I've been using it BlockSCAD:

https://www.blockscad3d.com/editor/

and apparently it can be used in Jupyter notebooks?

https://jupyterlab-blockly.readthedocs.io/en/latest/

Or perhaps a node programming system such as:

https://nodezator.com/

https://ryven.org/

https://github.com/derkork/openscad-graph-editor

> kids typically do not master touch typing by that age.

That's wrong, I have an experience of learning 9yo touchtyping with Dvorak as the first step to learning both how to program and how to learn English from scratch. It took no more than 6 hours of continuous work or 2 weeks of a full from zero to hero routine.

I also had experience with brilliant kids during my teaching side-career, but my statement is still true: kids TYPICALLY do not master touch typing by that age. In fact, it's extremely rare based on the kids I know and knew in the past.

Still wrong, it should not be the kid's choice, it should be the teacher's choice. As well as choose of hardware and OS, it just should not be the kid's choice because all they want by their own choice is consuming the capitalists' dark patterns.

BTW adults also typically do not master touchtyping, typically they have some advanced 4-fingers hunt-and-peck approach, and do not have a need to progress.

N.b. here is a brief article[0] in which Matthias Felleisen explains the reasoning behind the CS curriculum he developed at Northeastern University.

[0] https://felleisen.org/matthias/Thoughts/Developing_Developer...

I wanted the author to pick a winner among approaches, but he's surveying and inviting new research. Most recently, Kölling has supervised the development of Strype, a frame-based editor for python. https://strype.org/

The abstract asks:

> Why do we not have a programming language that is designed for education and in widespread use across the world

It is important for a teacher to immediately demonstrate subject-matter mastery. If a student asks a question that goes beyond the planned lesson, you need to have an answer. You can't say, "I don't know how to do that." That would make you look incompetent.

When you're teaching programming, it is easiest to do this with a programming language that you know well and use everyday. That language is unlikely be a language designed explicitly for education.

I was a TA and instructor for several programming classes, usually in Java, with which I was moderately experienced but not an expert.

My students would frequently ask how to accomplish something, how syntax or keywords worked on q deeper level, whether there was a stl class for a purpose, or what caused an error, etc, that I didn't know about already. I didn't hide my ignorance even a little bit, but Idid help them find an answer. In lecture settings, if it wasn't too much of a digression, I'd demonstrate finding the answer. In one on one help, or one on group help, I'd lead them through finding the answer themselves. My students had a lot of respect for me as an authority on the language and still listened to my advice and came to me with questions frequently.

This is kinda important across all fields, but especially in programming, you don't need to know the right answer by rote so much as you need to be able to seek and identify the right answer with some independence using existing resources.

Absolutely. Demonstrating how to Google (and now, how to ChatGPT) is important. The pervasiveness of Java makes it relatively easy to do.

> If a student asks a question that goes beyond the planned lesson, you need to have an answer. You can't say, "I don't know how to do that." That would make you look incompetent.

Huh? It's perfectly normal for the curiosity of students to surpass the subject matter expertise of the teacher. Why do you believe that makes the teacher incompetent?

As my great teacher, Nikos Tzanakis, used to say: nobody is infallible. The only infallible people are secondary education teachers!

Huh? I teach a first year programming course. I often reply to questions with "let's see if the compiler lets us do that" or "let's quickly search how to do that".

We do this in our regular job. It makes sense to me to demonstrate this process to students.

None of us knows everything there is to know about a language and its libraries. Heck, I'm part of the language development team of a language and I have to look things up about it.

This is true, as long as you consider immediately knowing to Google it and competently doing so a valid answer.

This article argues at considerable length that an "educational" language targeting complete novices should choose a keyword-heavy syntax like Wirth's Modula 2 as opposed to a terser one like C, prior to discussing more esoteric topics like structural editing, "frame"-like graphical representations of high-level syntax and such. Is there any significant evidence that the keyword-heavy syntax style may be easier to understand for novice coders, or is this just a matter of subjective preference?

> Is there any significant evidence that the keyword-heavy syntax style may be easier to understand for novice coders, or is this just a matter of subjective preference?

I'm not sure how you'd subjectively measure that. Also, I don't think it's just the keyword-heavy syntax of language like PASCAL or Modula-2 that make them easier to learn than, say, C/C++. They also discourage quirky, terse expressions (favorites of advanced C/C++ devs) that can be difficult for beginners to understand.

Beginners face an uphill battle: not only are they being introduced to abstract concepts like data structures and flow control, but they have to deal with the language syntax. You can't do much to alleviate the former, but you can make the latter a bit easier by picking a language with a more straightforward, plain syntax.

A keyword-heavy syntax ought to make it easier to produce helpful error messages

(I'm a fan of very terse syntax, but do admit that when you mess up with it, you probably typed something that's also syntactically, and often even semantically, valid — so you don't get as much support from the machine as a novice might like)

> "the experienced user will usually know what's wrong" —KLT

Computers should be controlled (primarily) via a programming language (aka the shell). That way you are "learning" every time you want to do anything on your computer, and anything you do can be programmed.

I prefer Lua for this purpose (and am extending it to be more suitable), but almost any "simple" language will do. Sh/bash are the original and IMO we should try to move away from them (pipes are still cool though)

That's a great concept. That was part of the premise of Smalltalk and Oberon, for example. How are you extending Lua to accomplish that goal?

https://lua.civboot.org

Ruby checks all of these boxes.

Also, it’s extremely valuable to see multiple real world languages after initial exposure. A single teaching language is insufficient. Aside from syntactic differences, there are other important differences like memory management, typing, and threading.

Also a teaching language lacks utility in the sense that it can’t be used for personal projects without reinventing wheels. Plus it would lack community and other external resources.

So yes C++ is a horrible language to start with, but students should see it at some point. And yes maybe Ruby and Python aren’t perfect, but a student can find other resources online and maybe even work on a personal project.

odd to publish such an article with so many undefended opinions.

for instance, that low-boilerplate is somehow worse than high-boilerplate languages because the boilerplate somehow builds character ("teaches important lessons ... from the start"). this insipidly assumes boilerplate is necessary for encapsulation and modularity. yes, the directness of Python does make it better than Java.

similarly, there seems to be a peculiar theory of learning here: both that learning many languages is a goal, and that you should Do It Right from the start. suppose the goal is to learn concepts, and it's perfectly fine to iteratively use a single language, starting with a simple subset.

An Educational Programming Language should not be too far removed from mainstream "Industry" languages. Complexity should not be completely hidden while teaching/learning Programming but must be gradually unveiled.

I believe a multiparadigm language with a small "kernel language" to which you progressively add more layers for different paradigms should be the way to teach. The Mozart/Oz language i think shows the way - https://en.wikipedia.org/wiki/Oz_(programming_language)

Genuinely curious about how LLMs and tools like bolt.new will change programming education. (Not computer science education—that might not change much)

Counter view: there should be no such thing as an educational programming language. Some set of regular production languages that are sufficiently easy to learn that they can be used in education should exist. If not then collectively we're doing something wrong with language design.

Random data point: I "taught" a middle school coding class for a couple years using JS. Turned out ok.

Reply on news.ycombinator.com