Hacker News Reader

> The myth that kids that age are all digital natives and hence much more adept at learning CS amd programming is wrong.

It feels sort of like assuming that kids born after commercial aviation became widely available have some magical understanding of fluid dynamics.

Racket is an interesting system for pedagogy. Up until now, it's been focused on undergrads, but the principles should be similar. If you aren't familiar, Racket lets you create new languages that (among many other things) can hide the complexity of the "full" Racket language to just a few primitives for purposes of elaborating some point or insight. There is a whole series of these languages designed specifically around /How To Design Programs/: https://docs.racket-lang.org/drracket/htdp-langs.html

The HTDP languages all look like Scheme, as most Racket languages do, but you can actually swap or modify the reader as well, to produce Blub-y languages (for example, someone has implemented ECMAscript: https://docs.racket-lang.org/ecmascript/index.html) that interoperate with other languages in the Racket system (including Racket itself).

At the same time, Racket is "real" in the sense that you can build production systems in it (not in the HTDP languages themselves, but it all interoperates), and it has a pretty good batteries-included core lib and contrib packages. For example, you could integrate the students' code (in a simplified pedagogical language) with the webserver (from the "real" language), so that they can see their code doing stuff out on the web where others can look at it, or they can show their parents, rather than trapped in some educational IDE that's only installed at school.

I taught high school freshmen using HtDP for three years and loved it. Definitely works for high schoolers!

However, there aren't any non-overwhelming "real" coding platforms out there. Python comes very close, but is far from simple (pip, IDE, maybe mypy, because it turns out types are helpful when learning to program).

What you're looking for is Racket. It has a set of options for starting from a barebones language and gradually adding features as you progress through the course. Here's a description of the different student language levels you can use in Racket:

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

I think visual feedback is important, I teached multiple people programming with https://processing.org/

Processing is more like a framework and comes in python and java flavour (although I think the language doesn't really matter as long as you grasp how loops work and what can be done with it).

Something like this:

    def setup():
        size(400, 400)
        stroke(255)
      
    def draw():
        line(150, 25, mouseX, mouseY)
     
    def mousePressed():
        background(192, 64, 0)

The concepts learned by just playing around with this are valuable in any language.

That looks an awful lot like Logo ….

This is something that earlier versions of flash did very well. You could start by creating graphics, then turn them into frames in an animation. In order to make those frames dynamic you had to learn some programming, and you'd get instant feedback.

It wasn't just some toy, you could create production applications this way. Unfortunately the low bar resulted in a lot of low quality applications (in terms of ux and engineering) which led to it's downfall.

On the fact that types are useful to learning programming, I cannot agree more. I often hear php and javascript labelled as good for beginners, and I did start programming in those (I had no formal CS training and am not a programmer). I wrote crappy code for years before I started using VBA and discovered the benefit of setting option explicit on, and suddenly the IDE provided helpful feedback, objects became self discoverable. And that’s when I started to improve and moved to more sophisticated languages.

We use https://thonny.org/ for Python.

I am a strange programmer, I think using a debugger is vital to understanding a program ;)

We start with things like Python and Turtle, drawing shapes and emoticons. Then we move on to functions and objects and stuff.

My girlfriend (completely out of the blue) asked me recently if I could teach her some programming. This looks fantastically simple, and I couldn't agree more that debuggers are vastly underrated when it comes to teaching beginners.

Thanks, I'll almost certainly be using this.

http://www.pythontutor.com/visualize.html#

this is one of my favorite tools for python, lets you iterate through every step in your program

Ironically, scratch probably has more in common with the modern package-orientated JS ecosystem than more traditional languages! ;)

I was recently at a couple of secondary open evenings with my son, and it blew my mind how far CS education has come. The only thing that seemed slightly lacking was anything around tooling and unit testing, TDD being a nice segway between theoretical and practical application imo.

I strongly believe in a few years the current "${library} experience === cushy fintech job" environment will be completely reversed, as the number of strong developers grows and the self-taught guys like myself that have been in industry for ages die off.

More importantly I suspect the demand for more practical, industry recognized vocational CS qualifications will grow.

You may want to have a look at Pyret[0] as a teaching language as well as Racket as others have recommended.

Pyret was designed by many of the same people involved in the Dr.Racket community, and has been specially tailored for early programming education. It uses a functional programming style, pattern matching, and tests built into function definitions.

[0] https://www.pyret.org/index.html

Pyret may very well be a great programming language. But it likely does not belong in a programming pedagogy at a higher ed institution. Why? Because time is limited. We already teach Intro to Programming in Python, which to us is a "throwaway" because they then go on to learn .NET (ie C#), Java, or "Web". I wish would could go deeper with just one language, but it is what the advisory committee has approved.

Scratch and similar block-based environments could be "the real deal".

If you ignore the pretty blocks, you can see that scratch is nearly a normal language. There is no reason we can't have a language with both representations, plain text and pretty blocks. You could even have a hotkey to switch the pretty colors on and off.

I strongly suspect that most modern programming languages would almost work with a block-based editor. You might need to leave out a few things, but not much.

Consider C. You can't tolerate a macro that expands to an opening curly brace, but you can tolerate both function-like and const-like macros. You could load many normal *.c files, and you could save them, and the only thing lost would be some whitespace.

12 years of teaching full time Intro to Programming (and other courses) at community college has taught me this: No matter how good a student is at "computers" doesn't matter. On day 1, I ask them to raise their hand if they are at the college math level (there is no pre-req to Intro to Programming here). I then ask them to raise their other hand if they have NOT studied a foreign language. I then say that those of you with both hands raised will find this class very challenging. Perhaps the hardest class you will have had so far. People ask "What is programming like?" My answer: it is like solving word problems in a foreign language.

Taking math but not language is supposed to make CS harder? That is a terrible evaluation.

A decent predictor is having enjoyed writing math proofs. Normally this starts in a geometry class, though sometimes a few proofs are done in beginner algebra classes. Many people hate proofs.

A weaker predictor is having experience with a plain-text editor (not Word or GMail, but raw ASCII) and with filesystem directory trees.

Foreign language is completely different. It's irregular. It involves making and hearing sounds.

> However, there aren't any non-overwhelming "real" coding platforms out there.

For the past few years, we have been working on a Scala based 'real' coding environment that's easy to get going with (via Turtle graphics), but also supports more advanced stuff (generative art, games, circuits/robots):

http://www.kogics.net/kojo

http://www.kogics.net/kojo-screenshots

I think you may be missing the larger point here - there is a lack of friendly/decent/sane programming environments.

Not for beginners, for everyone. For beginners, it's only overwhelming and can be helped with someone who already knows it. For people who are solving real problems - the awful tooling programmers have to deal with everyday is a major pain point that hasn't been addressed in decades.

Nice to hear from someone with experience in this area.

I wonder though, if the problem with existing platforms is in the environment and tooling, is a new programming language going to help? Wouldn't it make more sense to build better tools around one of the existing ones? Ones that are more "real deal", as you said? (e.g. TypeScript, Kotlin, Swift, ...)

For those who are not allergic to Microsoft, visual studio is a beast but it is quite intuitive, has a UI for everthing, very easy debugging and auto-complete. I don’t think there is anything wrong with using a professional tool for kids if the few features they will use are easy to do in this environment. Of course I am less convinced any of the languages in VS is a beginner’s language (apart perhaps from VB but it is going away).

>apart perhaps from VB but it is going away

Even presuming it's gone zombie, it'll be 30+ years before it might scatter to the winds...

(And that's presuming that VBA is finally no longer a thing.)

In the meantime, some of these kids might someday make a living at maintaining VB codebases.

True. Though hopefully their first language is a "gateway drug" toward more hardcore stuff!

> Python comes very close, but is far from simple (pip, IDE, maybe mypy, ...

This might be of interest for you to try---it's a super simple Python IDE for beginners: https://codewith.mu/ I've tried it out for doing basic coding demos and works really well...

Have a look at Godot. I'm looking forward to 3.1 (lazy typing) and planning on using it to teach programming.

This will be my first time so we'll see how it goes. But it is cross platform, small, has everything built in and can be used to make games. It is also real so students can take it beyond educational tutorials.

I heard vim is pretty easy.

It's not easy, it's just that nobody knows how to exit it, so once you start using it, you use it for life.

Obligatory reference: "Kids can't use computers"

http://www.coding2learn.org/blog/2013/07/29/kids-cant-use-co...