Ask HN: Is there a modern “power on to basic” computer, for kids to learn on?
I want to give some young kids a small cheap computer that "switches on to basic" or some other programming language?
Like in ye olde computer days when you brought home your Commodore 64 and turned it on you were in basic.
I'm guessing everyone will want to say "Raspberry Pi" of some form, but does that meet my requirement? Plug it into TV, turn it on and you're in basic and can start programming. Ideally with some sort of book or resource for learning how to make the computer do things on the home TV screen.
339 comments
[ 3.2 ms ] story [ 421 ms ] threadClosest modern analogue I can think of is the "console" tab in the browser "developer tools" window. Still stuck with a host OS and JavaScript though...
https://www.lexaloffle.com/pico-8.php
When I was a kid, I was heavily into video games and had a burning desire to create my own. However, the options for doing so were not great. One of my middle school teachers tried to introduce us to programming via creating Space Invaders in perl, which went as well as you might imagine. There were a few GUI game making applications that were all terrible and extremely limited. I eventually managed to make a game using Flash, but all the overhead of arcane Actionscript APIs was overwhelming and discouraging. I stopped programming and for several years thought I was going to go into media, creating films and animation. I eventually picked up programming again in college, but there were many years of programming experience I could have had if I had stuck with game dev.
I'm convinced that if PICO-8 existed when I was originally interested in making games, I never would have stopped programming. PICO-8 is the perfect balance of easy-to-learn and powerful. Lua is a good first language because it's so small, and encourages you to build your own solutions rather than rely on magical libraries. For example, I never knew how a list-shuffling algorithm (Fisher-Yates) worked until I needed to write my own because Lua and PICO-8 don't provide one.
The limited sprite and sound options encourage you to spend time not on the assets but on the gameplay (the code). It's quick to get things on screen and working because the PICO-8 API is simple, logical, and not arcane (cough Actionscript cough).
Basically, it introduces programming in an instant-gratification way that's able to grab and hold a child's attention, while still being powerful enough to produce games that aren't hamstrung by toy programming languages.
My first Basic experience was on a VIC-20, and I later got my own C64 in 85.
Great computer to learn on but I don't think I would have got far without the Programmers Reference Guide.
So I think Pico8 or Scratch are cool in the sense that they give you an environment to start programming. But OTOH, if what you look after is AAA games, then you'll soon be confronted to a brand new wall, ie : DirectX, GPU, C++ whatever. Now I rememeber of Processing which is cool too.
https://en.wikipedia.org/wiki/COSMAC_ELF
Also of note: it was made by the creator of Voxatron (the only game I know of that really explored voxels), and is available as a $5 add-on to that.
Wikipedia page told me of a pocket computer preloaded with PICO-8: Pocket CHIP[1]. It seems to be exactly what the OP was asking for.
Alas, the Kickstarted company went belly up, failing to deliver all the preorders.
[1]https://en.wikipedia.org/wiki/CHIP_(computer)#Pocket_CHIP_an...
Really too bad that the company went under.
I'm going to snatch one on eBay before this thread really picks up.
I've used this Sublime Text Package which works well:
https://packagecontrol.io/packages/PICO-8
You can explain it in an afternoon. Try that with C++ or JavaScript.
a) The code editing story was a bit nicer (better resolution / builtin support for external editing and reloading etc)
b) If there was some kid-specific introductory game programming content for it (even "type all this in and play around with it after" worked for me as a kid)
https://sectordub.itch.io/pico-8-fanzine-1
Key weaknesses of Pico-8 for kids learning to program:
1. The editor runs at the same resolution that the games do. Maybe this is because they didn't want to make their VM flexible enough to deal with multiple resolutions, or they just wanted to make the illusion that the Pico-8 is its own machine very consistent, but the end result is still a painful code editing experience. When I make example programs for my kids, I need to compromise between descriptive variable names and indenting code blocks.
2. Deviations from the standard lua API/libraries mean that normal learning resources like PIL have to be interpreted with an asterisk.
3. This is a minor thing, but the fixed palette is annoying. In graphical terms, Pico-8 lies roughly between the Atari 2600, 7800, and NES, but all of those systems handled colors more flexibly.
4. Splore allows children to find games that are not appropriate for their age. It's just not designed for kids and parents. My son found a game featuring smoking and thought it looked SO COOL (this was easy to disabuse him of). He also found a game that puts you in the role of a cyberbully, and the subtle psychological effects of that sort of "edgy" game aren't as easily undone with a single conversation. It is possible to mitigate this by putting whitelisted carts into the bbs carts folder and then making that folder read-only.
TIC-80 improves on the first three points. The editor is still running at the same resolution as the games, but uses a higher resolution (and the editor can optionally use a thinner font). The lua implementation is much more standard. And the palette can be changed (even per-scanline, I think). The music editor lets you draw your own waveforms, but in other respects is less intuitive than Pico-8's. (I haven't looked at TIC-80's cart browser so I can't comment on it.)
Multiple resolutions would absolutely break the "Fantasy console" feel of Pico-8, even though I understand why programmers universally hate that. To be fair a lot of people do code editing outside of the Pico-8 editor.
#4 is an interesting point. The trick here is that different parents have different ideas of what is and isn't appropriate, and of course different kids will have different responses. It seems like the answer is to maybe have a version of Pico-8 that removes splore and expands the demo carts with some universally safe, popular titles.
TIC-80 is cool btw and might be a better learning environment for kids. I don't like it (or any of the other fantasy console\pico-8 clones) quite as much as Pico-8 because they remove constraints, making them feel more like generic game editors and less like imaginary retro computers.
Indeed, which is why they won't change, which is why (for me) an alternative like TIC-80 is preferable to waiting around for Pico-8 to become what I wish it were.
The virtual console space is tantalizing, but the culture around it has different tastes from mine. For example,
>I don't like it (or any of the other fantasy console\pico-8 clones) quite as much as Pico-8 because they remove constraints
This is a pretty common sentiment on the Pico-8 boards; I understand there are people looking for a certain aesthetic thrill that comes from working within the constraints to make something unexpectedly cool. And yes, when I have time, I would like to make e.g. a metroidvania that uses individual tiles to encode 4x4 chunks of tiles to allow for a big-ass map. It just so happens that those constraints aren't necessary for, and sometimes are in tension with, the goals of a good first-coding-experience learning environment.
I also totally understand why virtual consoles almost all use BASIC or lua, but (for me, not for my kids) I wish there were an option with static types. The combination of not being able to see much code on the screen at once plus no static type checking is pretty uncomfortable for me.
At some point the question becomes why not just use Unity, BFXR, Bosca Ceoil and ASE Sprite if you want no constraints and better tools with a similar Pico-8-ish aesthetic? That question is outside of the scope of the original post, but as I piece together your ideal fantasy console, it seems like not really a fantasy console but a simple general purpose game IDE with a statically typed language.
Edit: Btw, if what you want is a simple general purpose game IDE with a statically typed language that is somewhere in-between Unity and Pico-8 I suggest you make it or at least spec out your needs more formally! I'm definitely a fan of more people making game creation tools (and software development tools in general) that fit their needs\use cases.
I actually do like reasonably low resolutions in-game rather than in the code editor. When I play with my kids I want it to feel like good graphics aren't too far out of reach, and low-res makes it easier to get to something in the range of acceptable. My own kids appreciate their own pixel art more than anything they do in Scratch, for example.
I also think I might be slightly younger than most fantasy console fans, maybe? When I was very young I had an Apple IIc, which was good for booting straight to BASIC, but most of my childhood programming occurred in the era that spanned from CGA cards to VGA, and then I left programming for a while when 3d acceleration became a thing. One quirk of this era was that tradeoffs between color depth and resolution were just a normal thing. So for me, it would be a natural thing for a retro game dev environment that simulated a fixed framebuffer size to support, say, a 256x192 256 color mode and a 512x384 4 color mode. An editor in that higher-resolution, low-color mode would be way more comfortable than in low-res. (Pico-8 does have an alternate resolution, but it's 64x64 and still 16 color- somewhat evocative of the old 40x40 mode that Apples had).
TIC-80 does almost, um, tic all my boxes. I mostly just want a higher-resolution code editing mode (for both me and my kids) and a static language (for me; my kids don't really have a notion of types (yet)). So obviously the solution is to fork TIC-80 and see what I can make it do...
My ideal machine would be a C64 and Spectrum combined, 4 commodore sound chips, screen resolution increased only about 50%, 256kB ram, possibility of running 6502 and z80 in parallel, at quadruple speed.
Could be just nostalgia, but the continuing demo scene for these computers is incredible[a] and beautiful new games also get made to the old frugal specifications.
[a]https://www.youtube.com/watch?v=5UN2HHVScUw
If are into games, check out Celeste. Just the music is reason to play this game (I played it on PS4 but all versions are equal).
Games can be compiled to HTML5, ando/or distributed as PNG files with all source code and assets included. There's also a builtin community game browser with ratings, etc. Some bigger name games were prototyped in Pico-8 (i.e., Celeste), and it has a lot of love in the indie community.
* Pico-8: https://www.lexaloffle.com/pico-8.php
* Liko-12: https://liko-12.github.io/
* Tic-80: https://tic.computer/
* Pixel Vision 8: https://www.pixelvision8.com/
I have no idea how they compare to each other.
A couple on the list run BASIC! E.g. [2].
I just learned there's this thing "Windows 10 IoT", [3] a Win10 version for low power devices like the raspberri pi.
Would be interesting to try to run B8 in there!
1: https://github.com/paladin-t/fantasy
2: https://store.steampowered.com/app/767240/BASIC8/
3: https://developer.microsoft.com/en-us/windows/iot/Downloads
1: https://www.gigabyte.com/Mini-PcBarebone/GB-BXBT-2807-rev-10...
Pixel Vision 8 is more flexible and complex than the other alternatives. One KEY difference between it and the others is that you can define your own editor tools... but the way this is done means that you must save your work every time you switch from tool A to tool B, or your work in tool A will be lost! It also is built with a focus on interoperability with external tools; it isn't as focused as the others on being a cozy self-contained environment.
Sadly they went out of business.
It would be easy to build something similar with a Raspberry Pi though.
It's a simple, 2D, open-source game engine that runs on all platforms — I'd recommend this and other sandbox-style environments to anyone getting into programming.
https://love2d.org/
https://www.theverge.com/circuitbreaker/2016/7/19/12227806/p...
Unfortunately, the company has shut down, and these aren't made anymore. But it looks like they can still be found on eBay:
https://www.ebay.com/itm/Pocket-C-H-I-P-sealed-portable-hand...
The pico-8 version exists as a game within the game and is great fun as well!
Website: http://www.celestegame.com/
GDC talk about development of Celeste: https://youtu.be/4RlpMhBKNr0
That said, I wonder if it's even possible to replicate the C64 (or equivalent) experience. Looking back, I think a big part of the "magic" was that there were relatively few distractions. Just you, the machine, and (maybe) some paper documentation or a magazine with a few listings [1]. Can that be replicated once you're used to network-connected computers that are gateways to almost unlimited amounts of video, colourful games, etc.?
(My child is getting to the point where I wish I knew the answers to some of this myself...)
[1] I'm pretty certain type-in listings were the biggest contributor to my learning, early on. That doesn't seem to be something that comes up terribly often nowadays (although I note that Zed Shaw's "Learn Python the Hard Way" is pretty specific about telling you to hand-type in the examples...)
No reason why someone couldn't create a Pi installation which does that - RetroPie boots into the game console screen, after all. BasicPie could just as easily boot into a Basic / Lua / Pico8 interpreter.
(Get a normal Pi install with X and set Scratch to be the startup/only X app? Would that work?)
Setting up a Pi or something to boot directly to a C64 emulator would be easier and an order of magnitude less expensive for most people.
http://geoffg.net/maximite.html
There's also the fignition which has a composite out and powers on to forth:
https://sites.google.com/site/libby8dev/fignition
But does require assembly & soldering.
[1] https://www.youtube.com/watch?v=XQA8lowEKOo
There are, I believe, various versions available and if you just want something to learn and write BASIC programs on it's difficult to imagine a better place to start because it boots directly into a BASIC prompt, just like 8-bit microcomputers from the 80s.
https://scratch.mit.edu/
Alternatively Pi's (or old/cheap pc's) that boot straight into Minecraft Eduction Edition:
https://education.minecraft.net
This has paths for the very young in minecraft itself to older kids using ide's.
http://kata.coderdojo.com/wiki/Scratch_Plants_vs_Zombies
I'm interested enough but can't guarantee low enough email latency on my end of staying in touch.
https://www.microbit.org/
Not exactly the same as what you're looking for, but the idea here is to introduce kids to programming with a small, self-contained environment, and there is both a graphical coding environment and you can move to Python or Javascript.
Comes with a 5x5 LED array, an accelerometer, two physical push-buttons, three capacitive sensors, and a bluetooth antenna, already on-board. It means you can start programming without having to plug in to a breadboard and wire up your inputs. You can also hang external sensors and actuators off of it, but the point is you don't need to in order to move beyond toy demonstrations.
It was designed specifically for education, so there are lots of beginner-oriented tutorials available, as well as educator-oriented lesson plans.
As fusiongyro points out, you can program it using three high-level languages. The graphical language lets you toggle to the Javascript version, so there's a clear learning path built-in. These provide high-level commands, such as "get the orientation", or "get the number of button presses since the last query", which makes programming it very straightforward.
It removes a lot of toolchain fussiness. Just run an online editor, or a desktop editor (Mu). These produce binaries that you drag onto the Micro:bit, which mounts to your desktop like an external drive. You can also program it from a smart phone or iPad.
https://pypi.org/project/uflash/
A bit too graphical for my tastes, and lots of distractions — but, lots of learning.
I'm involved in an extracurricular thing in Scotland focused on giving kids an environment they can figure out computers. We've seen a lot of different approaches to the problem of "how can we get kids to code", and Swift Playgrounds is consistently where we see youngfolk making the most progress.
It gives you a nice, guided framework to get the very basics of programming, and slowly gives you more and more "rope" to play with, ultimately leading you to move your projects to Xcode on a Mac.
Swift may not be your favourite language, and Apple are totally doing this with a view to people becoming iOS/MacOS developers (not necessarily a bad thing), but Swift Playgrounds is definitely best-in-class when it comes to having kids teach themselves how to program. The integration with real-life robots and drones is really impressive, too; the kids absolutely love being able to write real code that makes a real robot do things, it's exceptionally motivational.
I grew up around a software company and I was exposed to computers and the internet from a very young age; I had my first computer that could be considered "my own" at about five years of age (a little hand-me-down desktop from my father's company) and cut my teeth on that, building little static websites, stuff like that.
It's definitely what lead to my lifelong interest in computing (as much as I can't stand this industry sometimes) and a healthy career in IT infrastructure.
On Xcode it sucks (buggy, stops refreshing, etc.)
Kind of strange, because it's the same infrastructure...
I'm betting the boundless possibilities presented by direct I/O control of a servo would do more to equip a kid for life than the range of choices presented in an app.
Making your ideas manifest is fascinating, regardless of whether they're tangible.
Personally, I want my kid to be on the TX pair, not the RX.
*BASIC
>_
and bob's your uncle: you get a nice BBC BASIC prompt at the bottom of your screen.
https://www.riscosopen.org/content/downloads/raspberry-pi
(that said, why not use pi + python? It's the new BASIC. And it supports turtle graphics besides ;-) )
Completely OT, but I had just had to look up this phrase and the supposed origin made me chuckle: https://en.wikipedia.org/wiki/Bob%27s_your_uncle
Do you have experience with teaching python to kids? I am afraid to try it with my son because white space is important, I tried only Scratch and making him think as "a machine" is hard enough adding syntax errors on top would make the job much harder, let me know if you have experience with this and if you think I am wrong.
I am not saying that Python syntax is a big issue, but is one more thing to keep in mind and it potentially trip up children(probably something more visual that is impossible to make syntax errors is better but I did not find something that is engaging enough)
If you define a different metric, maybe pretty syntax then it would compare in reverse.
Though I don't have experience or seen people testing this on children and "proving" that having to keep in mind spaces/tabs is harder then the braces and semicolumns (when using a decent IDE) so I may be wrong.
That's pure speculation, not a fact.
1 the cost of keeping indentation in mind for beginners is 0
2 or the cost is greater then zero but there is some different cost in C like syntax that affects beginners
Keep in mind I am talking about syntax here and not the C language
In other words, I think a child will more easily learn about indentation, than handle writing flat code, which can get difficult to understand pretty quick
My point is that something that is obvious and simple for us for someone else makes no sense(he is 12 and I don't have experience teaching other children),
For now I gave up on teaching coding to him, maybe he needs to grow a bit more to understand the abstract thinking required.
When you're trying to get your kid into something that doesn't come naturally, they're more liable to give up quickly if they can't make rapid strides.
What happens if you give him a reference sheet? (I have little experience teaching kids but I’m a firm believer in that the only good test is one where all the puzzle pieces are provided; its the composition thats worth testing, knowing the pieces by heart is just to speed things up)
A thing I learned by doing the homeworks with my son is that is also easy to think that the child learned/understood your nice explanations/graphics/examples he does all the exercises/problems correct and then 1 week later he won't be able to do the exercises again, so I will repeat them again after 1 or 2 weeks to make sure he still knows how to do it. This may be different with other children or different teachers
But unlike BASIC, Python will grow with you and you can use it for non-trivial projects without fighting with the language. I certainly wish my old Apple II had Python; it would have prevented the immense jump to a "real" programming language, because I kept trying to go from AppleSoft BASIC to C and banging my head into a wall, nothing about it made any sense. (Perhaps I would have had better luck going from BASIC to Pascal or QBasic, but for some reason I never thought to try it. I think because the very few computer-literate adults I knew were minicomputer people and led me to believe that C was the only thing worth learning.)
Not that working up from a text prompt is the only way to learn how to interact with computers, certainly. I know a fair number of people who learned to program due to environments like HyperCard, which are much more visual, and let you start with the art and storytelling and then glue things together with code, rather than start from the code.
But for some people, including myself, the feeling of interacting directly with a computer via a simple prompt, and making it do things each time I pressed the Return key, was quite powerful.
But Python doesn't let you do that - there's no goto...
While I'm being somewhat tongue-in-cheek, I do think it's true that
carries quite a bit more conceptual overhead than the BASIC equivalent, and is not exactly a "very simple imperative syntax". You don't have the simplistic and obvious "goto" - instead you have the ungrammatical and obtuse "while true". And then there's the indentation, the colon, and the parentheses around the argument to print... all explainable of course, but all requiring explanation. To fully grok it you need to understand booleans and conditions, block structure, and function calls. Of course it's all perfectly obvious to experienced eyes but remember the mountain you have to climb when you're first starting out - more than one or two seemingly inexplicable things when you're first starting out can be very discouraging.Worse, to my mind, is the loss of that small moment of enlightenment regarding complex behavior emerging from computer programs - with 10 PRINT BUTTS : 20 GOTO 10 you are composing two atomic, individually obvious statements to create something more - an infinite loop. When one of the statements is a slightly more complex line that essentially means "do an infinite loop", some of that magic is lost.
Raspberry Pi Zero + Risc OS Pico.
The fastest BASIC interpreter ever written, with local variables, recursion, inline ARM assembler, and more.
Advantages over Python etc. on Linux:
* No complex OS underneath;
* No need to learn arcane concepts like "editors" and "files" yet;
* No significant whitespace;
* No weird C-isms like the output statements, the two meanings of % or any of that legacy nonsense it inherits from 40y of crap underneath;
* Zero maintenance required.
Blinding fast, cheap as chips, runs on a dribble of power, solid-state and silent.
If the kid takes to it, can be trivially enhanced to a full rich GUI OS with tons of educational apps and software.
Comparing opening Windows 10 and VS and starting a new project to turning on a computer and being presented an in-line-text IDE is to introduce degrees of complexity greater than is needed to understand or teach the fundamental concept (programming).
I think your question, although sincere, is a variation of "why not give a child a 4 wheel drive suv instead of a silly old go cart?"
They are accommodating. They fit. They are easy to master.
If you want the login shell to go straight into programming, you could launch an interpreter or text editor on login using .profile or what have you.
You'll need a keyboard with PS/2 connector and a monitor/tv with a VGA port. And it does "power on to BASIC."
Cheap too...20 EUR.
There's also a "mega" version with added USB and composite video: https://www.olimex.com/Products/Duino/Duinomite/DUINOMITE-ME...
I think the actual coding Python and Javascript with a block formatting kind of like lego Mindstorms. Come to think of it you can use Small Basic on Mindstorms which might be interesting.
For the Kano the coding portion is web based and free if you want to take it for a spin, as well as their OS.
https://world.kano.me/coding-challenges/training
https://kano.me/store/us/products/computer-kit
Been using repl.it and the "Python with Turtle" flavor this week and he's been having fun with it.
https://www.amazon.com/dp/B071YPZFZ4/
Bash is fairly expressive and gets you the basics of programming, and then you can easily use a more complex language fairly easily and have all the abstractions from bash that lets you build fairly useful programs without having to build complex UIs.
I know you mean well and I have nothing against bash, but I promise you it will not replicate that experience nor excite kids.
I am, below, trying to imagine what an argument could be for any specific example to be worse than the previous ones.
One could make an argument that when the level of abstractions eliminate Turing completeness, they have eliminated an essential quality. (But this does not even eliminate Swift playground, I think, so in this case it does not apply.)
Or one could make an argument about a lack of program interconnectedness, which, I am given to understand, is very much a problem in modern smartphone and tablet environments. But I could be out of date and/or misinformed. Nevertheless, it would be a reasonable argument (and I don’t know if it applies to Swift playground on an iPad or not).
Very constrained environments, like Minecraft, can also be argued against on practical grounds – it’s simply too difficult to make something useful within them. Not technically impossible, just too difficult once you get up a bit in abstraction levels. In my opinion, this argument also applies, sadly, to BASIC: The lack of functions and other methods of abstractions is, I think, a killer.
Or one could argue (which I think I personally favor doing) that software freedom for end users is an essential quality which must never be lost, for reasons which are only tangentially based on what is good for learning. It is almost special pleading, but has its own reasons for doing so, and the logic, on its own terms, is sound.
But none of these arguments are insurmountable by some theoretical device and environment which avoids any or all of these specific criticisms. Therefore, I think that any argument based solely on the age and abstraction level would not be valid.
BASIC (essentially any 3GL) never wore such a veil. To suggest discrete logic and IC-level assembly compares to issuing commands via the LEGO Mindstorms protocol perfectly illustrates the chasm between learning and understanding.
Yes. That is certainly a good argument against that specific example, and it is one I agree with. But it does not apply generally.
> To suggest discrete logic and IC-level assembly compares to issuing commands via the LEGO Mindstorms protocol perfectly illustrates the chasm between learning and understanding.
But learning and understanding what? Why is it (as I imply that your argument is) important to understand assembly-level instructions when it is not important to understand the underlying electronics? Why is this level special?
In addition to all the general arguments I outlined above, there is one additional argument to be made against assembly language: In today’s processors, I am given to understand that these assembly language instruction sets are largely a high-level language, emulated by microcode – the assembly instructions you write have very little to do with what the processor is actually doing in a modern hardware architecture, and therefore teach you exactly the wrong things about how a modern processor works.
There are some python shells around (the developer of one posts here) that might make for a better experience than bash though scripts though, either way they'll learn some real world tools.
http://github.com/antirez/load81.git
{{I like to pimp LOAD81 any chance I can get, because its simply a great idea from a rockstar programmer, and it could probably do with some eyeballs and patch requests from those interested in this particular subject .. it could easily, for example, become a next-gen PICO8 with a few tweaks (e.g., ipfs integration, lol...)}}
https://duckduckgo.com/?q=nodemcu+lua&atb=v119-3__&iax=video...