5 ms·

λ Snap – An inviting programming language for kids and adults for CS study

184 points by dr_kiszonka 23d ago

stymaar 23d ago
For those wondering the difference with scratch, it's on the about page: > About Snap! > Snap! (formerly BYOB) is a visual, drag-and-drop programming language. It is an extended reimplementation of Scratch (a project of the Lifelong Kindergarten Group at the MIT Media Lab) that allows you to Build Your Own Blocks. It also features first class[1] lists, first class procedures, and first class continuations[2]. These added capabilities make it suitable for a serious introduction to computer science for high school or college students.
- biofox 23d ago
  Scratch already allows you to create custom Blocks and features lists. This seems like a perfect example of reinventing the wheel (and fragmenting development communities).
  - striking 23d ago
    Snap implemented these features and others long before Scratch had. To my memory it might have been a decade earlier.
  - DonHopkins 23d ago
    Actually there is a large historical overlap between the two communities -- warm, collaborative, always giving credit where due. Different goals, lots of feedback both ways. Jens Mönig was on the Scratch Team (invited by Mitch Resnick). BYOB was presented at Scratch@MIT 2010 explicitly to merge ideas back into Scratch, not to fork the community: https://scratched.gse.harvard.edu/resources/announcing-byob299-first-class-procedures-scratch.html https://scratched.gse.harvard.edu/resources/announcing-byob2... Berkeley has kept showing up at Scratch conferences (Amsterdam 2015, Bordeaux 2017), and the Scratch forums hosted BYOB/Snap! discussion for years: https://scratch.mit.edu/discuss/topic/4455/ https://scratch.mit.edu/discuss/topic/4455/ So "NIH syndrome," "reinventing the wheel," and "fragmenting the community" is pretty much the opposite of how these two actually interact. Documented cross-pollination: BYOB => Scratch: custom blocks (Scratch 2.0 took command blocks only, not reporters/lambda). That was an explicit goal: https://en.scratch-wiki.info/wiki/Snap https://en.scratch-wiki.info/wiki/Snap! Scratch => Snap!: browser rewrite timing influenced by Scratch 2.0 plans; Morphic via John Maloney; CC-licensed costumes/sounds used under license. Shared people: Jens (Scratch Team => Snap! lead), John Maloney (Scratch/Morphic; GP session with Jens at Scratch2015AMS), Bernat Romagosa (Snap!, MicroBlocks, Snap4Arduino -- Bordeaux, Snap!Cons).
  - rmunn 22d ago
    When I looked at Scratch six months ago, its lists were deliberately handicapped in function. They could only contain text or numbers; they could not contain other lists. Nor could they be passed as parameters to functions (!!), which really made me say "Nope, this is not what I'm going to use to teach programming to kids". I looked at Logo, and was drawing up lesson plans when I noticed Brian Harvey (the primary designer of Berkeley Logo which I was planning to use) had a lot of activity on this other repo. What in the world is https://github.com/jmoenig/Snap/ https://github.com/jmoenig/Snap/ and why is Brian Harvey contributing to it so much? (Looks it up). Oh. OH. And so I taught my class using Snap!, because it has: - Lists that are proper first-class types, and can contain anything, including other lists, and also blocks - Blocks (functions) that are also proper first-class types, and can take anything as parameters, including lists and blocks. - Blocks that can create and return other blocks, thereby enabling functional programming - All the standard list-handling primitives you would expect, like `filter` and `map` All of which was missing from Scratch when I looked at it six months ago. Scratch is a toy language, with a deliberate ceiling that you can't get past because of the language's design. Snap! is a real programming language with no ceiling, with the visual appearance of a toy. It takes longer to do anything in Snap! than in a professional language like Lisp or C# or Go or ... well, all of them, because dragging blocks together is a lot slower than typing. But you can do anything you need to in Snap!. There is no artificial limit that blocks you from going farther, the way Scratch has. P.S. Saying that Scratch is artificially limited is not meant as a dig against the language. It's a deliberate design choice, and it's a fine choice if your intent is to teach people the very basics and then graduate them to another language. It's a choice I disagree with, because I prefer the way Snap! has implemented the same pedagogical choice (you can create tutorials with a limited set of blocks, to avoid presenting complete beginners with an overwhelming array of choices). But it's a defensible choice in many cases (many kids taking a programming class will not have the aptitude — and those who do turn out to have the knack for it can be graduated to Snap! really easily and not have to relearn everything).
    - brian_harvey 22d ago
      Not to mention first class continuations! :) Thanks!
sinuhe69 23d ago
Snap is designed to be more expressive and powerful than Scratch. But I find debugging them is very painful. Changing the name of a variable or block for example, could create “holes” in the calling sites but the system can or cannot report an error and fails silently. Snap is IMO more flaky and the team seems more eager to add features than polish the existing ones or make the system mor robust and stable.
- Xirdus 23d ago
  > Changing the name of a variable or block for example, could create “holes” in the calling sites WTF. Isn't the whole point of visual programming that you are NOT bound by the limitations of text as a medium? A block refers to a specific variable. It shouldn't matter what it's called, it shouldn't matter if what it's called changes, it should still refer to the same variable even after renames.
  - gs17 23d ago
    That one is a bit more defensible for variables, when you rename variables, it gives you "rename" or "rename all". "rename" renames the variable, leaving uses of it the same, "rename all" also renames where you used it. Deleting a variable leaves the blocks that references it in place but they'll throw an error if called (IIRC this is useful if you wanted to switch from a global to local variable or vice versa). Now, custom blocks have a different issue, where deleting one just severs any code that was using it (so if you had some custom blocks in a program: [on start] -> a -> b -> c, deleting the definition for b will mean c no longer gets called). There's now a block to delete custom blocks, so you can make self-destructing code.
- gs17 23d ago
  They've fixed surprisingly many of the quirks, but my biggest gripe with Snap is that they don't like to add documentation with new features. A lot of the older content has a nice "help..." context menu option with a description of what it does (which is often out of date itself, e.g. the "split" and "join" by blocks feature isn't shown on those blocks), and newer blocks have the context menu option... but nothing pops up.
anguishe 23d ago
Nice! I did a few chapters of this when I was learning. I'll have to add it to my list to go and check out any new updates/features they have. I can NOT wait to get my little one into something like this!
jc4p 23d ago
I've been spending a lot of time with my nephews working on Scratch and Snap. They also attend local classes and their teachers switched from Snap to this which is way simpler and stickier with my nephews: https://www.microsoft.com/en-us/makecode https://www.microsoft.com/en-us/makecode
- crushinator 23d ago
  Yeah, my nephew loved scratch but he's endlessly devoted to make code. I got him a little Gameboy thing that can play the games he builds, and he keeps sending me games of his and then mercilessly mocking me for not being good at them :( A couple years ago I went through Flexbox Froggy with him out of curiosity, and the really interesting thing was that he was able to complete all the levels but only by dictating to me what to write, because his eye hand coordination wasn't yet up to the task of typing. He has a laptop now and he's getting better but his fingers just don't work very quickly and accurately yet. It's such an interesting thing developmentally that the visual coding approach is helpful for.
  - dr_kiszonka 23d ago
    What device did you get your nephew? When I was looking for one, those listed on the Make Code website were pretty bad and expensive (or unavailable). I would love to find an affordable retro handheld like Miyoo or Anbernic with Make Code support.
    - crushinator 23d ago
      I got the Elecfreaks Retro Arcade for Education, I'm sure it's not as bulletproof as an actual Gameboy so he uses it with his parents around rather than taking it everywhere with him, but it works!
      - grugagag 22d ago
        https://wiki.elecfreaks.com/en/retroarcade/retro-case-06 https://wiki.elecfreaks.com/en/retroarcade/retro-case-06
smlacy 23d ago
I guess universities suffer from NIH-syndrome just as much as big tech does.
- rmunn 22d ago
  Not true in this case; the original intent for BYOB (Build Your Own Blocks) was as an extension to Scratch. When the Scratch team decided not to merge it, the BYOB folks decided to build it into Snap! instead of abandoning the perfectly-functional code they'd written.
andrewla 23d 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.
- r_lee 23d ago
  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.
  - deleted 23d ago
    [deleted]
  - DonHopkins 23d ago
    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 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=PL5OeDsbY1ElLa5FvQoejTFddsVZpp8Nah https://www.youtube.com/watch?v=Ltzlzk_zkys&list=PL5OeDsbY1E... Robots (Finch, Hummingbird, Lego NXT, drones): https://www.youtube.com/watch?v=6_0EqIbTlkk 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 https://www.youtube.com/watch?v=K6ra5ThxkrE Web APIs and IoT: https://www.youtube.com/watch?v=l_P7MoBG250 https://www.youtube.com/watch?v=l_P7MoBG250 ML/AI and digital fabrication (Ken Kahn's eCraft2Learn): https://project.ecraft2learn.eu/ 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 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-keyboard-editing https://docs.snap.berkeley.edu/user-interface-elements/#sec-... Demo (typing formulas from the keyboard): https://www.youtube.com/watch?v=ahHAl3p3gEU 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 https://github.com/jmoenig/Snap/issues/1498
DonHopkins 23d ago
https://news.ycombinator.com/item?id=38016554 https://news.ycombinator.com/item?id=38016554 [...] I'm also a huge fan of Snap!, which has all the advantages of Logo (Lisp without parenthesis) and Scratch / eToys / Squeak / App Inventor family of block based visual programming languages, but all the power of Scheme. If you know Scheme, then it's easy to think about Snap!: it's just Scheme with a visual block syntax, but with some functions renamed to make them easier to learn, plus all the stage and turtle graphics stuff from Scratch, running in a web browser! I didn't realize until watching in amazement as Jens Mönig used his own creation, that it also has full keyboard support, so you can create and edit programs without using the mouse! It's much easier to teach Scheme to kids by teaching them Snap!, because the user interface is so much better than a text editor. I attended Snap!Con2023 in Barcelona recently, and we discussed some interesting possible extensions to Snap: Grammar defining blocks. Right now you can create your own custom vocabularies of blocks that fit together in particular constrained ways, by writing JavaScript Snap! extensions. Develop a set of blocks for visually defining new grammars and vocabularies of custom parameterizable blocks. For example, a grammar for representing plants with seeds, roots, stems, leaves, flowers, petals, etc. You can assemble and edit them manually by dragging and dropping from a palette, or write programs that generated and interpret and transform them, and pass them around as data, for example as instructions to the embroidery machine to sew, or logo turtle to draw. Turtlestitch - Coded Embroidery: https://www.turtlestitch.org/page/about https://www.turtlestitch.org/page/about Ken Kahn led a discussion about integrating LLMs like ChatGPT with Snap!. He's the developer of eCraft2Learn for teaching kids AI programming. Ken recently made some cool Snap! extensions for integrating LLMs with the speech synthesis and recognition system, and orchestrating conversations between different characters. Snap!Con2023: Creative uses of Snap! blocks using large language models like GPT: https://www.youtube.com/watch?v=d2rNGsbzkXI https://www.youtube.com/watch?v=d2rNGsbzkXI Enabling children and beginning programmers to build AI programs: https://ecraft2learn.github.io/ai/ https://ecraft2learn.github.io/ai/ But when it comes to LLMs, code generation, and code understanding, JavaScript has two huge insurmountable advantages over Snap! or any other block based visual programming languages: 1) First of all it's extremely well known, by both humans and LLMs. 2) And second of all, there's typically no efficient and faithful way to textually represent block based programs in a way that ChatGPT (or humans) can easily understand and generate. Of course you could just dump out the XML or JSON save file, but that wastes your token budget, and doesn't work well, because the LLM doesn't inherently understand the syntax and semantics of save files the way it deeply groks JavaScript. You need to define some equivalent text based language to serialize and deserialize your visual programs, or define some equivalency to an existing language, so you can translate back and forth without loss. Like Relax/NG has an XML syntax and also a simple concise human readable syntax, both which can express the same things. But no matter what equivalent language you come up with to serialize your block programs into, it'll never be as well known as JavaScript (unless it IS JavaScript). I think Snap! could take advantage of its equivalency with Scheme, and you could just parse Scheme into Snap! blocks, and the other way around. And ChatGPT knows scheme pretty well, though it's not as ubiquitous and standard as JavaScript. Logo would not be as good as Scheme, since it has ambiguities, because you need to know the number of parameters a function uses in order to parse it, since it's essentially Lisp without parens. [...]
k2xl 23d ago
Question (serious) - Why teach kids programming anymore?
- utopiah 23d ago
  The same reasons we keep on teaching kids to read, write, do math, sketch, take photos, etc ... because it is fun, empowering and important. Most of them will never become professional actors, authors, mathematicians, artists, photographers, etc ... and yet they will rely on those skills, on their own or combined, pretty much every single day of their lives.
- elviejo 23d ago
  Why do we teach them to add and multiply we have calculators? Why do we teach them to read, we have text to voice? Why do we teach them to broom, we have Roombas? Why do we teach them to do the dishes, we have dish-washers? </sarcasm>
  - omegacombinator 23d ago
    Where is the opening <sarcasm> tag?
- bigfishrunning 23d ago
  Programming encourages analytical thinking, and also if no-one learns to program it'll become magic, and that'll be a major societal step back.
- SamBam 23d ago
  I'm a software engineer turned public middle school science teacher. At the moment, I would never encourage any of my students to go into software engineering. It seems to me that's rapidly becoming a field where a small competitive handful will be making millions and everyone else will be unemployed. That said, I have no problem teaching some programming. We're going to be making autonomous greenhouses soon, with windows that open or whatever, and they'll be using Scratch to program their micro:bits. Anything that empowers you to do stuff is a good thing.
- 23d ago
chrisjj 23d ago
> inviting My first attempt to place a statement (play sound at Hz) failed with a Type Error. Android Chrome.
- gs17 23d ago
  It's an odd quirk of Snap that they never cleaned up. Some blocks have a "friendly" error message. Delete a variable and uses of it get "Hmmm... a variable of name 'name' does not exist in this context". That one just regurgitates the JS error when it should say "You need to add and select a sound to play a sound".
  - chrisjj 23d ago
    Nor does it let me select a sound. The drop-down list is empty.
    - gs17 23d ago
      You have to add one, in the sounds tab you can record one, or in the file menu they have a library of them you can load (they also have libraries of sprites and backgrounds which are pretty useful when we use this with students).
      - chrisjj 23d ago
        Thanks. I think I misinterpreted inviting.
Dwedit 23d ago
Any name that you can't type is going to be a problem.
- Jtsummers 23d ago
  > Any name that you can't type is going to be a problem. Fortunately the name is Snap! so typing it isn't much of a problem. (With the !, which was stripped from the submission title and when most people write about it.)
  - jayknight 23d ago
    The logo has a lambda in front, and I assume that's where the "Λ" came from in the title of the post. But I don't see it in any of the text on their site.
    - Jtsummers 23d ago
      Correct, it's not part of the name, which is just "Snap!".
- gs17 23d ago
  That's more of a problem in text-based coding. One of the things I genuinely like about Snap (well, in my case NetsBlox, which is a fork of it) is the ability to have spaces and weird characters in a variable name. Edit: Oh, you meant the lambda in the post title? It's not really part of the name, but you can at least type it into Snap itself.
  - brian_harvey 22d ago
    There's no need to type the word "lambda" into Snap!. As befits a visual language, we have a visual representation of lambda; it's the gray ring that you sometimes see surrounding an expression or a script. It's a discoverable notation; when you click on an expression you see its value, and when the expression is inside a ring the value you see is the expression itself. We inherited from Scratch the idea of using different shapes of input slots to represent the data type that's expected, round for numbers and rectangular for text. (They have since changed their minds about that, I'm not sure why. They do still use hexagons for Boolean slots.) We have an "expression" data type, and instead of a polygonal shape, we represent expression input slots by preloading them with an empty gray ring. (If you drag something with a gray ring around it into the slot, your ring is absorbed into the one that's already there.) This lets us write higher order functions that are usable by kids who haven't yet wrapped their minds around anonymous functions. It took us three tries to get the notation exactly right, but I'm super proud of it.
aspizu 23d ago
Scratch is how I first learned programming. I was building increasingly ambitious projects in it, and at some point the editor itself became the main thing I was fighting. Once a project got to around 10,000 blocks, it could get painfully laggy, and I ended up spending a lot of time engineering around Scratch's limits. That is what eventually led me to build goboscript: https://github.com/aspizu/goboscript https://github.com/aspizu/goboscript I'm one of the programmers who owe their career to Scratch, this year, I joined https://ente.com https://ente.com as a software engineer. Scratch taught me how to code, and perhaps a bit of real-world engineering indirectly.
- varun_ch 23d ago
  same here! I got into Scratch at the age of 7 and without it (and the Scratch community), I wouldn’t have any career (or even a plan for one). I also worked as an intern on the Scratch team at the Scratch Foundation. I also know that one of the important developers for the Asahi Linux drivers also started on Scratch. I think there’s a lot of real software engineers who started on Scratch (and the Scratch community, which is often overlooked)
- psyklic 22d ago
  This is what happened with me and BASIC. I had to upgrade to C when my programs became limited by complexity, speed, and difficulties robustly integrating audio.
  - bpavuk 22d ago
    same, switched from Scratch to C at age 8, but I only really wanted my programs go fast back then :)
- Muhammad523 22d ago
  I also learned programming with Scratch first, at around age 11, but i soon left it for Python
- saled 22d ago
  I think John Carmack was looking for you recently. https://x.com/ID_AA_Carmack/status/2094450188911845827 https://x.com/ID_AA_Carmack/status/2094450188911845827
nico 23d ago
Nice! Can this be used with a LEGO Wedo set? It would be cool to have some alternatives to the deprecated/unsupported official software, some of which no longer works (like the iOS app)
jacknews 23d ago
Snap is a little intimidating compared to Scratch. It's clearly designed for older students, but at that point some of the advantages of blocks are lost. Most of these systems suffer from the 'canvas' model, where you have many stacks of blocks scattered around the canvas as they are created, possibly in no particular or logical order. It's difficult to find things or to get a good overview, and really becomes a navigation problem as projects get bigger. I think they would greatly benefit from a more traditional ide/file type structure, or some other way to structure 'stacks'.
- rmunn 22d ago
  In Snap! version 12 they have added the ability to create tutorials, which are projects that load up with a limited set of blocks (you choose what set is available when creating the tutorial). This fixes the intimidation problem: you can even create a set of tutorials that, if the student goes through them in the recommended order, teaches the basics with just four or five blocks available at first, then slowly introduces concepts over time.
  - jacknews 22d ago
    TY I was not aware of that, it sounds extremely useful.
avadodin 22d ago
Welcome to the esoteric church of functional programming! Sure, you could use a Scratch for loop and be done with your cat piano program but have you considered constructing something that theoretically works like a for loop from obscure calculus? We even have the occult symbol! Joking aside, if base Scratch does lack a way to express trees as claimed Snap! may in fact be better from the perspective of teaching computer science concepts.
- rmunn 22d ago
  It did as of six months ago when I evaluated Scratch and chose Snap! instead for teaching the beginning-coding class I had signed up to teach. Scratch had lists, but they were only allowed to contain text or numbers, not other lists. To make a tree, you need to be able to nest lists inside other lists. Snap! allows lists to contain any kind of data, including other lists, or even blocks. And it allows blocks to take lists as input, which is another thing lacking from Scratch. Snap! also includes the standard basic list-manipulation functions like `filter` and `map`, which aren't in Scratch at all (naturally, since lists in Scratch can't be passed as input to blocks).
thrtythreeforty 22d ago
I feel like HN shouldn't auto-capitalize "λ" in this instance. An anonymous function is a λ, not a Λ.
fnord77 22d ago
the "code" looks like the comment section from a tumblr post
brian_harvey 22d ago
A note to those commenters who complain that visual programming doesn't help you learn software engineering: Right, you aren't our target audience. We're after the people who aren't going to major in computer science in college, but who're curious what all the fuss is about. They've taken high school algebra, so they know what a variable is and what a function is. (They don't have to know about functions as data, but we hope to teach them that.) These days, they probably used Scratch in elementary school, so we don't have to teach them the syntax of blocks, or what a sprite is, etc. Nobody's going to come straight out of our class into a software engineering job. They'll have plenty of opportunity to learn that later, supposing that (as happens gratifyingly often) they change their minds about what to study in college because of our course. They're not (or at least not yet) hackers, in the sense of people whose instinct on meeting a machine is to take it apart. Oh, P.S., there is one sense in which block languages are better for software engineering: you can have arbitrarily long names of things (including spaces between words), because you only ever need to type the name once, so you can give your procedures self-documenting names such as "convert upper case to lower case letters" instead of ugly "convUcLc".
- rmunn 22d ago
  There's a limit to how long the name can be, even in Snap! — not an enforced limit as far as I know, but a practical one. You don't want the block you're dragging around to be thousands of pixels wide, it's very inconvenient. So people are naturally going to rename "convert all the upper case letters in the input text ___ into lower case letters" (where ___ represents the input slot) into "convert ___ to lower case" at some point, because they get tired of that one block being so much wider than every other block around it. (Edit to add: especially if they're snapping it into the input of a `map` block, which itself is the list input of "keep items (predicate) from (list)" block. That would get unwieldly really fast). But you know some wag is going to paste the Pevear and Volokhonsky translation of War and Peace into a block name, just to see if he can. :-) So perhaps there does need to be an artificial limit, at 4096 characters or so, on block names.
- dr_kiszonka 22d ago
  Thank you for your work on Snap! and for finding the time to respond to our comments.
pamelafox 22d ago
I am generally not a huge fan of block-based coding, but I worked with the Snap folks while I was at UC Berkeley, and they make a very compelling case for both block-based coding and their functions-first approach. While there, I helped develop this middle school curriculum for Snap: https://bjc.berkeley.edu/bjc-r/course/sparks.html https://bjc.berkeley.edu/bjc-r/course/sparks.html It was really interesting to attempt a functions-first approach that was still fun - I ended up re-making similar projects for a functions-first Python course as well.
Norlo 22d ago
[flagged]
Muhammad523 22d ago
The website seems to put significant weight on the fact that it allows you to create your own block. I'd just like to point out that Scratch allows you to do that as well
- lern_too_spel 22d ago
  You can't make a block that returns a number in Scratch, let alone another block. It's really frustrating.
lozf 22d ago
. o O (Maybe Ubuntu users can use snap to download Snap! from the Snap store…)
poppafuze 22d ago
inserting an exclamation point into the name is desperate.
td2 22d ago
How does this compare to blockly?

184 points by dr_kiszonka 23d ago

For those wondering the difference with scratch, it's on the about page: > About Snap! > Snap! (formerly BYOB) is a visual, drag-and-drop programming language. It is an extended reimplementation of Scratch (a project of the Lifelong Kindergarten Group at the MIT Media Lab) that allows you to Build Your Own Blocks. It also features first class[1] lists, first class procedures, and first class continuations[2]. These added capabilities make it suitable for a serious introduction to computer science for high school or college students.

biofox 23d ago
Scratch already allows you to create custom Blocks and features lists. This seems like a perfect example of reinventing the wheel (and fragmenting development communities).
- striking 23d ago
  Snap implemented these features and others long before Scratch had. To my memory it might have been a decade earlier.
- DonHopkins 23d ago
  Actually there is a large historical overlap between the two communities -- warm, collaborative, always giving credit where due. Different goals, lots of feedback both ways. Jens Mönig was on the Scratch Team (invited by Mitch Resnick). BYOB was presented at Scratch@MIT 2010 explicitly to merge ideas back into Scratch, not to fork the community: https://scratched.gse.harvard.edu/resources/announcing-byob299-first-class-procedures-scratch.html https://scratched.gse.harvard.edu/resources/announcing-byob2... Berkeley has kept showing up at Scratch conferences (Amsterdam 2015, Bordeaux 2017), and the Scratch forums hosted BYOB/Snap! discussion for years: https://scratch.mit.edu/discuss/topic/4455/ https://scratch.mit.edu/discuss/topic/4455/ So "NIH syndrome," "reinventing the wheel," and "fragmenting the community" is pretty much the opposite of how these two actually interact. Documented cross-pollination: BYOB => Scratch: custom blocks (Scratch 2.0 took command blocks only, not reporters/lambda). That was an explicit goal: https://en.scratch-wiki.info/wiki/Snap https://en.scratch-wiki.info/wiki/Snap! Scratch => Snap!: browser rewrite timing influenced by Scratch 2.0 plans; Morphic via John Maloney; CC-licensed costumes/sounds used under license. Shared people: Jens (Scratch Team => Snap! lead), John Maloney (Scratch/Morphic; GP session with Jens at Scratch2015AMS), Bernat Romagosa (Snap!, MicroBlocks, Snap4Arduino -- Bordeaux, Snap!Cons).
- rmunn 22d ago
  When I looked at Scratch six months ago, its lists were deliberately handicapped in function. They could only contain text or numbers; they could not contain other lists. Nor could they be passed as parameters to functions (!!), which really made me say "Nope, this is not what I'm going to use to teach programming to kids". I looked at Logo, and was drawing up lesson plans when I noticed Brian Harvey (the primary designer of Berkeley Logo which I was planning to use) had a lot of activity on this other repo. What in the world is https://github.com/jmoenig/Snap/ https://github.com/jmoenig/Snap/ and why is Brian Harvey contributing to it so much? (Looks it up). Oh. OH. And so I taught my class using Snap!, because it has: - Lists that are proper first-class types, and can contain anything, including other lists, and also blocks - Blocks (functions) that are also proper first-class types, and can take anything as parameters, including lists and blocks. - Blocks that can create and return other blocks, thereby enabling functional programming - All the standard list-handling primitives you would expect, like `filter` and `map` All of which was missing from Scratch when I looked at it six months ago. Scratch is a toy language, with a deliberate ceiling that you can't get past because of the language's design. Snap! is a real programming language with no ceiling, with the visual appearance of a toy. It takes longer to do anything in Snap! than in a professional language like Lisp or C# or Go or ... well, all of them, because dragging blocks together is a lot slower than typing. But you can do anything you need to in Snap!. There is no artificial limit that blocks you from going farther, the way Scratch has. P.S. Saying that Scratch is artificially limited is not meant as a dig against the language. It's a deliberate design choice, and it's a fine choice if your intent is to teach people the very basics and then graduate them to another language. It's a choice I disagree with, because I prefer the way Snap! has implemented the same pedagogical choice (you can create tutorials with a limited set of blocks, to avoid presenting complete beginners with an overwhelming array of choices). But it's a defensible choice in many cases (many kids taking a programming class will not have the aptitude — and those who do turn out to have the knack for it can be graduated to Snap! really easily and not have to relearn everything).
  - brian_harvey 22d ago
    Not to mention first class continuations! :) Thanks!

sinuhe69 23d ago

Snap is designed to be more expressive and powerful than Scratch. But I find debugging them is very painful. Changing the name of a variable or block for example, could create “holes” in the calling sites but the system can or cannot report an error and fails silently. Snap is IMO more flaky and the team seems more eager to add features than polish the existing ones or make the system mor robust and stable.

Xirdus 23d ago
> Changing the name of a variable or block for example, could create “holes” in the calling sites WTF. Isn't the whole point of visual programming that you are NOT bound by the limitations of text as a medium? A block refers to a specific variable. It shouldn't matter what it's called, it shouldn't matter if what it's called changes, it should still refer to the same variable even after renames.
- gs17 23d ago
  That one is a bit more defensible for variables, when you rename variables, it gives you "rename" or "rename all". "rename" renames the variable, leaving uses of it the same, "rename all" also renames where you used it. Deleting a variable leaves the blocks that references it in place but they'll throw an error if called (IIRC this is useful if you wanted to switch from a global to local variable or vice versa). Now, custom blocks have a different issue, where deleting one just severs any code that was using it (so if you had some custom blocks in a program: [on start] -> a -> b -> c, deleting the definition for b will mean c no longer gets called). There's now a block to delete custom blocks, so you can make self-destructing code.
gs17 23d ago
They've fixed surprisingly many of the quirks, but my biggest gripe with Snap is that they don't like to add documentation with new features. A lot of the older content has a nice "help..." context menu option with a description of what it does (which is often out of date itself, e.g. the "split" and "join" by blocks feature isn't shown on those blocks), and newer blocks have the context menu option... but nothing pops up.

anguishe 23d ago

Nice! I did a few chapters of this when I was learning. I'll have to add it to my list to go and check out any new updates/features they have. I can NOT wait to get my little one into something like this!

jc4p 23d ago

I've been spending a lot of time with my nephews working on Scratch and Snap. They also attend local classes and their teachers switched from Snap to this which is way simpler and stickier with my nephews: https://www.microsoft.com/en-us/makecode https://www.microsoft.com/en-us/makecode

crushinator 23d ago
Yeah, my nephew loved scratch but he's endlessly devoted to make code. I got him a little Gameboy thing that can play the games he builds, and he keeps sending me games of his and then mercilessly mocking me for not being good at them :( A couple years ago I went through Flexbox Froggy with him out of curiosity, and the really interesting thing was that he was able to complete all the levels but only by dictating to me what to write, because his eye hand coordination wasn't yet up to the task of typing. He has a laptop now and he's getting better but his fingers just don't work very quickly and accurately yet. It's such an interesting thing developmentally that the visual coding approach is helpful for.
- dr_kiszonka 23d ago
  What device did you get your nephew? When I was looking for one, those listed on the Make Code website were pretty bad and expensive (or unavailable). I would love to find an affordable retro handheld like Miyoo or Anbernic with Make Code support.
  - crushinator 23d ago
    I got the Elecfreaks Retro Arcade for Education, I'm sure it's not as bulletproof as an actual Gameboy so he uses it with his parents around rather than taking it everywhere with him, but it works!
    - grugagag 22d ago
      https://wiki.elecfreaks.com/en/retroarcade/retro-case-06 https://wiki.elecfreaks.com/en/retroarcade/retro-case-06

smlacy 23d ago

I guess universities suffer from NIH-syndrome just as much as big tech does.

rmunn 22d ago
Not true in this case; the original intent for BYOB (Build Your Own Blocks) was as an extension to Scratch. When the Scratch team decided not to merge it, the BYOB folks decided to build it into Snap! instead of abandoning the perfectly-functional code they'd written.

andrewla 23d 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.

r_lee 23d ago
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.
- deleted 23d ago
  [deleted]
- DonHopkins 23d ago
  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 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=PL5OeDsbY1ElLa5FvQoejTFddsVZpp8Nah https://www.youtube.com/watch?v=Ltzlzk_zkys&list=PL5OeDsbY1E... Robots (Finch, Hummingbird, Lego NXT, drones): https://www.youtube.com/watch?v=6_0EqIbTlkk 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 https://www.youtube.com/watch?v=K6ra5ThxkrE Web APIs and IoT: https://www.youtube.com/watch?v=l_P7MoBG250 https://www.youtube.com/watch?v=l_P7MoBG250 ML/AI and digital fabrication (Ken Kahn's eCraft2Learn): https://project.ecraft2learn.eu/ 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 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-keyboard-editing https://docs.snap.berkeley.edu/user-interface-elements/#sec-... Demo (typing formulas from the keyboard): https://www.youtube.com/watch?v=ahHAl3p3gEU 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 https://github.com/jmoenig/Snap/issues/1498

DonHopkins 23d ago

https://news.ycombinator.com/item?id=38016554 https://news.ycombinator.com/item?id=38016554 [...] I'm also a huge fan of Snap!, which has all the advantages of Logo (Lisp without parenthesis) and Scratch / eToys / Squeak / App Inventor family of block based visual programming languages, but all the power of Scheme. If you know Scheme, then it's easy to think about Snap!: it's just Scheme with a visual block syntax, but with some functions renamed to make them easier to learn, plus all the stage and turtle graphics stuff from Scratch, running in a web browser! I didn't realize until watching in amazement as Jens Mönig used his own creation, that it also has full keyboard support, so you can create and edit programs without using the mouse! It's much easier to teach Scheme to kids by teaching them Snap!, because the user interface is so much better than a text editor. I attended Snap!Con2023 in Barcelona recently, and we discussed some interesting possible extensions to Snap: Grammar defining blocks. Right now you can create your own custom vocabularies of blocks that fit together in particular constrained ways, by writing JavaScript Snap! extensions. Develop a set of blocks for visually defining new grammars and vocabularies of custom parameterizable blocks. For example, a grammar for representing plants with seeds, roots, stems, leaves, flowers, petals, etc. You can assemble and edit them manually by dragging and dropping from a palette, or write programs that generated and interpret and transform them, and pass them around as data, for example as instructions to the embroidery machine to sew, or logo turtle to draw. Turtlestitch - Coded Embroidery: https://www.turtlestitch.org/page/about https://www.turtlestitch.org/page/about Ken Kahn led a discussion about integrating LLMs like ChatGPT with Snap!. He's the developer of eCraft2Learn for teaching kids AI programming. Ken recently made some cool Snap! extensions for integrating LLMs with the speech synthesis and recognition system, and orchestrating conversations between different characters. Snap!Con2023: Creative uses of Snap! blocks using large language models like GPT: https://www.youtube.com/watch?v=d2rNGsbzkXI https://www.youtube.com/watch?v=d2rNGsbzkXI Enabling children and beginning programmers to build AI programs: https://ecraft2learn.github.io/ai/ https://ecraft2learn.github.io/ai/ But when it comes to LLMs, code generation, and code understanding, JavaScript has two huge insurmountable advantages over Snap! or any other block based visual programming languages: 1) First of all it's extremely well known, by both humans and LLMs. 2) And second of all, there's typically no efficient and faithful way to textually represent block based programs in a way that ChatGPT (or humans) can easily understand and generate. Of course you could just dump out the XML or JSON save file, but that wastes your token budget, and doesn't work well, because the LLM doesn't inherently understand the syntax and semantics of save files the way it deeply groks JavaScript. You need to define some equivalent text based language to serialize and deserialize your visual programs, or define some equivalency to an existing language, so you can translate back and forth without loss. Like Relax/NG has an XML syntax and also a simple concise human readable syntax, both which can express the same things. But no matter what equivalent language you come up with to serialize your block programs into, it'll never be as well known as JavaScript (unless it IS JavaScript). I think Snap! could take advantage of its equivalency with Scheme, and you could just parse Scheme into Snap! blocks, and the other way around. And ChatGPT knows scheme pretty well, though it's not as ubiquitous and standard as JavaScript. Logo would not be as good as Scheme, since it has ambiguities, because you need to know the number of parameters a function uses in order to parse it, since it's essentially Lisp without parens. [...]

k2xl 23d ago

Question (serious) - Why teach kids programming anymore?

utopiah 23d ago
The same reasons we keep on teaching kids to read, write, do math, sketch, take photos, etc ... because it is fun, empowering and important. Most of them will never become professional actors, authors, mathematicians, artists, photographers, etc ... and yet they will rely on those skills, on their own or combined, pretty much every single day of their lives.
elviejo 23d ago
Why do we teach them to add and multiply we have calculators? Why do we teach them to read, we have text to voice? Why do we teach them to broom, we have Roombas? Why do we teach them to do the dishes, we have dish-washers? </sarcasm>
- omegacombinator 23d ago
  Where is the opening <sarcasm> tag?
bigfishrunning 23d ago
Programming encourages analytical thinking, and also if no-one learns to program it'll become magic, and that'll be a major societal step back.
SamBam 23d ago
I'm a software engineer turned public middle school science teacher. At the moment, I would never encourage any of my students to go into software engineering. It seems to me that's rapidly becoming a field where a small competitive handful will be making millions and everyone else will be unemployed. That said, I have no problem teaching some programming. We're going to be making autonomous greenhouses soon, with windows that open or whatever, and they'll be using Scratch to program their micro:bits. Anything that empowers you to do stuff is a good thing.
23d ago

chrisjj 23d ago

> inviting My first attempt to place a statement (play sound at Hz) failed with a Type Error. Android Chrome.

gs17 23d ago
It's an odd quirk of Snap that they never cleaned up. Some blocks have a "friendly" error message. Delete a variable and uses of it get "Hmmm... a variable of name 'name' does not exist in this context". That one just regurgitates the JS error when it should say "You need to add and select a sound to play a sound".
- chrisjj 23d ago
  Nor does it let me select a sound. The drop-down list is empty.
  - gs17 23d ago
    You have to add one, in the sounds tab you can record one, or in the file menu they have a library of them you can load (they also have libraries of sprites and backgrounds which are pretty useful when we use this with students).
    - chrisjj 23d ago
      Thanks. I think I misinterpreted inviting.

Dwedit 23d ago

Any name that you can't type is going to be a problem.

Jtsummers 23d ago
> Any name that you can't type is going to be a problem. Fortunately the name is Snap! so typing it isn't much of a problem. (With the !, which was stripped from the submission title and when most people write about it.)
- jayknight 23d ago
  The logo has a lambda in front, and I assume that's where the "Λ" came from in the title of the post. But I don't see it in any of the text on their site.
  - Jtsummers 23d ago
    Correct, it's not part of the name, which is just "Snap!".
gs17 23d ago
That's more of a problem in text-based coding. One of the things I genuinely like about Snap (well, in my case NetsBlox, which is a fork of it) is the ability to have spaces and weird characters in a variable name. Edit: Oh, you meant the lambda in the post title? It's not really part of the name, but you can at least type it into Snap itself.
- brian_harvey 22d ago
  There's no need to type the word "lambda" into Snap!. As befits a visual language, we have a visual representation of lambda; it's the gray ring that you sometimes see surrounding an expression or a script. It's a discoverable notation; when you click on an expression you see its value, and when the expression is inside a ring the value you see is the expression itself. We inherited from Scratch the idea of using different shapes of input slots to represent the data type that's expected, round for numbers and rectangular for text. (They have since changed their minds about that, I'm not sure why. They do still use hexagons for Boolean slots.) We have an "expression" data type, and instead of a polygonal shape, we represent expression input slots by preloading them with an empty gray ring. (If you drag something with a gray ring around it into the slot, your ring is absorbed into the one that's already there.) This lets us write higher order functions that are usable by kids who haven't yet wrapped their minds around anonymous functions. It took us three tries to get the notation exactly right, but I'm super proud of it.

aspizu 23d ago

Scratch is how I first learned programming. I was building increasingly ambitious projects in it, and at some point the editor itself became the main thing I was fighting. Once a project got to around 10,000 blocks, it could get painfully laggy, and I ended up spending a lot of time engineering around Scratch's limits. That is what eventually led me to build goboscript: https://github.com/aspizu/goboscript https://github.com/aspizu/goboscript I'm one of the programmers who owe their career to Scratch, this year, I joined https://ente.com https://ente.com as a software engineer. Scratch taught me how to code, and perhaps a bit of real-world engineering indirectly.

varun_ch 23d ago
same here! I got into Scratch at the age of 7 and without it (and the Scratch community), I wouldn’t have any career (or even a plan for one). I also worked as an intern on the Scratch team at the Scratch Foundation. I also know that one of the important developers for the Asahi Linux drivers also started on Scratch. I think there’s a lot of real software engineers who started on Scratch (and the Scratch community, which is often overlooked)
psyklic 22d ago
This is what happened with me and BASIC. I had to upgrade to C when my programs became limited by complexity, speed, and difficulties robustly integrating audio.
- bpavuk 22d ago
  same, switched from Scratch to C at age 8, but I only really wanted my programs go fast back then :)
Muhammad523 22d ago
I also learned programming with Scratch first, at around age 11, but i soon left it for Python
saled 22d ago
I think John Carmack was looking for you recently. https://x.com/ID_AA_Carmack/status/2094450188911845827 https://x.com/ID_AA_Carmack/status/2094450188911845827

nico 23d ago

Nice! Can this be used with a LEGO Wedo set? It would be cool to have some alternatives to the deprecated/unsupported official software, some of which no longer works (like the iOS app)

jacknews 23d ago

Snap is a little intimidating compared to Scratch. It's clearly designed for older students, but at that point some of the advantages of blocks are lost. Most of these systems suffer from the 'canvas' model, where you have many stacks of blocks scattered around the canvas as they are created, possibly in no particular or logical order. It's difficult to find things or to get a good overview, and really becomes a navigation problem as projects get bigger. I think they would greatly benefit from a more traditional ide/file type structure, or some other way to structure 'stacks'.

rmunn 22d ago
In Snap! version 12 they have added the ability to create tutorials, which are projects that load up with a limited set of blocks (you choose what set is available when creating the tutorial). This fixes the intimidation problem: you can even create a set of tutorials that, if the student goes through them in the recommended order, teaches the basics with just four or five blocks available at first, then slowly introduces concepts over time.
- jacknews 22d ago
  TY I was not aware of that, it sounds extremely useful.

avadodin 22d ago

Welcome to the esoteric church of functional programming! Sure, you could use a Scratch for loop and be done with your cat piano program but have you considered constructing something that theoretically works like a for loop from obscure calculus? We even have the occult symbol! Joking aside, if base Scratch does lack a way to express trees as claimed Snap! may in fact be better from the perspective of teaching computer science concepts.

rmunn 22d ago
It did as of six months ago when I evaluated Scratch and chose Snap! instead for teaching the beginning-coding class I had signed up to teach. Scratch had lists, but they were only allowed to contain text or numbers, not other lists. To make a tree, you need to be able to nest lists inside other lists. Snap! allows lists to contain any kind of data, including other lists, or even blocks. And it allows blocks to take lists as input, which is another thing lacking from Scratch. Snap! also includes the standard basic list-manipulation functions like `filter` and `map`, which aren't in Scratch at all (naturally, since lists in Scratch can't be passed as input to blocks).

thrtythreeforty 22d ago

I feel like HN shouldn't auto-capitalize "λ" in this instance. An anonymous function is a λ, not a Λ.

fnord77 22d ago

the "code" looks like the comment section from a tumblr post

brian_harvey 22d ago

A note to those commenters who complain that visual programming doesn't help you learn software engineering: Right, you aren't our target audience. We're after the people who aren't going to major in computer science in college, but who're curious what all the fuss is about. They've taken high school algebra, so they know what a variable is and what a function is. (They don't have to know about functions as data, but we hope to teach them that.) These days, they probably used Scratch in elementary school, so we don't have to teach them the syntax of blocks, or what a sprite is, etc. Nobody's going to come straight out of our class into a software engineering job. They'll have plenty of opportunity to learn that later, supposing that (as happens gratifyingly often) they change their minds about what to study in college because of our course. They're not (or at least not yet) hackers, in the sense of people whose instinct on meeting a machine is to take it apart. Oh, P.S., there is one sense in which block languages are better for software engineering: you can have arbitrarily long names of things (including spaces between words), because you only ever need to type the name once, so you can give your procedures self-documenting names such as "convert upper case to lower case letters" instead of ugly "convUcLc".

rmunn 22d ago
There's a limit to how long the name can be, even in Snap! — not an enforced limit as far as I know, but a practical one. You don't want the block you're dragging around to be thousands of pixels wide, it's very inconvenient. So people are naturally going to rename "convert all the upper case letters in the input text ___ into lower case letters" (where ___ represents the input slot) into "convert ___ to lower case" at some point, because they get tired of that one block being so much wider than every other block around it. (Edit to add: especially if they're snapping it into the input of a `map` block, which itself is the list input of "keep items (predicate) from (list)" block. That would get unwieldly really fast). But you know some wag is going to paste the Pevear and Volokhonsky translation of War and Peace into a block name, just to see if he can. :-) So perhaps there does need to be an artificial limit, at 4096 characters or so, on block names.
dr_kiszonka 22d ago
Thank you for your work on Snap! and for finding the time to respond to our comments.

pamelafox 22d ago

I am generally not a huge fan of block-based coding, but I worked with the Snap folks while I was at UC Berkeley, and they make a very compelling case for both block-based coding and their functions-first approach. While there, I helped develop this middle school curriculum for Snap: https://bjc.berkeley.edu/bjc-r/course/sparks.html https://bjc.berkeley.edu/bjc-r/course/sparks.html It was really interesting to attempt a functions-first approach that was still fun - I ended up re-making similar projects for a functions-first Python course as well.

Norlo 22d ago

[flagged]

Muhammad523 22d ago

The website seems to put significant weight on the fact that it allows you to create your own block. I'd just like to point out that Scratch allows you to do that as well

lern_too_spel 22d ago
You can't make a block that returns a number in Scratch, let alone another block. It's really frustrating.

lozf 22d ago

. o O (Maybe Ubuntu users can use snap to download Snap! from the Snap store…)

poppafuze 22d ago

inserting an exclamation point into the name is desperate.

td2 22d ago

How does this compare to blockly?