
Ask HN: Is there a modern “power on to basic” computer, for kids to learn on? - andrewstuart
I want to give some young kids a small cheap computer that &quot;switches on to basic&quot; or some other programming language?<p>Like in ye olde computer days when you brought home your Commodore 64 and turned it on you were in basic.<p>I&#x27;m guessing everyone will want to say &quot;Raspberry Pi&quot; of some form, but does that meet my requirement?  Plug it into TV, turn it on and you&#x27;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.
======
potta_coffee
The closest thing I've found to this is Pico-8: not a computer, a piece of
software, but it's very cool. It has a simple text editor for writing Lua
code, a simple sprite editor, and a simple sound editor, all for creating
games. It's a nice little sandbox for playing with code and creating things.

[https://www.lexaloffle.com/pico-8.php](https://www.lexaloffle.com/pico-8.php)

~~~
nicolashahn
I upvoted this but I need to reiterate my support.

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.

~~~
codebolt
You think you had it rough, at 15 I taught myself C/C++ Win32 programming with
COM and early DirectX versions from textbooks and online tutorials. I'm
thankful now though, as most modern frameworks are a breeze to learn by
comparison. Looking back it was a bit like learning to swim by jumping in the
deep end of the pool. It certainly gave me the confidence that I can figure
stuff out, even in a new domain. And it's given me some valuable lessons in
what makes a good vs bad API design.

~~~
andrepd
Mine was Pascal in Turbo Pascal (6?) for DOS, circa 2004. It speaks volumes to
the outstanding quality of Turbo Pascal and the Pascal language that it still
holds up, more than 20 years later.

~~~
matt_the_bass
I feel old. Mine was commador64 basic in 1988

~~~
wiz21c
I started with AppleSoft basic around 10 years old. It was fairly simple to
achieve "stuff". But if your dream was videogames (and when you're 10 years
old, well, you see :-)), then you ended up in front of the assembler/machine
code wall. And there your dreams vanished (or you were crazy enough to learn
by yourself and books).

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.

------
Kim_Bruning
Raspberry PI cab be said to be evolved from a ~ power-on-to-BASIC computer; to
wit: the (BBC) Acorn Archimedes. You can still get RISC OS for it even.
Basically, you power on; hit F12;

*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](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 ;-) )

~~~
simion314
>why not use pi + python?

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.

~~~
Kadin
Python seems like a nice update to what BASIC was in the 8-bit era. Real-time
interpreter so you get instant feedback, including very simple imperative
syntax. (IMO any introductory programming environment that doesn't let you do
something like 10 PRINT BUTTS <RET> 20 GOTO 10 <RET> and get BUTTS BUTTS
BUTTS... out of it is a failure to launch.)

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.

~~~
dTal
>MO any introductory programming environment that doesn't let you do something
like 10 PRINT BUTTS <RET> 20 GOTO 10 <RET> and get BUTTS BUTTS BUTTS... out of
it is a failure to launch.

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

    
    
      while true:
        print("BUTTS")
    

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.

------
JacobJans
This post reminds me of a running line of thought that's been going on in my
head for quite some time: "Single Purpose Devices."

The main disadvantage of most computing devices is that they offer too many
options; making them mentally unwieldy. A "single purpose device" is created
to support just one purpose. The Kindle is perhaps the most famous example; it
practically created an industry. Sure, it can do more than just present books,
but everything is designed to support reading.

Ideally, there would be a "computer", where every aspect of it was designed to
teach computer programming.

I often fantasize about a device designed solely for producing new writing. It
would have a nice screen, and a nice keyboard, but only a very very limited
web-browser, and would sync with Google Docs, Office, or something similar, so
that you can do the more advanced stuff elsewhere.

Such devices are about empowering the user to go down a specific path; one
they choose as soon as they start interacting with the device.

Kindle -> Reading

Typewriter -> Writing

Hammer -> Hitting things

"Power to Basic" -> Learning to program

~~~
excalibur
Dumb phone -> Talk and text, no camera, no browser, cheap and readily
available. Please?

~~~
drngdds
I really like the idea of ditching my smartphone for a dumbphone, but giving
up Google Maps would be rough. Knowing the fastest way to get from point A to
point B (including public transportation!) is genuinely really useful.

~~~
htor
do it and re-discover the art of getting lost!

~~~
jriot
And how to navigate a city on your own.

~~~
ryacko
I grew up in the intermediate period between widespread desktops and finally
getting a smartphone.

I just wrote down Google Maps directions and the general description of places
I needed to turn on a piece of paper.

------
Slimbo
Depending on their age, for young kids best results I've had are Pi's (or
old/cheap pc's) that boot straight into scratch. Far better results than an
intimidating command prompt.

[https://scratch.mit.edu/](https://scratch.mit.edu/)

Alternatively Pi's (or old/cheap pc's) that boot straight into Minecraft
Eduction Edition:

[https://education.minecraft.net](https://education.minecraft.net)

This has paths for the very young in minecraft itself to older kids using
ide's.

~~~
martin1b
I second this. My kids love scratch. It shows them event driven programming
with quick returns. The can also share their apps and download others so they
can download and modify.

~~~
d_runs_far
How old are the kids? Mine is just turning 5, and I've been looking at this as
an option, but as many have said, I don't want to feel like I'm 'forcing' the
tech learning on him.

~~~
Slimbo
Scratch is good from around age 8 to 14 or so, depending on their ability.
Most kids don't even know they're learning, scratch is really fun. Coder Dojo
has some great lessons, eg this one to make your own version of plants v
zombies:

[http://kata.coderdojo.com/wiki/Scratch_Plants_vs_Zombies](http://kata.coderdojo.com/wiki/Scratch_Plants_vs_Zombies)

------
blihp
For those of us who grew up in the 8-bit era, this has a lot of appeal since
that's how we got engaged. But for most kids today, is this sort of ab initio
approach really the right way to go about it? Based on my experience with a
few different types of kids/personalities, I'm skeptical.

Dropping them into the command line / IDE of any language / environment is
likely to leave them both unimpressed and lost. Neither the Raspberry Pi (more
software oriented) or Arduino (more hardware oriented) is going to be terribly
impressive from a standalone point of view compared to the PC/iPhone/XBox
they're used to. But the thing they've got going for them are a lot of cool
projects other people have done with them, step-by-step tutorials, and pre-
built stuff that's relatively easy to re-create and/or integrate. Will the
8-bit recreation you have in mind have any of that?

~~~
seanmcdirmid
Kids have it too easy today, they don't have to work very hard to get decent
computing experiences, and its not like they have to do any programming at all
to have fun. It is also super easy to get addicted to just consuming all the
time. It is quite depressing.

My kid is still a toddler, but I think I might put a stripped down CLI-only
computer in his room when he reaches 5 so he can at least play with it if he
wants. It doesn't need to count as dangerous screen time, there is no internet
to worry about, and he probably won't get addicted to a CLI at least. I mean,
the alternative to that is probably no computer in his room until he is 16.

~~~
anigbrowl
Kids like you had it way too easy. When I was young you had to solder your own
components together to make a calculator.

Kids like me had it way too easy. When they were young they had to look things
up in log tables and use slide rules.

Etc. back to hunting wild beasts and digging vegetables out of the frozen
ground

~~~
seanmcdirmid
I'm sure I would have found some charm in using punchcards, but I think being
6-7 when PCs just first starting coming out was kind of a magical time on the
threshhold, similar to when crystal radios started showing up in the 50s or
cars started becoming viable in the early 1900s.

------
KirinDave
Power-on-to-basic is gone in the world of more sophisticated hardware and
power management. But! You can always alter a homebuilt hardware to boot into
the next best thing: DrRacket. Just modify the init scripts to go right into
this: [https://racket-lang.org/](https://racket-lang.org/)

Grab a copy of "the little schemer" and let them go. And when they're through
that, then you can unlock the rest of the computer.

As for the hardware, I have recently been building this kit. It affords a very
small, humble laptop from the base parts up. You literally build it up. You
can re-open it pretty easily.

[https://www.olimex.com/Products/DIY-
Laptop/](https://www.olimex.com/Products/DIY-Laptop/)

~~~
peatmoss
There’s also Realm of Racket which uses games to teach.

------
alliecat
Hear me out here; Apple's Swift Playgrounds on an iPad.

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.

~~~
athenot
My kids don't have tablets but this would be the application that would make
me buy an iPad for them. Very close in spirit to the old LOGO, but with the
added bonus of laying the foundation using a real language—real as in
something used in our industry and with concepts that are easily transferable
to other languages.

~~~
nickthegreek
You can also put an ipad into an kiosk mode where they cannot exit an app
without a pin. This will help keep the ipad as a 'power on to code' system and
not let them drift into other apps.

------
modeless
TI graphing calculators boot to BASIC. I don't know about the newer ones but
the old ones are extremely simple computers with Z80 or 68k processors and
hardly any operating system, fun to program in BASIC or assembly language or
C.

Modern kids might find them boring but they are great places to learn how a
computer really works without piles of modern software cruft between you and
the hardware. That's where I learned.

~~~
craftsman
For those interested in hearing more about TI calculators and hacking on them,
this episode of the Embedded.fm podcast was really fun, and there are a couple
interesting links in the show notes:
[https://www.embedded.fm/episodes/259](https://www.embedded.fm/episodes/259).

------
tyingq
Duinomite: [https://www.olimex.com/Products/Duino/Duinomite/DUINOMITE-
MI...](https://www.olimex.com/Products/Duino/Duinomite/DUINOMITE-MINI/open-
source-hardware)

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...](https://www.olimex.com/Products/Duino/Duinomite/DUINOMITE-MEGA/open-
source-hardware)

~~~
dvfjsdhgfv
Duinomite is great, the only drawback of the VGA solution is the distortion on
modern high-resolution screens, i.e. if you use the CIRCLE command the result
is hardly a smooth circle.

------
kipchak
The Kano kits come to mind in spirit, Though it's more of a guided cushier
approach than just getting into basic. The basic idea is a Pi and it's
accessories that you "build yourself" and then some optional add ons like a
light grid display.

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://world.kano.me/coding-challenges/training)

[https://kano.me/store/us/products/computer-
kit](https://kano.me/store/us/products/computer-kit)

~~~
linsomniac
I really like the Kano, but my son was able to figure out how to get into
youtube with it and it's become a "all youtube all the time" environment.

Been using repl.it and the "Python with Turtle" flavor this week and he's been
having fun with it.

~~~
amasad
That's awesome. Repl.it ceo here. Check out our forum, there's lots of
material shared by kids like your son. Here is one tutorial on pixel art with
Turtle [https://repl.it/talk/challenge/How-to-draw-Pixel-Art-on-
Pyth...](https://repl.it/talk/challenge/How-to-draw-Pixel-Art-on-Python-with-
Turtle/7556)

~~~
linsomniac
Thanks! We will check that out tonight!

------
dasmoth
At a technical level, JSFiddle or equivalent comes kind-of close. Set up a
template with a nice big <canvas> element, then you've got a simple imperative
API to draw stuff which really does come pretty close to what you'd get from a
BASIC> prompt.

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...)

~~~
joeberon
In my opinion anything js-related is the furthest you can get from "power on
to BASIC". I can say that for me it feels less enjoyable to have to rely on an
external website (like jsfiddle), also requiring that you be able to write
(very) basic HTML and maybe even CSS. I agree that once it's set up it can be
very interactive, but it's non-trivial to get to that point

------
astrodust
In the old days you saved up an extraordinary amount of money, bought a
Commodore 64, plugged it in, and then had absolutely no idea what to do unless
you had books.

So you went and got books or magazines, some maybe from the library, some from
bookstores, and many of them might be for systems other than the C64. It
wasn't uncommon for a magazine to have to cater to a dozen slightly different
versions of BASIC: Apple ][, Atari, BBC Micro, PET, Sinclair, TI, Tandy,
VIC-20 and more. I remember finding all sorts of interesting programs in
magazines that weren't for the computer I had, so they were basically useless.

This was because a lot of BASIC code that did anything useful consisted of
PEEK/POKE calls to manipulate memory, and as the memory layout of each
computer was often completely different. Having a book about the Altair was of
no help when trying to program anything but an Altair.

Even if you did get a book that had the right code, for the right hardware,
typing it in was frustrating because the computer didn't ship with anything
that resembled an editor. You just typed in line numbers and statements and
hoped it all worked out. You could LIST your code, but unless you organized it
well, you'd get lost quickly. Anything over a hundred lines became an
unmaintainable mess of garbage.

So yeah, you could program, but you could only program in BASIC, and that
language is one of the absolute worst. There's been joke languages that are
more pleasant to use and more educational.

Today there's JavaScript and it works roughly the same everywhere, is
thoroughly documented for free, and there's places to ask about coding that
simply didn't exist when the C64 launched.

Going back is a mistake. Programming back then was a nightmare, it was an
awful, discouraging experience, and I wouldn't wish it on anyone.

Presumably a lot of the golden-hued nostalgia here comes from the fact that
you could _program_ a computer, something that at the time was a relative
impossibility for most people. That by typing in code you could make the
computer Do Things, which can be thrilling.

The thing is today you have things like Arduino, the Pi, and others, where you
can not only program them in sensible programming languages inside of
civilized build environments, but you can make them interact with hardware in
ways that really weren't possible on the C64.

For that sort of thrill, give someone a Feather board they can program with
Micropython.

~~~
bdamm
That's silly. Javascript requires all kinds of knowledge to get started; what
does this code mean, how do you hook it into a page, what is DOM, etc. That's
a lot to ask of a 10-yr old.

Meanwhile, any 10-yr old can understand this code:

    
    
      10 PRINT "Hey there Joe"
      20 GOTO 10
    

Boom. Functional program. Instant gratification. That will be the last program
this person ever writes that provides such instant reward, but nevermind, that
foundational idea that the computer can bend to your will is planted.

~~~
astrodust
I can teach someone how to make a button blink in JavaScript in ten minutes. I
don't have to explain what line numbers are. I only have to teach some very
rudimentary HTML.

From there they can absorb more knowledge and do really cool things.

That BASIC program is garbage and nobody cares. Seeing your name on a screen
doesn't carry the same thrill it did in 1985.

Show someone PONG today and they will wonder if you're playing a joke on them.
Show someone PONG IN 1972 and you'd blow their mind.

~~~
dvfjsdhgfv
You both have a point. When I showed a text-mode adventure to a kid, their
reaction was "Really? Why would anyone play such a thing these days?"

On the other hand, getting started with toy twoliners involving a question and
a simple arithmetic answer can spark some interest. The effect is augmented if
what you type can have an immediate effect on hardware like in the case of
Duinomite where the inerpreter is running on the MCU itself and doesn't need
uploading like on the Arduinos or Mindstorms.

~~~
astrodust
If you want to get kids engaged, Minecraft is the best learning environment
out there.

You can get a computer that runs Lua in the game, and that thing can interact
with devices and the environment.

You can write a couple of lines of code that spawns pigs. From there
anything's possible.

Subjecting someone to the ridiculously spartan environment that is the READY
prompt is the polar opposite of encouraging.

~~~
bdamm
Interesting... I had no idea Lua was in Minecraft.

~~~
astrodust
There's a number of mods for Minecraft that put Lua into the mix. One I was
using (ComputerCraft?) had all the common UNIX commands implemented as things
like ls.lua, so typing "ls" actually just ran a Lua script with the
corresponding name.

You really couldn't get a more hackable computer.

These instances can have 4-16MB of memory allocated to them which honestly is
way more than is necessary. They can make remote HTTP calls. With the right
server settings they can even adjust the in-game weather to match the real
world.

The possibilities are literally endless. A few lines of code can produce
immediate results, and you can iterate and expand on that to make elaborate
systems.

~~~
dvfjsdhgfv
Unfortunately ComputerCraft is no longer developed, even though you can still
use it on an older version of the game.

~~~
wilsonthewhale
OpenComputers is actively developed though, and arguably a more fleshed out
Lua mod than CC

------
mstevens
I found the CG Maximite lately, which powers on to BASIC and has composite
video or VGA out:

[http://geoffg.net/maximite.html](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](https://sites.google.com/site/libby8dev/fignition)

But does require assembly & soldering.

~~~
Koshkin
Colour Maximite is a lot of fun [1]! The BASIC environment it has is quite
powerful, and it even runs a full-screen text editor.

[1]
[https://www.youtube.com/watch?v=XQA8lowEKOo](https://www.youtube.com/watch?v=XQA8lowEKOo)

~~~
bartread
Beat me to it: I was going to post a link to the 8-Bit Guy's video as well.

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.

------
zimpenfish
> Plug it into TV, turn it on and you're in basic and can start programming.

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?)

~~~
jschwartzi
In Ubuntu you'd just use console 1-6 instead of console 7. Console 1 is
typically a terminal, while console 7 is typically a GUI. You could configure
getty to start a REPL as a shell instead of the normal login shell.

------
reificator
> _Like in ye olde computer days when you brought home your Commodore 64 and
> turned it on you were in basic._

Why not try, you know, a Commodore 64?

[https://thec64.com](https://thec64.com)

Hooks up via HDMI, powered by micro USB, and has two USB ports for keyboards
and joysticks.

No longer boots _straight_ into BASIC, but scroll to the right and hit enter
and you're there.

~~~
PyroLagus
There's also going to be the [http://mega65.org/](http://mega65.org/) which is
a spiritual successor to the C64. It's completely open source, even the FPGA
code implementing the 6502 (although the FPGA is most likely not going to be
open source), and it has better specs than the C64, but it should still be
compatible with the original C64 and its games from what I understand.

~~~
jasonm89
Any idea when the mega65 is going to be released?

------
thrower123
I'm sure you could setup a machine with FreeDOS and boot it right into QBasic
at startup. That'd probably be almost perfect; you'd have the relatively good
built-in interactive help files, and all the graphics and sound APIs to
actually do some cool stuff out of the chute.

~~~
petermcneeley
Ya this appeared on HN previously [http://www.nicolasbize.com/blog/30-years-
later-qbasic-is-sti...](http://www.nicolasbize.com/blog/30-years-later-qbasic-
is-still-the-best/)

------
ddebernardy
Couldn't an old (or a new?) HP graphic calculator do the job? It's not
technically basic, but you can do tons of stuff on it in addition to
arithmetics and function plotting - including programming games, etc.

Plus, it's organized as a LIFO stack. To do e.g. 2 * (2 + 2) you'd enter: 2,
2, 2, +, *. Which helps train the mind to think far ahead about what you want
to calculate and how.

~~~
AntonyGarand
This is known as the Reverse Polish Notation:
[https://en.wikipedia.org/wiki/Reverse_Polish_notation](https://en.wikipedia.org/wiki/Reverse_Polish_notation)

------
fusiongyro
I would suggest checking out the Micro:bit:

[https://www.microbit.org/](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.

~~~
dmlorenzetti
Micro:bit has a lot going for it.

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.

~~~
fusiongyro
You can also get Python onto it directly with uflash.

[https://pypi.org/project/uflash/](https://pypi.org/project/uflash/)

------
nicole_express
I'm curious why the 8-bit machines themselves aren't an option here; I'd
recommend the Commodore 128, as it was the newest of the Commodore machines
and had their most advanced BASIC (so you can actually do graphics stuff
without directly manipulating memory) Finding a working one might be a bit
more pricy these days than a Raspberry Pi, though.

Otherwise, I'd say the web is probably the closest thing; once you help them
over the initial hurdles of setting up a basic site with a simple JS program
that they can mess with, it's possible to do quite a lot, in an environment
most kids are going to be familiar with; configure a simple Linux environment
to open a web browser and a text editor on boot and there you go.

------
swiley
Just give them a computer running linux without going all the way to runlevel
5.

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.

~~~
normalhuman
I too grew up with a "power on to basic" computer, in my case the ZX Spectrum.
I don't think that people that did not have that experience at that age can
truly get it. I was able to create graphics and play sounds with a very simple
language. The text editor, the graphical display, the "OS", it was all the
same thing. The manual taught you how to program in BASIC. It was an amazing
tool of creativity and intellectual development. It was truly magical.

I know you mean well and I have nothing against bash, but I promise you it
will not replicate that experience nor excite kids.

~~~
teddyh
Your personal experience is not the only correct one. I assure you that the
people coming before you, making their own computers out of chips and
resistors with a soldering iron, would say the same thing about you. And
people who grew up with Windows 98 say the same thing about people only
exposed to iOS and Android, and so on.

~~~
itomato
They are all more justified than the person who claims Swift playground on an
iPad is the pinnacle of CS for Primary School.

~~~
teddyh
I understand, in a sense, what you mean (since I am of an earlier generation
than the one which learned programming on that particular platform), but why
should that necessarily be true? Hasn’t it always been the case that the
current generation skips learning about useless lower layers used by older
generations? How could it be that the layers _you_ grew up are the special
ones which are still useful, when all the layers which came before, which
people at the time thought essential, have turned out not to be so?

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.

~~~
itomato
Despite being an open language, Swift (and Playgrounds) is an effort to usher
children into the Apple tent.

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.

~~~
3rdAccount
Agreed. I'm a python beast, but really struggled with Assembly language in
school. I'd have been better off with a ZXSpectrum earlier in life so I
could've learned hardware. IMO high level languages (as insanely useful as
they are) are similar to writing spells like a wizard and using assembly or
even basic when you know all the registers...etc is more like a real science.
Both are valuable, but I really wish I knew more about hardware.

~~~
teddyh
Having a ZX Spectrum would in no way actually help you learn hardware. The
only thing it would do is to reinforce its _realness_ , so to speak, which
would help to motivate you to learn it. But it would not actually help you
learn it – the design and learning curve of assembly language is what it is,
and having access to running hardware (compared to having an emulator) does
not change that.

~~~
3rdAccount
It makes it easy to learn the hardware because it has a simple processor and
makes it dirt simple to access. Windows on the other hand runs on modern chips
and it isn't easy to run assembly without 3rd party software and graphics is
also not something a child can easily handle. I suppose a good emulator would
be similar, but emulation is a little bit of a lie :)

------
damianmontero
[https://googlecreativelab.github.io/coder/](https://googlecreativelab.github.io/coder/)
Google has a sd card that you put into a raspberry pi (everyone has one of
these hanging around, if not ask your friends for theirs) and with NO SETUP
just hooked up to the internet you can learn full web development, NO SETUP!

------
jaysonelliot
Personally, I'd just get them an Apple II.

They're still plentiful and cheap to find on eBay, and it's exactly what
you're looking for.

There are modern hardware upgrades you can find to use CF or SD cards in place
of floppies, so old media won't be an issue, as well as modern ways to connect
to an LCD screen, and even Ethernet cards if you want to go online.

And of course, the Apple II is supremely open and hackable, perfect for kids
who want to have access to the entire computer.

~~~
drivers99
I second that. I just set up an Apple IIgs last weekend and was making some
small Basic programs with my son. He was actually really into it, unlike in
the past when he was too young. He has had some exposure to Scratch so that
may have helped as well. We didn't have any way to load or save programs, so
I'll have to look into the cards you mentioned.

~~~
jaysonelliot
I have a CFFA3000 and an SDFloppy II. Both are great, but I prefer the
CFFA3000 and use it regularly.

CFFA3000:
[http://dreher.net/?s=projects/CFforAppleII&c=projects/CFforA...](http://dreher.net/?s=projects/CFforAppleII&c=projects/CFforAppleII/main.php)

SDFloppy II:
[http://www.a2heaven.com/webshop/index.php?rt=product/product...](http://www.a2heaven.com/webshop/index.php?rt=product/product&product_id=124)

Another good option, the Floppy Emu: [https://www.bigmessowires.com/floppy-
emu/](https://www.bigmessowires.com/floppy-emu/)

------
reubeniv
An actual commodore64 is still an option

[https://www.amazon.co.uk/Koch-
International-242390-THEC64-Mi...](https://www.amazon.co.uk/Koch-
International-242390-THEC64-Mini/dp/B0764BK6L1)

The mini boots straight to basic still I understand

Otherwise I'd recommend some free software and some tutorials, Udemy has a
very good C# Unity course for example that can often be found at ~$/£10

~~~
joeberon
This thing reviews terribly. I think it's more meant for nostalgia for the
older generation. Also the keyboard is just for show which is quite sad

~~~
jnurmine
I think it will help once they release the new firmware that lets you more
easily access disks stored on a USB stick. Doing LOAD "$",8,1 etc. is rather
tedious with the virtual keyboard.

Also, they have promised a bigger version with a fully functional keyboard.
That will be awesome once it's out. I'm waiting for it since it was actually
the thing that made me join their crowdfunding campaign.

------
jstewartmobile
You'd think that we'd have a modern version of such a thing, wouldn't you?

Closest 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...

------
mdhughes
While that's what I grew up with, too, it's probably too isolated anymore.

Find a cheap laptop or desktop, or a pi, install Python3, and make IDLE easy
to reach. For graphics, "import turtle" and later "import tkinter".

Grab any learning Python book. It's not that far from how we learned back in
the day.

------
amasad
When we're building Repl.it we think about this a lot and we think we're
building "power on to basic" for the cloud era.

Where the microcomputer in the mainframe era made computing more accessible,
we think Repl.it is the microcomputer to the mainframe's cloud.

In fact most of our users that use it as a platform, and not just a repl, are
kids.

Check out our hackernews-like forum where mostly teenager are sharing what
they're building:
[https://repl.it/talk?order=votes](https://repl.it/talk?order=votes)

------
dahart
I learned on power-on-to-basic computers in ye olde days... Atari 800, Apple
][, C64, IBM PCjr. I have tried to teach my kids programming exactly the same
way, I was looking for the same thing. I don’t think we can bring back ye olde
days. My kids are actually interested in programming, but they don’t have the
patience for command line anything. It was _my_ wish to teach them the same
way that I learned, but in retrospect, I don’t think it’s the best way for
them to learn. My oldest (14 years) has been a tech freak since he was 3 years
old, and he’s just starting to dig into text programming and command lines,
but he won’t work on it for more than a few minutes before he’s off to
YouTube. I was into that stuff by the time I was 10 and could do it for hours.
Tablets and smart phones and Nintendos and Netflix and Steam add up to an
environment where the choice to slow down and read console is too difficult
for young kids.

If teaching is the primary goal and a power-on-to-basic not necessarily
required, then there are so many great options for starting. Maybe too many.
There are literally dozens of fantastic suggestions in this thread. Mobile
tablets have a built-in TV and there are great apps for beginner coding. Some
of the “no code” game engines are excellent for the beginner.

I looked through all the suggestions and didn’t see this one yet: open your
browser devtools. You _always_ have a browser, and it comes with a JS REPL.
Chrome (for example) lets you save and evaluate snippets, and you can choose
easy stuff to start with using only console.log(). It can be very similar to
BASIC.

------
d99kris
While not a complete hardware/software solution, there are some simple "OS'es"
that boots directly into a BASIC interpreter, which should be possible to use
on any old x86 laptop.

OS64:
[https://github.com/xlar54/emudore64](https://github.com/xlar54/emudore64)

NopeOS: [https://github.com/d99kris/nopeos](https://github.com/d99kris/nopeos)

(Disclosure: I wrote - or rather glued together - NopeOS)

------
forinti
I recently found out about a Japanese computer called Ichigo Jam:
[https://ichigojam.net/index-en.html](https://ichigojam.net/index-en.html)

Seems to be something between a Micro:bit and a Raspberry Pi and has Basic
built in.

~~~
lioeters
The site seems to be down (403) - but I found some related pages:

IchigoJam BASIC on Raspberry Pi -
[https://ichigojam.github.io/RPi/](https://ichigojam.github.io/RPi/)

[https://ja.wikipedia.org/wiki/IchigoJam](https://ja.wikipedia.org/wiki/IchigoJam)

------
ryandrake
One other thing to add to this request is that the machine boots around as
quickly as the Commodore did. Modern PCs have clock speeds thousands of times
faster than the C64, and boot up 10-100x slower.

A sub-1-second “boot to BASIC” time should also be added to the requirements.

------
makz
Setup a raspberry pi to boot directly into pico-8 in full screen mode and you
are ready to go.

~~~
sneak
Bonus points: leave the pi/raspberry login there for when they get old enough
to google about VTs and figure out how to exit the matrix.

------
nurettin
I will tell you why whatever you find won't feel like the old C= 64 no matter
how good the properties are emulated.

It is the culture, and the music. You will never find an equivalent, so might
as well consider yourself lucky, move on and let the kids beat their keyboards
typing JavaScript into their browser in debug mode. If you want to give them
something they can program as soon as it boots up, just install any Linux on
any pc.

~~~
fit2rule
I'm seriously into retro-computing, having kept every computer I've ever owned
since the 70's ..

So I admit my bias in this, but I have to say it: those 8-bit machines are
still out there, can still provide endless utility, and are also integrating
quite nicely with the modern era. In my 48k Oric Atmos, I have an 8G SD card-
based filesystem. My CPC6128 has Internet access over the house wifi.

Old computers never die - their users do!

------
androidgirl
I definitely think Raspberry Pi is what you want.

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.

------
sparkie
Ludovic Courtes created a Boot-to-Guile image a few years ago, packaged using
Guix:

[https://lists.gnu.org/archive/html/guile-
user/2013-02/msg001...](https://lists.gnu.org/archive/html/guile-
user/2013-02/msg00131.html)

~~~
CodeArtisan
There also is Armpit Scheme that is targeting single board computers

[http://armpit.sourceforge.net/](http://armpit.sourceforge.net/)

------
masto
There is exactly this: [https://basicengine.org/](https://basicengine.org/)

The catch is that you have to build it yourself, and there is some surface
mount soldering. I put one together and found it to be an enjoyable project.

------
fit2rule
Disclaimer; I have raised my kids with my computer collection, which means
we've done all of the following and found great rewards:

Just get an old, retro, 8-bit computer to use to teach your kids computers.
Seriously.

Something like an Amstrad Spectrum +3. Or maybe a CPC6128. Or an Amiga -
although all of these machines can easily be used only as games-machines, the
documentation for creating software on them is a high-value read. My kids love
the +3 and the stack of 80's magazines with type-ins and machine-code
tutorials. These are awesome, still, 30 years later and with a few modern
accessories, are simply awesome systems - and they will still teach your kids
to program, and to manipulate computers, in ways beyond the reach of the
average consumer-bot. By way of an 8-bit machine, new students can learn all
the components of computing, and immediately apply it to
bigger/newer/contemporary things.

Of course you have to appreciate the aesthetic.

So another thing you can do is load up an old laptop with antirez' wonderful
LOAD81:

[http://github.com/antirez/load81.git](http://github.com/antirez/load81.git)

We have a Toshiba tough-book running puppy booting directly to LOAD81. This is
a modern version; and has the bonus of being a Linux-machine behind the
curtains, to boot. Another great avenue.

And then, if you can find it, you could do the cocktail thing and get a
PocketCHIP .. mine sits in the drawer, wrapped in its 3d-printed keyboard,
ticking away .. so I'm still using it. But its pretty much the 'pocket boot to
basic' ideal, since it comes with PICO8 already ready already.

(OpenPandora, DragonPyra: same deal; probably a fair bit more expensive
though...)

The key thing is: as long as there is a compiler on-board, you can 'boot your
kids to basic'. If you get results with a new-school retro-rig
(OricAtmos+Cumulus ForeveR!), or if you just re-purpose an old laptop with
auto-boot to load81, there are definitely options for this ethos ..

------
lcuff
Squeak, Alan Kay's environment for kids, evolved from Smalltalk, would be a
very hot prospect if I were in your shoes.

------
ynniv
"power on to genera" would be nice.

~~~
exikyut
One of these days somebody needs to find the email addresses of the people
that need emailing and make the effort to politely pester and track the
progress of opening Genera.

I'm interested enough but can't guarantee low enough email latency on my end
of staying in touch.

------
adroitboss
There is an app on the Nintendo 3DS called Petit Computer which is a basic
interpreter.(It might currently be called Smile Basic). There are tons of
tutorials and you can make simple applications to advanced games.

------
squarefoot
"Plug it into the TV" as a requirement would restrict the choice. Why not
something that can be programmed through a PC, fun enough to attract the kids
attention, with great instructional value, powerful enough to be used for
serious tasks (LCD+wifi+bluetooth+buttons+battery=IoT terminal) and cheap?

Take a look at this:

[https://www.hardkernel.com/main/products/prdt_info.php?g_cod...](https://www.hardkernel.com/main/products/prdt_info.php?g_code=G152875062626)

------
yetanotherfrank
I separate "power on to" and "BASIC". In my view, Python, is the language
closest to "BASIC done right," so I am interested in "power-on-to-Python".

In classic "power-on-to-BASIC," the BASIC interpreter was a single shell that
allows interactive instructions, OS commands, and editing (with line numbers).
Even to run a game, one needed to know and type at least one BASIC command.

Python's shortcoming here is that one cannot easily run Python programs from
inside the Python REPL. Check out this silly attempt at Python with line
numbers and a READY prompt...:
[https://github.com/frankseide/basicpython](https://github.com/frankseide/basicpython)

The big difference between a Python IDE and Scratch (and similar GUI-based
systems) is that Scratch is a top-down approach that start with high-level
objects/operations and gradually give access to more and more details. On the
other hand, the classic BASIC computers, and a Python system, are bottom-up.
Those would not allow self-written games to be flashy from the start, but on
the other hand kids would gain a much deeper understanding since they have to
build things up themselves.

------
mj_olnir
Has any here played LittleBigPlanet (specifically, the sequel)?

I'm young enough to learn boolean logic from that game, and went on to develop
a true love for programming.

------
tootie
What I bought for my kid and what is now taking over American schools is a
Chromebook. I got one for maybe $140 that has an 11" screen and is super light
and thin. Yes, it's a UI and yes they can surf the internet and play games.
There's plenty of parental controls. Mine uses it for fun, but also to work on
Scratch and use CodePen. I'm not sure teaching shell commands is actually very
beneficial.

------
fooblat
I would consider something like the BBC MicroBit[0] or Calliope Mini[1].
Similar to an Arduino but much more accessible for first time coders. And, as
many have mentioned, the Raspberry Pi series.

0\. [https://microbit.org/](https://microbit.org/)

1\. [https://calliope.cc/en](https://calliope.cc/en)

------
archi42
If it was my kid, I'd use any single board computer or an old laptop (pro:
integrated keyboard and screen, e.g. Dell D630), and install a Linux that
boots straight into QB64: [https://www.qb64.org/](https://www.qb64.org/)

I didn't test if it runs in pure Linux text mode, but if possible that's what
I'd use.

------
6keZbCECT2uB
xonsh from linux

A shell is an interactive programming environment (like basic) that is the
primary interface for communicating with the computer. (remember Commodore
BASIC was also how you used the computer)

Linux with auto-login directly into a shell with xonsh as default does exactly
this. Go directly into a shell from a PTTY or set up your desktop environment
to automatically launch a terminal.

------
banach
I would consider [https://www.nand2tetris.org/](https://www.nand2tetris.org/)
for a similar from-metal-to-application understanding of computing. It is a
ground-up course that covers the construction of a CPU using only a NAND
circuit, and ends with implementing Tetris on top of this computer.

------
crispytx
Retro/Vintage computing enthusiast here. I actually got into playing around
with old computers because I was interested in using a computer that simply
ran Microsoft BASIC for the operating system. Much simpler times! But yeah, I
don't think there is anything out there right now like what you're talking
about. I would suggest simply purchasing a retro computer if you want to teach
your kids the old school way. Python is a pretty good substitute for BASIC in
my opinion, the only problem is you have to teach object-oriented stuff if
your students want to make anything interesting with graphics. (I teach kids
to code btw, thus my interest in the topic)

EDIT: I forgot to mention FreeBASIC. With FreeBASIC you can do a lot of stuff
the old school way, including graphics. However, I haven't actually gotten
around to playing with FreeBASIC yet so I don't have a whole lot to say about
it.

~~~
thedaemon
Also QB64, which has been mentioned here. It's pretty backwards compatible
with QBasic, which is what I learned Basic with. It's cross compatible as
well.

------
a-saleh
At a previous team a colleague was a big proponent of BBC MicroBit [1], I have
seen it sell around 15-20$

You are expected to code in your browser, then download a binary and copy it
over to the little device that is recognized as a usb-drive. You have scratch-
like javascript ide [1] and a python ide [3]

I remember a presentation about the ways they used in a class of 8yo kids.
They were making simple games, managed to network them to create simple
pagers.

It is the most hardware thing you can get with the lowesr barier to entry,
i.m.o :)

[1] [https://microbit.org/resellers/](https://microbit.org/resellers/) [2]
[https://makecode.microbit.org/#](https://makecode.microbit.org/#) [3]
[https://python.microbit.org/v/1.1](https://python.microbit.org/v/1.1)

------
muxator
I learnt event-driven programming, OOP and GUI toolkits architecture studying
a "borrowed" Pascal Turbo Vision manual that nobody in my high school was
using.

Later on I wanted to mess around with VGA mode X and direct memory access, but
there was no internet at the time, and I had no books. So I just tried and
tried, until it eventually worked.

In a way, being limited to just a few sources of high quality information
forced the young me to learn how to study them in deep. This was helpful
because it gave the foundations and the method, and made it possible to
explore unknown fields without guidance.

Now that I wrote it down, I realized that this journey was so satisfying that
it continues, in other forms, to the present day.

I would not be surprised if the OP was moved by a similar desire to offer this
kind of experience to kids. If so, I definitely can understand why.

------
jaclaz
I guess you could put up _any_ old PC (or laptop) to run VICE[0], if you
automate the booting (you can use DOS or Linux as "base" OS) you will be
greeted by the:

“COMMODORE 64 BASIC V2”

[0] [http://vice-emu.sourceforge.net/](http://vice-emu.sourceforge.net/)

------
IcePic
There are quite a few "boot to basic" comments here, but one of the things I
think they are missing when suggestions like "you can just have rpi start
X,Y,Z at boot" or "use W,R,S in your browser" come is that when you have
something like ZX Spectrum or C64 it was a static platform for 5-10 (and now
upto 30) years, so there was no "oh, you can't DL jquery so your fancy
webthing broke" or "you'll get to your IDE soon but first java updates, apt
updates, chkdisk, fdisk, or something else that needs to pop up in your face",
and of course no other kinds of distractions like "bah, my game doesn't work,
lets zone out on youtube lolcats or play $random_FPS instead" to take up your
attention.

------
lupire
This seems overcomplicated, asking for setup that suits the parents' nostalgia
instead of useful and attractive to the modern child.

Just grab any handy compiter, open an interpreter window / shell console for
the language of your choice, and let the kid play and learn.

------
sneak
Yes, the Raspberry Pi supports this (via the smaller non-GUI “Raspbian lite”
SD image), with Bash, Python, and JavaScript. No GUI or browser or internet
connection required. Plug in TV and keyboard and fire up an editor.

(You will want to change the keyboard layout from uk to us first, but after
that it is smooth sailing.)

For daily use, you or your child may have to log in as pi/raspberry first, it
does not boot directly to a REPL, as there is an OS. But immediately after
typing a username and password you are in a bash REPL that is fully
programmable.

If you then type ‘node’ or ‘python’ you get the same thing.

TBH I would have preferred a bash shell with readline and an editor to appleII
BASIC when growing up.

------
0xdeadbeefbabe
BASIC is more readable than forth, but forth is good for things too. What
about an hp48 or
[http://amforth.sourceforge.net/](http://amforth.sourceforge.net/) on some
atmega device?

------
matt-daemon
I saw some links to JSFiddle, but here's one that's maybe a little better
(software-wise): Khan Academy [0]. It uses JavaScript, and they've added
ProcessingJS wrappers so you don't have to use raw canvas API. They also have
instructional videos and other content. It's also gamified. [1]

[0] [https://www.khanacademy.org/computer-
programming/new/pjs](https://www.khanacademy.org/computer-programming/new/pjs)

[1]
[https://www.khanacademy.org/computing](https://www.khanacademy.org/computing)

------
andrewstuart
There's quite some distance between unboxing a Raspberry Pi and getting basic
on a screen versus unboxing a BBC/Acorn to basic on the screen.

I'd like it if there was a genuine retro computer remake like a C64 or really
any of those old machines.

When I say genuine I mean not an FPGA thing that looks the same and has the
same feel but inside is a modern FPGA.

I mean a computer with a real 6502 or Z80, "power on to basic" plus a real
keyboard.

There's so much old great books and educational materials for those old
machines too.

The problem with modern retro remakes is that they focus on being about games
and ROMs and I can't think of any with a nice keyboard.

------
anttipoi
DrRacket? ([https://racket-lang.org](https://racket-lang.org))

That is what I gave my mom when she asked what she could try programming on.
It features a simple whole window editor/repl where you can get straight into
business.

What failed was the supporting literature. I thought Realm of Racket would
have been ideal for self-study but it did assume more background than she
had...

[https://www.amazon.com/Realm-Racket-Learn-Program-
Game/dp/15...](https://www.amazon.com/Realm-Racket-Learn-Program-
Game/dp/1593274912)

------
danilocesar
When I was a kid there was a program called "MultimediaFusion".

It was a drag'n'drop with some pre-defined elements and included a visual
logical editor to define how objects behave (if then do that). I used a lot, I
had no one to help with instructions, no internet, i didn't even know english
at that time but I was able to write some games (bricks/arcanoid clone, space
invaders clone, etc).

I believe something like that would be a good way to teach pretty basic
programming logic (no complex code).

But this was almost 20 years ago... I'm pretty sure there's something better
(and OSS) today.

------
krick
> everyone will want to say "Raspberry Pi" of some form, but does that meet my
> requirement?

Uhm, yeah, I'd say it does. Autorun ipython on startup, either no graphical
shell or very restricted WM and you are done.

------
tmaly
The new Scratch 3.0 that is in beta is all web based.

You could use a tablet or Chromebook to get the child started right away if
specialized hardware was not a requirement.

I have been teaching my 5 year old programming with it.

------
city41
Another option, a modern Commodore 64. For example the C64 Mini has BASIC:
[https://thec64.com/basic/](https://thec64.com/basic/)

It doesn't boot directly to BASIC, but I do believe that is achievable with
other modern C64s, like the C64 DTV:
[https://en.wikipedia.org/wiki/C64_Direct-to-
TV](https://en.wikipedia.org/wiki/C64_Direct-to-TV)

------
pxi
I've been maintaining an obscure version of BASIC called "SmallBASIC" for a
few too many years. It started out as a calculator for the PalmPilot (by
another developer). You can build it on a raspberry machine or there's an out
of date binary you could try.
[https://smallbasic.github.io](https://smallbasic.github.io)

------
crooked-v
There's always 'web browser and Javascript'. Start with document.write, ease
into more complicated input/output methods.

------
progval
Despite being 25yo, this is how I started programming too. My "computer" was a
TI-80 calculator I had laying around. It can be programmed in a simple variant
Basic: 26 variables, 6 arrays, but also plotting capabilities.

You can probably still find such a calculator, like the TI-82 family which is
being revived. Just avoid the TI-Nspire which looks fancy but is hard to
program.

------
sea-shore
I missed the c64 etc. but.. Any smartphone or laptop can do this and more,
even within a browser. What might be the real question is what do we need to
limit for new users to reach that state of boredom needed to explore and
create, instead of getting stuck in The feed.

Perhaps disable the network or pointing device?

(Dedicated hardware per task, even for myself, is slowly winning me over)

------
onlyrealcuzzo
I'm testing a business right now for fun family learning activities. The
original offering is an arts-and-craft type product.

But if it works out, one of the products I want to test is something computing
related. The general idea is a digital escape room. But this thread has been
super inspiring and led me to a lot of great resources, so thanks for bringing
it up [=

------
dmitripopov
Pi plus boot-on MSX emulator (or Commodore C64 or ZX Spectrum). Also there are
a lot of functioning retro-comps on online auctions.

------
jdck1326
When I was about nine I used something called misoft basic! on ios. Not
exactly what you're asking for but it did the job.

------
skjdflsiugf
please dear lord not BASIC! Those of us who learned to code on 8-bit micros
back in the day never used BASIC anyway & ended up writing everything in
machine code.

You could use an emulator: the Jupiter Ace for example, which ran Forth (quite
a good first language to learn)

I'd suggest Wolfram langauge on the Raspberry Pi, or Squeak Smalltalk

------
ziaddotcom
I think the color maximite is this
[http://geoffg.net/maximite.html](http://geoffg.net/maximite.html)
[https://www.youtube.com/watch?v=XQA8lowEKOo](https://www.youtube.com/watch?v=XQA8lowEKOo)

------
yellowapple
This is almost exactly what TempleOS was/is billed to do; you'd need to
provide the hardware, but once you've installed it, you end up with a machine
that boots into a REPL/shell using the same language (HolyC) used to write the
whole OS itself (and all the applications thereof).

------
abijithk
If the idea is to teach kids the constructs to coding then we are trying to
achieve it through our products at -
[https://www.makewonder.com](https://www.makewonder.com)

Its the first robot that was designed to teach coding to kids. It requires a
robot and a tablet.

------
vgoh1
I think that the Arduino is worth mentioning, even though it fails the "power
on to basic" need of the OP. Once setup, it is fairly easy to compile and
upload to the board, and there is a lot that you can do with it, if they are
not to into making thier own video games.

------
cjdell
When I was running kids workshops I created this site so kids could write
scripts (accessible by pressing ESC) to manipulate a Minecraft-style and using
it they could even build their own games:

[http://webblocks.uk/](http://webblocks.uk/)

------
3rdAccount
ZXSpectrum Next is exactly this. An old ZXSpectrum computer that is newly made
with more RAM and in a much better package. Complete with lots of games you
can get. I think they're always out though....not sure if we'll ever see more
:(

------
Jun8
There you go, I just saw this on Hackaday:
[https://hackaday.io/project/2428-single-chip-avr-basic-
compu...](https://hackaday.io/project/2428-single-chip-avr-basic-computer-v03)

------
tlrobinson

        sudo apt-get install nodejs
        echo "/usr/bin/node" | sudo tee -a /etc/shells
        chsh -s /usr/bin/node
    

Replace node with your favorite programming language :)

------
leo_song
BASIC and any other toy platform are a bad ways of starting programming and
primary school kids do speak in assembly code. Throw some microcontrollers,
LEDs and motors to them, they will be happy. Boards like Arduino may be a good
option.

------
tomc1985
If it boots to a bash prompt, you can program that :P

Actually, I wonder if kids could learn shell script?

~~~
Jach
This was going to be my suggestion. You could also make sure some sort of
curses library is installed, e.g.
[https://bashsimplecurses.readthedocs.io/en/latest/](https://bashsimplecurses.readthedocs.io/en/latest/)

But really the question is misguided. Kids need to want to do something with a
computer, and in order to do that they will learn shell script, basic,
javascript, asm typed from magazines, whatever, to get it done. The
environment itself is instrumental, not terminal.

------
lukego
I’m starting my kids on electronics. LEDs, buttons, breadboards. A bit of
soldering. Soon transistors. Reminds me of my “BASIC in the 80s” childhood
even though it’s circuits rather than programs.

Kits cost about $2.50 on Aliexpress.

------
ChuckMcM
Working on it... :-)

But not that I've seen. Some come closer than others.

The current suggestion is a Raspberry Pi type system that is manipulated into
booting into a BASIC or some other development environment.

The closet thing right now is a micropython board.

------
davidandgoliath
My kids are enjoying working through the kano. It's a raspberry-pi with a
linux distro attached to it, lots of coding opportunities.

A bit too graphical for my tastes, and lots of distractions — but, lots of
learning.

------
nobody271
Why not a Raspberry Pi? Boot into bash and you have what you wanted. 3D print
some cases (or buy them) and pick up some cheap monitors. The whole setup
would be maybe $50 per computer.

~~~
sneak
I am not affiliated with them in any way, but I adore this high quality $15
metal rPI case and bought like 8 of them in red and blue:

[https://www.amazon.com/dp/B071YPZFZ4/](https://www.amazon.com/dp/B071YPZFZ4/)

------
cm2187
What about python for minecraft? I am not sure how accessible it is but I can
see how it would appeal to kids, and they would learn a language that they can
apply to other things.

------
DanBC
I don't know what the status of Maximite is:
[http://geoffg.net/maximite.html](http://geoffg.net/maximite.html)

------
cozzyd
You could try adding init=/usr/bin/ipython to your kernel command line, but I
bet that won't end well (way too lazy to try this).

------
xena
I wish TempleOS was in more of a state to be usable by kids and the like, but
it is about the gold standard for this kind of stuff I feel.

~~~
astrodust
Yeah, no. It's an interesting art project, but it's completely ill-suited to
be a learning tool.

~~~
yuhong
I wonder if HolyC has been ported to other platforms.

~~~
astrodust
Please don't.

------
andrewguy9
The browser console

------
davegardnerisme
Power on to BASIC! I’m going to try it out with my kids.

[https://basicengine.org](https://basicengine.org)

------
justaaron
microcontrollers... arduino seems to be a popular smoothed-over
platform/IDE/ecosystem that's friendly to beginners.

The actual C++ is largely hidden and one deals with statements inside one of a
few preset event handlers in an event-loop...

------
modzu
serious question: if you're looking for a commodore 64 why not use a commodore
64?

------
agumonkey
power on to lua: nodemcu

[https://duckduckgo.com/?q=nodemcu+lua&atb=v119-3__&iax=video...](https://duckduckgo.com/?q=nodemcu+lua&atb=v119-3__&iax=videos&ia=videos)

------
ikeboy
I learned on a TI calculator

------
sigjuice
Dijkstra’s blog post from 1975 is somewhat relevant :p
[https://www.cs.utexas.edu/users/EWD/ewd04xx/EWD498.PDF](https://www.cs.utexas.edu/users/EWD/ewd04xx/EWD498.PDF)

------
mhh__
Could you buy a BBC Micro? Pricey probably, but great heirloom too

------
joaofiliperocha
Sinclair ZX Spectrum was a greate machine to learn Programming

------
exikyut
I want to give real-world advice as opposed to some of the more theoretical
suggestions (the mention iPads doesn't quite line up with "small cheap
computer").

A lot depends on unspecified contextual factors, so I'll just throw a couple
ideas at you.

If you have a cache of sub-GHz hardware already lying around, I would
recommend Win98 and QuickBASIC 4.5. The ability to hit F5 and immediately get
output is excellent for reinforcement learning, and being able to CTRL+Break
out of unruly mistakes gone rogue great as well.

After a few months (or only weeks?) of QuickBASIC I would move up to Visual
Basic.

To be entirely honest, I stumbled on VB 1.0 while browsing at a library many
years ago, threw added it to my CD to take home "for the lulz"... and ended up
writing a ton of things in it. I found 2.x-5.x's UI to be unnecessarily full
of things I didn't want to know about at the time. It _is_ very Spartan; this
may appeal for a very short time.

After the novelty of drawing up terrible UIs has worn off, throw them a
curveball in the form of VB 6. They'll have the fascination to chow through
the additional UI complexity, and VB 6 occupies the sweet spot of being the
last in the pre-.NET series and a good preparation for Visual Studio...

...which will need to be introduced at some point, presumably along with an OS
switcharoo from Win98 to Win10. My recommendations for such archaic platforms
are not without due consideration; the "total mental model surface area" of
Win98+DOS is orders of magnitude smaller as Win10, which may provide a
friendlier learning environment than "hi you can play in the rocket capsule
but don't do anything that affects the engines underneath or you'll blow us
all up and I'll be really mad." The very opposite will be true since it's a
"toy" environment, so the kids would be free to kill everything as many times
as they wanted/needed (within the limits of your patience ;)), and this will
fuel the inspiration to discipline their interest in discovery and learning
into something usable.

A microcontroller-based environment does provide _some_ of the kinds of bare-
metal experience that using QB on an old PC does, but only if you completely
ignore tooling and infrastructure. Unfortunately I have insufficient
(...any...) experience so can only really comment on the difficulty of this
aspect.

The above reflects (part of) my own history (I unfortunately skipped the bit
about VB6, which was why I had so many things in VB1.0. I only ended up
learning how I'd even go about finding a copy long after the window it would
have been useful had passed, so perhaps I'm a bit biased about it.)

The one thing I'm trying to consider, though, is the thing about total surface
area, for want of a better phrase - I can remember struggling to figure out
JavaScript using IE 5.5 because I didn't know anything else even existed at
the time (in 2003, no internet) and perceiving the existence of and hating the
browser sandbox. The devtools REPL makes things so different nowadays but it's
undeniable that a browser is a gigantic pseudo-operating system on top of
another operating system and most problematically this is viscerally
perceptible; it's not seamless at all. There's no sense of true freedom, that
you're pushing what you're controlling to its limits. (Incidentally speaking,
this has some interesting parallels with the Web's recent transformation into
the media format of the day, its adoption of DRM, etc.)

The same is true to some extent with QuickBASIC, and this is why I would
recommend using it for a maximum of 6 months, but only allowing someone to use
it for that long if they had learning difficulties. I personally believe that
my own development was severely impaired by the fact that I had nothing else
available when I was younger. I'm only just breaking even in terms of having a
mind able to make use of CS first principles, but in all fairness this is
predominantly due to my autism and not entirely QuickBASIC's fault ;)

A short, engaging path straight to assembly language might be a good idea. I'm
still yet to wrap my head around this particular subject, nearly 20 years on,
because I'm still un-learning the very complacent computer science models I
unfortunately ingrained when I was very young.

------
etaioinshrdlu
Get them Mathematica.

~~~
3rdAccount
There's a lot of cool stuff you can do with Mathematica and it is available
for free on Pi, but some people will take offense at closed source proprietary
software and for good reason. Some things in the Wolfram language are so
amazing though. Stephen Wolfram has commented on how bad highschool CS
education is. Learning hello world and some Java or JS is great, but being
able to seamlessly use the thousands of functions in Mathematica is really
neat. For example, things like Conway's Game of Life, other automata, sound
processing, image processing, neural networks...etc are all built in and
composable primitives. The big downside is you're really just learning their
tech stack and you often use a declarative approach, so they may miss out on
imperative concepts (for loops are a code smell in wolfram language).

------
gaius
Why not use an actual Commodore 64? I’m serious, get one for a song on eBay
and a SCART adaptor and you’re in business. There are ample books around, they
will be cheap too.

~~~
PeanutNore
I have a Commodore 64 and due to its age it's a rather temperamental piece of
equipment, and the 1541 disk drive even more so. I'm planning to replace all
of the electrolytic capacitors in it which should help a lot, but that's
probably beyond the abilities of most people.

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.

~~~
leoc
You could buy a reburbished C64 or (better) C128, and use a SD2IEC
[https://www.thefuturewas8bit.com/shop/commodore/sd2iec-c.htm...](https://www.thefuturewas8bit.com/shop/commodore/sd2iec-c.html)
for storage.

------
s73v3r_
I mean, you have to click an icon to open Scratch, but other than that, the
Raspberry Pi is what you want.

------
gowld
What's the point? "Power on to BASIC" is running an app on an old small OS.
What's wrong with running any programming environment app fullscreen on a
modern computer?

~~~
ziaddotcom
Nothing wrong with it. However, I think an 8 year old seeing a 30 year old
computer turn on instantly to the same thing a supposed "better computer"
takes 10 minutes to boot to might surprise and teach them something.

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?"

~~~
lupire
It's more like "Why not let the child put stuff on the bottom shelf of the
fridge instead of buying them their own kid-fridge?"

------
bsenftner
"Back in the day" the BASIC language made sense, as it was right at your
prompt in text based interfaces. The same situation today is the web browser,
and the ability to open up the developer's console and getting direct access
to a web site's JavaScript, html & CSS. Forget BASIC, and introduce your kids
to web developing. They will "get it" much faster than <kid's voice here>
"boring dumb BASIC, can't do web stuff, it sucks."

~~~
TallGuyShort
Some basic scripting is probably still a good starting place for younger kids
to wrap their minds around syntax, basic constructs, etc. Dropping them in the
DOM right away is probably in the deep end, too much, although I'd agree
getting them there quickly opens a lot of fun and practical doors faster than
almost anything else.

edit: Second the suggestion of Python below, even if it's just for a few
months to learn the basics of coding in general. Pivoting a few months in to a
new environment is also hard in and of itself, but that's the path I'd go. As
a little bonus, then you don't get too stuck in one way of thinking :)

~~~
bsenftner
You under estimate kids. You all are under estimating them. 10 year olds
figure out how to modify mods written in C++ for games they love. Given
interest, they will get it. And the web is what has their interest today.

~~~
TallGuyShort
No I'm thinking for like 7-8 year olds. I was doing C++ at age 11, but it was
substantially easier because already had a few years of Pascal under my belt.

