The BASIC Engine is a very low-cost single-board home computer with advanced 2D color graphics and sound capabilities, roughly comparable to late-1980s or early-1990s computers and video game consoles. It can be built at home without special skills or tools and using readily available components for under 10 Euros in parts, or mass-produced for even less.
What a fascinating little device, and a great idea to boot – BASIC is a great programming language to use as first steps into programming.
How hard would it be to port Comal to this machine?
Honestly, BASIC was a poor choice.
I’m thinking right now about what’d be involved in creating an INTERCAL Machine…
Python would be the natural choice nowadays. But I guess it is more resource demanding.
Was a joke
But yeah I suppose Python would make sense. Or one of a number of similar languages.
Or even JS maybe?
embedded python ? might be an excuse to get my Ice40 board out again…
why not just install any emulator on an Raspi?
Ok, an minimal Raspi setup cost more then 50Euro, but you can run many more different systems …
Apart from this: Nice project 😉
Because this project has nothing to do with emulation.
“It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration.”
(Edsger W. Dijkstra)
I wanted to write “bollocks” and leave it at that, but I will elaborate instead, so let me start with an analogy.
Writing is not about language because even if you had a full dictionary in your head and you were capable of picking up the right word for any circumstance, that wouldn’t necessarily make you a great writer: sure, you’d be correct all the time, even impressive, but maybe you’d be just boring because you wouldn’t have anything to say or, at the very least, you wouldn’t know how to tell a story.
Of course some languages are better suited for certain tasks, but programming is not really about any specific language, because algorithms and data structures are far more important: either you can think about a problem, organize it in your head and come up with a solution for it, or you can’t; and no language can change that.
RT.
Language forms the way you think. (For both programming languages and natural languages.)
Sapir-Whorf loves this
It has loads, calculations, stores, tests, and branches (both conditional & unconditional) with optional linking. That’s enough to simulate any Turing-complete CPU, or any other Turing-complete language. Just like VintageBASIC is implemented in Haskell, but it could equally be implemented in Emacs LISP or Rust or Forth.
The only historical shortcoming of BASIC has been the hardware implementations: I doubt one could simulate the complete SPARC ISA in BASIC on a TRS-80 Model III, or a Commodore 64, due to memory limitations. I don’t know if that’s enough space to hold the tokenized BASIC needed for such a simulation. But in a 32-bit address space, 4 gigs minus the 16K needed for BIOS + BASIC interpreter, I’m sure it could be done.
FWIW: the source code for p2c, the GNU Pascal-to-C translator, includes a Pascal implementation of interactive BASIC. It uses line numbers, instead of the named procedures and functions associated with “structured programming”. The line numbers themselves are translated into C long values, so they’re at least 32 bits in Linux. That’s a hella lot of lines of BASIC.
And then there’s this bit: where C and Pascal use semicolons and block delimiters, BASIC allows colons to separate statements on a single source line. This permits close grouping of related statements, on one or more consecutive source lines. The human-readable delimiters are REM statements, i.e. comments in the code.
Given enough space, every Turing machine becomes VHDL, and vice-versa.
To be TC is a pretty low bar for a language to pass to be a good introductory language, don’t you think?
Not really. If a language isn’t TC, it’s domain-specific. The underpinning concepts of Turing-completeness (would that be tao?) are present in BASIC, equally with any other TC programming language.
My first glimpse into TC came in 2005, when I told my boss (EE master’s degree from UCSD) that a number is only a number, but its meaning is derived from its context. A CPU instruction? An ASCII character? A floating-point exponent? A reference to a RAM page ejected into swap space? An entire computing sequence (a lambda function)? Or, in this comment thread, is it a BASIC token, or a BASIC source line number?
Four years later, I found “An Explanation of Computation Theory for Lawyers” on Groklaw(*), which introduced me to the Church-Turing thesis and Gödel numbers. Unique numbers have unique meanings in well-defined contexts.
That was 2009. Eight years later (last autumn), I finally decided to read Turing’s “On Computable Numbers” paper from 1936. Even though the notations and symbols can slow down the reader, I finally grasped the low-level mathematical theory under every computing machine, everywhere.
Lisp can implement Forth can implement BASIC can implement Z80 can implement CP/M can implement any language you want, compiled or interpreted, as appropriate.
Please understand, in matters of computing theory, I’m completely self-taught. But I don’t just believe, I know that BASIC is Turing-complete. It can implement a universal Turing machine well enough to simulate any other Turing-complete system.
(*)http://www.groklaw.net/articlebasic.php?story=20091111151305785
BASICs are TC. No doubt. But it’s just an necessary requirement, but by far not enough to make them goosld languages (for education as well for solving real world problems).
Brainfuck is TC. Would you use it for teaching beginners? Even Conways Life is TC. List of TC stuff is quite long. Vast majority (I am stretching the term a bit because the list is infinite 😉 ) of it is crap.
(Just a small note – lots of domain specific languages are TC, it’s for example a pretty common internal DSL approach)
Aye, I was somewhat damaged by C64 BASIC.
Luckily I forgot almost all of it, and by the time of highschool I was pretty good with Logo. 
Bwahahaha
Thx for the laugh.
I’d like to add, Amstrad CPC 664 had a very nice BASIC as well, despite missing the awesome sprites of the C64 (but then Amstrad had steam roller resistant floppies).
Hm, I didn’t know I was being funny…
Hi,
Back when Dijkstra said this, BASIC was relatively horrible – there were no labels (you’d use line numbers, like “gosub 12345”), there were no do/while/until loops (just “for”) and several other modern features were also missing.
All of that got added to BASIC decades ago.
Despite this; all programming languages share the same fundamental concepts. Things like breaking larger things into smaller pieces, variables, expressions, conditional statements, loops, etc. You can learn these concepts in any language and they’ll be the same (just with different syntax) in any other language.
It’s only “optional concepts” where the language matters – to learn pointers you need a language that supports pointers, to learn exceptions you need a language that supports exceptions, etc. There isn’t one language that supports all “optional concepts” (although C++ is close) and if there was it’d be a hideously unusable mess of conflicting features (C++ is close).
– Brendan
Well, I’m not afraid to say “bollocks”
I began learning to write code in Sinclair BASIC on the Spectrum (and assembler) and then moved on up through Pascal to C,DBaseIV, Java and Python without any problems.
The essential elements for coding exist in any TC language and you can write good code or bad code.
BASIC doesn’t come with much in the way of functions, so you just write your own library of functions. You can write BASIC in a good, structured way or as an unstructured mess.
You can write BASIC in an OO way, which is quick and efficient or you can write a tangle.
What you learn automatically (after quite a short time) is to write non-redundant, structured code because it looks better, it runs better and it is easier to debug.
And there you are, writing neat code, the habits of which transfer themselves to newer languages.
If I’d had had to start coding in C I’d probably have given up before I could get it to do something useful, whereas with BASIC I had knocked together a simple database, complete with sanity checks and all in a couple of weeks of spare time.
A GREAT language? No. A good language for beginners? Yes.
Mac
OO in the early Basics? Even structured programming is essentially impossible – as they aren’t structured at all. Remember the quote is from 1975!
Again every variable were global, there were no dynamic memory allocation except for strings (and that wasn’t featured in all Basic versions). There were no subroutines, only non-descriptive variable names and a fixed number of data types (often floating point numbers or strings only).
There were no structures so every data structure would have to be mapped to the one that was provided: arrays, and of course there were no pointers.
Initialization of arrays had to be done “manually” by having a lot of DATA statements filled with a for loop.
Having been forced to use an early unstructured Basic for non-trivial tasks it isn’t easy. It requires discipline and a lot of notes. Not notes inline with the code – God forbid – as REM statements are interpreted in most Basic versions adding both to space and execution time.
But the result is still very limited and far from structured let alone object oriented!
Not “early” early but BBC Basic was pretty good; it had actual functions (and possibly also named labels? I forget)
Yes I’ve heard people having that as an example of a good early Basics, the one in the Enterprise 64/128 is also nice. But those aren’t the type of BASICs the Dijkstra quote was targeting, it was the likes of the Wang 2200 one.
Again cargo cult phenomenon instead of understanding: some BASICs/Basics are actually nice.
(I still prefer Forth!)
My favorite was Color BASIC on a TRS-80 Model III.
The computer was already 10 years old when I got it in the early 90’s, and it came with absolutely no software, but it had a Color BASIC manual and that was enough to get me hooked. I spent hours reading that manual and writing programs.
Transitioning to structured programming languages was a bit awkward at first, but it wasn’t that bad.
I never encountered that quote– probably just as well, because it’s such a narrow-minded myopic view that it may constitute one of the earliest examples of trolling within the computer industry.
I can only conclude he was a lousy teacher, in addition to being an egomaniac (after reading his other quotes).
BASIC is a terrible choice for a basic programming training.
Not at all. It’s a very good choice to teach the basic concepts (no pun intended).
No. You should not teach something like it. The poor student will not learn basic concepts. She will learn stuff that is hard to unlearn.
That is a load of rubbish. People should stop recommending how new programmers should approach programming simply based on their own horror experiences.
BASIC is definitely a serviceable language for beginners. Learning a language isn’t about learning something that you use exclusively. It’s about learning how to deal with problems along the way.
The only “poor student” is the one who gives up after a few missteps. A “poor student” who would fail with BASIC would fail with Haskell or LISP or Python or Rust or Ada or C++. And unlearning stuff is an irreplaceable part of the learning process. Stop trying to coddle programmers from having to unlearn things. Embrace it.
Almost any language is a good place to start. All of the pioneers of programming didn’t start out with a perfect language. They freakin’ used assembly for a specific machine. Or fortranalgol.
“People should stop recommending how new programmers should approach programming simply based on their own horror experiences.”
Maybe just ask somebody competent? Such as teachers and mentors at youth programming contests etc.?
“BASIC is definitely a serviceable language for beginners.”
For the definition of serviceable = ‘you live in pain and learn things that you are forced to unlearn later. But you will survive and can learn something useful later.’
“The only “poor student” is the one who gives up after a few missteps.”
That is no reason to teach programming the wrong way.
“And unlearning stuff is an irreplaceable part of the learning process.”
In a reasonable amount. To fill the brain with useless crap is not a good idea.
“. A “poor student” who would fail with BASIC would fail with Haskell or LISP or Python or Rust or Ada or C++.”
The problem is, what happens if he succeeds with BASIC.
“Almost any language is a good place to start.”
No. You don’t learn driving by forcing the person into a muscle car at mountain road. You don’t learn self-defence by putting knives to kids hands. You don’t give a child Sonnets as a first book to learn reading.
“All of the pioneers of programming didn’t start out with a perfect language.”
And then they come with something better. And we don’t want to teach 0.01% of geniuses – they would survive anything. And “about average” student has needs that are not fulfilled by BASIC.
“Those who can, do; those who can’t, teach.” — George Bernard Shaw, Man and Superman.
However, to be completely fair, Shaw had been probably inspired by Aristotele’s “Those who know, do. Those that understand, teach.”
I confess that I prefer Shaw’s version, which I usually expand with: “Or become managers!” (think Dilbert’s Pointy-haired Boss)
RT.
To do something and to teach something are quite different qualifications, no doubt about it.
But “don’t teach BASIC, don’t use BASIC” is probably something both groups (programmers and teachers/mentors…) can easily agree. (With some exceptions, as always.)
Again, says the person who recommended Haskell. Haskell doesn’t fulfill any beginner’s need to see something working. No beginner programmer cares about theoretical OCD concerns.
” No language has no pain. ”
” All languages have things you have to unlearn later. ”
This is mainly about amount of such things. No product/person/place/whatewer is perfect. But there are generally good products, there are products suitable for some specific situations and there is terrible crap nobody should consider.
” Says the person who recommended Haskell. ”
As you would see if you would read it carefuly – for only specific (and rather small) group of people.
Edited 2018-08-03 13:24 UTC
People who are decidely not beginners. Good job on completely missing the specification.
Please read first, comment after.
There is a group (not numerous but somehow interesting anyway) of people, that gained some mathematical knowledge, have no problems with abstract thinking and don’t program yet. So they are beginners by definition.
Funny how it’s you who should have done so.
Whoa, finally I see on the internet somebody using this term and seemingly not meaning “raising the question”!
Yes, I thought very hard about it
Maybe just ask somebody competent? Such as teachers and mentors at youth programming contests etc.?
Hello! I write firmware for Hewlett Packard Enterprise, and I volunteer to teach computer programming to high school students. (If you’re in the US, you can, too!) It’s my second year doing it, so I have experience and I think this makes my opinion more informed on the subject than some others.
Edsger Dijkstra’s comment is generally a load of crap. At the very least, he’s speaking from the narrow perspective of someone who is teaching a university course to undergrads. Any language you learn is going to teach you things you’ll have to unlearn when you learn the next language. That’s the way of things, and part of the reason why it’s good to learn several different languages. The thing is, if it wasn’t for BASIC, his classrooms would have been a lot emptier.
It was those early BASIC’s ability to do cool stuff in a very few lines of code that got a generation of programmers excited about the possibilities of computing. BASIC got a lot of people excited enough about programming to get people into his classes. He should have been grateful, not scornful. He should have leveraged that in his intro courses.
Would I suggest this device, or even BASIC to beginning programmers? Oh, hell no. If your thing is instant gratification, and to get people hooked on programming your whole focus should be on instant gratification, building a computer from a kit is not the way to go.
In the USA, high school students are taught Java because Java is what’s on the Advanced Placement exam. That’s a horrible choice, too. You have to a lot of typing in Java just to get a program that does nothing. That’s not instant gratification!
Python is better because it has a lot less cruft to it, but the best choice, at least for the people we’ve been teaching, is one of those block programming languages. I teach Snap!, but the Scratch it’s derived from is a good choice, too. There is no installing a dev environment or typing “public static void main” which is inside this mysterious something called a ‘class’ just to get it to compile. Instead, you just point your Web browser at the right URL, and then drag some blocks into a workspace and use them to move sprites around.
Along the way you learn concepts like branches and variables and loops and conditions and all these things that you guys know, but which a beginner has no notion of.
Can you stop speaking in similes and metaphors, and actually enumerate real problems with BASIC?
So far, all you’ve done is denounce it via soundbytes, without providing a single solid example of what BASIC does that’s so horrible.
Other than GOTO and line numbers, both of which are easily (and gratefully!) abandoned by a mildly competent programmer, what exactly does BASIC do that is so terrible?
I think it all depends on what kind of “student” we’re talking about. For teaching kids, BASIC is perfect. For teaching college students, perhaps not. For IT students, definitely not.
Agreed. Computer science students should start with C. Although in Leiden, where I studied, they used C++ for the 101 programming course. Now they also learn a bit of Python (after learning C++).
I should learn LISP one day… good brain gymnastics 😉
I started with Pascal, but that was way back in the 90s. Nowadays C should indeed be the language of choice. I’m not sure about C++, I think one should be careful introducing OO concepts too early, and C# is better suited for that than C++, imho.
Yes, OO is often taught as The Only Way. Also C++ is IMHO not good for new students because of the many different “versions” resulting in many outdated code examples. OTOH, if you can handle C++, you can handle nearly anything.
If I’m correct, at MIT they use Scheme for 101 programming, which forces the students to structure their programs and think in a “functional” paradigm.
Given that C has no standard dynamic array or string type, OO or not, students would need to move to a language with such things.
No, that’s just perfect, they need to use char arrays and really understand strings. Also they would be forced to deeply think about arrays and pointers. A bit primitive, yes, but highly useful if you want to teach computer science students. (It’s not a productivity tool, although Linus would disagree.)
No, just no. Starting to develop shouldn’t be a pain in the ass, having to deal with pointers and stuff. For that you have C or assembler.
Just use Pascal, which was purposely made for start coding efficiently, or any lisp derivative (scheme?) that empower users with a usable programming language to get the shit done.
Not everybody that can find utility in learning to program needs the Computer Science background, though.
Knowing how to implement strings isn’t universally important to people that aren’t going to be professional programmers.
Perhaps REXX? Everything’s a string, and it’s seemingly designed for intermittent/accidental programmers.
No, nothing like rexx or tcl, a lightly typed language with repl is the best.
Agreed, but those things aren’t needed to understand programming. Low-level is best to start with. I tried to teach my kids C, but only after I explained the low-level internals of a computer they properly understood things like variables, arrays etc.
I definitely agree that C or something like it should be part of a “real” programmer (and not everybody who programs needs to be a “real” programmer) education. This and a FP language. (aka every real programmer)
But I don’t think that C is a good introductionary lang. It needs too much prior knowledge, it has too slow feedback loop (langs with REPL are usually pretty good at this), it had too many dangers, it has too few bells and whistles to make the first wins fancy (especially kids need it)…
So use C for programming education, but don’t use it for 101 courses, unless you are aware of the dangers.
Yeah, the biggest struggle using C as a start-up language for teaching is the abominable handling of basic input/output. Try explaining a “scanf”…
FreePascal (with its various dialects) has all of that and is a far safer, more robust choice, IMHO. But C libraries are ubiquitous, yet you can still link the two together! FPC even has inline asm, good docs, portable, free/libre, good IDE, etc.
Nope, Assembly 😉
I strongly believe you should learn programming languages in this order:
– Python (you learn the concepts of programming with an elegant tool)
– Assembly (you learn how a computer really works, what goes on inside)
– C (you get to appreciate the magic of abstraction since it is effectively almost Assembly but so much more convenient)
– Whatever you need for your job (reality bites)
[deleted]
Edited 2018-08-06 14:13 UTC
Such as?
Not really. BASIC was fine when I was 9 years old– a couple years later, I was ready for structured programming, and understood the difference.
If you can’t teach the student how structured programming is better than BASIC, you probably shouldn’t be teaching.
If the student can’t understand the difference, and why it’s better, perhaps they aren’t meant to be a programmer.
… yes, I know structured basic is a thing, but I prefer not to believe in it. As for OO basic, that’s neither basic, nor a good idea. BASIC should be considered an introductory language, and stop there.
Personally, I feel object-oriented programming as currently taught leads to absolutely terrible programming habits– but I learned to program when memory was typically between 16k and 64k.
I fully agree with every point
.
What do you recommend instead?
I played some time with Processing. But the “setup” is already a no-go for starters.
Processing, Python, Scratch.
If the person is mathematically inclined and old enough then Haskell.
Probably Scheme (I have no experience).
As I said, Processing needs a lot of “setup” before you really see something. Same for Python.
But todays BASIC interpreters (at least the ones I tried) also lack this “interactive” feeling if the old days (ZX81, Amstrad CPC, Atari ST GFA-BASIC), where you could draw a line just without a big voodoo arround.
And as someone wrote, Python with its weird identing is not really beginner friendly.
I played a bit with Scratch, and it does have some nice features (an online IDE with a built-in sprite editor, and a portal for sharing programs), but the language itself isn’t very nice, IMO.
It’s kind of object-based. It has one object for the screen, and “sprites” which are kind of like classes. These can have associated images, sounds, and code. The “sprites” can be instantiated (or “cloned”), but the originals themselves also exist as objects. Variables can have a scope of either global or object property (no procedure parameters or local variables), and a type of either a single value (which can be a number or string) or an array. The only means of communicating between objects is to set a global variable and broadcast a parameterless event (from what I remember). Also, the total number of objects is quite limited.
I was intending to make a scrolling online multi-player game in it (having heard it had networking, and supposing it was appropriate for this sort of thing), but after spending some time trying to work around various limitations, I decided it might actually be harder to do in Scratch than in a “real” language (for want of a better term).
None of those languages is ideal for beginning programming– especially python, one of the most difficult to troubleshoot languages I’ve encountered in recent memory.
By comparison, Java is a joy to debug.
Yes, I know python has extensive error handling support– but it’s not automatic, it has to be coded, and that’s not something a neophyte will know how to do.
BASIC does a nice job of introducing the basics of programming… simple data types, conditionals, some loop control, and rudimentary functions/subroutines.
I’m surprised so few people have mentioned Pascal. It is not an interpretered language, but I find it to be one of the best languages for learning how to program. I guess it’s not new or flashy enough for the modern computer programming student.
Personally, I do not see anything wrong with BASIC. I read the online manual for this particular board, and they use a dialect without line numbers. There are only a few keywords, so it would definite my be easier to get started.
Edited 2018-08-03 12:56 UTC
I agree that classic (or even Turbo) Pascal has a lot of virtues. But yeah, it’s too archaic for most people.
Perhaps Delphi (dialect, e.g. FPC) is better. It has exceptions, interfaces, properties, class-based OOP, and more. The GUI stuff is covered by Lazarus.
As mentioned elsewhere, I also think Oberon (language, not OS) would be a good choice. But it may be perceived as “too simple” or lacking good support for all the flashy extensions of modern GUI-based OSes.
So it’s less about raw algorithms and number crunching. Even simple cmdline-based stuff is probably shunned. So yeah, most people only want something heavily integrated into their modern OS (Win, Linux, Mac). Or something they can use for mobile (Android, iOS).
Your comments really help to illustrate and enlighten this article. Without your insight, I would have been left unmoored in a sea of inferior language constructs.
“BASIC is a terrible choice” is a quite common knowledge for decades 😉
And as in many cases mostly as a cargo cult phenomena.
The BASIC that made people bad programmers? It wasn’t any of the structured versions with proper variable naming, it was the one that required goto and gosub. It was the one that didn’t have dynamic variable sizing, that didn’t have array initializers or even structures. With variable names consisting of one alphabetical character followed by a number, only global variables etc.
For another equally disconnected “knowledge” look at all those that when hearing Pascal grabs their “Why Pascal is not my favorite programming language” as if it is representative to anything people actually used/uses.
Or why not the “Go To considered harmful”?
Again this is cargo cult instead of understanding.
That was Dijkstra’s work (with Wirth’s approval, even though Pascal had goto). Modula-2 left it out.
Later, Wirth designed Oberon (type extension, garbage collection), omitting many other things (e.g. variant records, enums, subranges). I think some people (Oxford?) still use Oberon (language, not OS) for teaching (and Haskell).
Yes, I said it. BASIC is great! Especially for beginners. Nu freaking tab/space invisible brainfucks as in Python, easy to learn commands/keywords, just perfect.
Of course you want a somewhat more modern dialect, without line numbers and with newer constructs, such as FreeBasic:
https://www.freebasic.net/
OTOH, the “interpreter” environment from GWBASIC was easy to work with. This might be fun to play with:
http://www.vintage-basic.net/
I so agree with that. I started out with BASIC, and never felt handicapped by that when I later started learning QuickBasic, Pascal, C and so on. It’s very easy to learn and teach programming concepts, and the right choice for such a machine.
I totally agree. Nothing replaces the fun when you start programming and you can just type your commands and the result just shows up (draw 0,0,100,100) 😉
For this GFA-BASIC was great: A good full screen editor, no line numbers and an interactive screen to try out commands.
Edited 2018-08-03 09:42 UTC
But that’s a compiler only. For beginners an interpreter is the best way to have an instant feedback.
Yes, that was in the part of my post that you did not quote
Agreed, my VintageBASIC suggestion is not that good for interpreted interactive use, and GWBASIC too old. I’d love to see a newer, easier one. I dit not try many, but there are options:
https://www.thefreecountry.com/compilers/basic.shtml
I tried GFA-BASIC for PC, but it does not have an interactive mode.
Sorry, I’m presenting myself as a fanboy of FreeBASIC, I know. I used it to learn programming to my girlfriend and to recompile a few QuickBASIC programs.
I like it for being open source, cross platform, and having modern features such as (primitive) OO support, pointer support and so on. GOTO is still there but not needed at all.
These kind of newer dialects of BASIC do not have the limitations that many associate with BASIC.
https://en.wikipedia.org/wiki/FreeBASIC
One of the biggest advantages of BASIC is the support for primitive screen drawing operations. For beginners, nothing gives so much satisfaction as drawing lines and circles using simple commands.
Or… Logo programming language! (turtle graphics)
I like the look of this – kind of a cross between a Pi and the ZX-8x’s and Spectrum of my childhood.
I would question this bit though:-
“It can be built at home without special skills or tools”
I would say that these days soldering could, sadly, be classified as a “special skill” and as for tools (quoted from their hardware page)…
“If you have no equipment, these are the items you will need to obtain:
Soldering tools
* Temperature-controlled soldering iron (recommended: generic 937D+ or similar device from eBay).
* Heat gun (recommended: generic 858D+ or similar device from eBay).
* Solder wire (0.5mm with rosin core).
* A set of pointy-tipped tweezers”
Although I did like the addition of these two points
:-
* Reading glasses (if above 40).
* A lecture on which ends of the tools get hot (if below 10, or a really big nerd).
I get it – they are probably aiming at the hobbyist electronics/build your own device market and most in that market would have these things but I’m not sure you can make a statement like “no special skills or tools” and then list skills and tools you need in order to build it.
Great little project though
Neat stuff. I think this is way better for true beginners than the Raspberry Pi, given that it boots straight into BASIC and a restart will give you totally pristine state. Linux is a wonderful OS, but less forgiving of random writes to random physical memory addresses than is a simple BASIC machine.
… that this modern system with WiFi “support”* still have just under 64KiB free for programs.
(* the hardware supports it but apparently not when using the Basic part which in itself is amusing)
can anyone help me out with this? i’m not that good with a soldering iron and don’t want to take my chances. i’ve always been better with software anyway..
BASIC is a great programming language to use as first steps into programming.
No, it is not. I learned BASIC as my first language, and it took me years to recover from that. If anything, Python is a great starting point, unless you buy into that whole assembly thing.
But BASIC was a bad choice back in the day, and it is even worse now.