Comment by andrewla

13 hours ago

I don't love graphical programming environments like this and Scratch and I can't quite put my finger on why I find them so unattractive.

A big part of it is that you can, to some degree, learn programming from this. But you absolutely cannot learn software engineering from this.

I would love to see the opposite emerge, a programming environment focused on teaching architecture, security, separation of concerns, etc. All while letting LLMs deal with the fussy programming bits.

The script is already flipping, with kids making software using AI but they can only fumble forward inch by inch while burning tokens. It would be great to introduce programming in the way it functions in the workplace - we want to make a Mario clone, start with the goal, hammer out the elements to a certain fidelity then let the AI cook.

  • This would be so exciting. The implementation language would be less of a concern, but it worth wondering about... Would you use Rust, Racket, Lisp, Clojure, etc? I had a lot of fun teaching adults to program using DrRacket and didn't focus on the language as much as the concepts you mentioned above. They ended up being easily able to move to Javascript, Swift, and others at the end of the course.

If you appreciate when keyboard interaction gets added to a GUI, then you might think of a graphical language as the opposite, as it essentially removes keyboard interaction from what is normally a text-based system.

LEGO created NXT-G for programming their Mindstorm NXT. It has since, in my opinion, been the best graphical programming I've seen to date.

It did have a slight learning curve, but 5th graders were competing just fine against high schoolers haha.

I have the same gripe and I think it’s just simply that when you are used to being able to just write code, everything else feels like it’s in the way.

Visual coding is a pain to change and move around quickly. It’s just clutter ultimately - if you know how to actually code.

I learned to program from block programming, starting out when I was 12. I'm now a full-time developer and funded startup founder. You absolutely can learn complex concepts from simple primitives, and there is a large underground community pushing the limits of languages like Scratch. See for example Linux running on RISC-V running on Scratch:

https://turbowarp.org/1201938491

  • In my experience, there’s no better way to learn more complex programming techniques or tools than running into a brick wall with the simple tools you’re familiar with, spending a ton of time on an unreasonably irritating solution, only to realize that you’re running into a classic [n] problem and some clever person figured out a simple logical trick to address it. I mean, it can be enraging but that knowledge tends to stick.

    Though I doubt that happens much anymore.

This supports making your own higher order functions. You absolutely can learn software engineering from this. What you can't do is get syntax errors, which makes teaching a classroom of kids by yourself intractable.

  • I skimmed the manual. It's more powerful than I thought. You can do metaprogramming directly in the language, which will deconstruct blocks into lists. It's basically Scheme as blocks,

from someone who can remember how they even got into programming:

it's because this is BS and just a toy, it's got no connection to the real world.

from the angle of someone trying to make some toy to teach programming, maybe in their head it's like: oh this is so simple and easy it should work perfectly for teaching

but from my experience, most of my learning came from "whats this?" "how do i make a thing like this?"

this doesn't provide a way to accomplish that or to promote curiosity

I think same applies to basic CS courses teaching bits and bytes, it's not really useful to know what bits and bytes are if you don't understand what they're even used for or why you should know what they are

however, this is just my subjective point of view, maybe it differs for others.

  • Fair that your path worked differently for you.

    But "no connection to the real world" is hard to sustain once you look at what people actually build with Snap!/Scratch. The ecosystem is full of bridges to physical stuff:

    Cameras, microphones, audio, pen plotters, 3D (BeetleBlocks). Snap! 12.1 (video from a few days ago) adds body-language recognition, Bauhaus-style shape compositions, first-class Processes, translation updates:

    https://www.youtube.com/watch?v=ID7wYxzHUAc

    Arduino / micro:bit / boards (Snap4Arduino, MicroBlocks, many hardware libraries):

    https://www.youtube.com/watch?v=Ltzlzk_zkys&list=PL5OeDsbY1E...

    Robots (Finch, Hummingbird, Lego NXT, drones):

    https://www.youtube.com/watch?v=6_0EqIbTlkk

    Sewing machines (TurtleStitch -- embroidery from blocks; one of my favorites):

    https://www.youtube.com/watch?v=K6ra5ThxkrE

    Web APIs and IoT:

    https://www.youtube.com/watch?v=l_P7MoBG250

    ML/AI and digital fabrication (Ken Kahn's eCraft2Learn):

    https://project.ecraft2learn.eu/

    The "what's this? how do I make a thing like this?" curiosity you describe is exactly how a lot of people get pulled in -- making something move, blink, sing, or stitch on a machine they can see, rather than learning abstract syntax first. Blocks are the on-ramp; the project is the motivation.

    Different audience than yours, maybe. But "just a toy walled off from reality" undersells what this community has been doing for decades.

    Snap! also teaches real computer science at college level while staying accessible to kids -- not a stripped-down kiddie language. Brian Harvey: "Snap! is Scheme disguised as Scratch" (though he notes the original intent was closer to Logo disguised as Scratch):

    https://forum.snap.berkeley.edu/t/hygienic-macros/3258/6

    Re alanbernstein's point about keyboard vs GUI: Snap! is not keyboard-hostile. It has a keyboard editor for scripts -- build and edit whole scripts without the mouse, block search from the keyboard, infix arithmetic expressions typed left-to-right. Manual chapter:

    https://docs.snap.berkeley.edu/user-interface-elements/#sec-...

    Demo (typing formulas from the keyboard):

    https://www.youtube.com/watch?v=ahHAl3p3gEU

    Full IDE accessibility (screen readers etc.) is still a work in progress; Jens and Brian document what's there now:

    https://github.com/jmoenig/Snap/issues/1498

    • I guess I just can't relate to it, because I was fascinated with the computing itself, not just getting from A to B as quickly as possible

      so it wasn't the project that was the motivation, it was figuring out how to do it for real, and getting closer to expertise in programming

      for example the TurtleStitch, I don't know how to say this exactly, but to me it doesn't strike as something that'd interest people who want to get into programming, but is more like a way to showcase how to do machined embroidery in an accessible way

      I might be totally wrong, but my problem seems to be that a lot of this is just about showing off the capabilities of Snap, but it's not really something I would've engaged with for example?

      like almost as if the ecosystem simply serves to show off Snap and thus misses the mark?

      like Snap doesn't really provide a way to understand how stuff is actually done except for maybe simple logic. So I don't see how it'd be very useful for e.g. learning CS when it's not really something you'd see in the real world, i.e. you're learning a learning platform and some basic concepts

      I guess my point is like, if it's not really something that's used in the real world, unlike say JS or Python, why use it instead of getting up to speed in a real language?

      again, it could be that I simply don't get it, or that I'm not the target audience, but I feel like there's a reason why these haven't really taken off, and IMO there's no reason why they would need to, because they serve a very specific niche

      1 reply →