Back in 2008 I bought a computer for 50 uruguayan pesos (around 2 dollars), Pentium MMX and 32MB of ram. It didn't boot W98 because the hard drive was corrupted.
It did load MsDOS and I found Qbasic using the help command.
I didn't have internet so I used to go to the internet cafe with a floppy disk and download tons of tutorials in plain text to read with EDIT.EXE
Now I've been working as a software developer for almost five years and love it, all thanks to QBasic and that old cheap computer.
It started very simple, PRINT and GOTO were enough to get you started. It had the tools to expand along as you learned, and a great community of amateurs who would make cool games with it. Eventually, you'd grow out of it and try your hand at C, because by that point you were encouraged to learn so much (and with a gentle curve) that you exhausted its capabilities. It was an excellent educational tool, an excellent way to get kids "hooked" into "real programming".
Learning programming today isn't quite as simple as it was with Qbasic. It involves setting up a large toolchain, and for a beginner, the experience is daunting as the language community reviled both anything imperative and unstructured. There's no easy way to do anything other than text from the command line, which makes for some thoroughly uninteresting demos and examples. Qbasic wrapped an IDE and graphics library around the language in an all-in-one solution; it was so cool seeing colourful, pseudo-graphical demos like Nibbles or Gorillas. If a beginner wanted to do anything "cool-looking" today, this same beginner programmer would need to set up render to texture on an OpenGL surface. Yuck! And so they lose interest, believing programming is the mysterious and complex domain of gods.
This market did not go away. I don't quite think QB64 fills it, being little more than a nostalgic, artistic homage to Qbasic. If someone were to design a programming language with a learning curve as gentle as Qbasic, and wrap a simple IDE and graphics library around it, all while modernising some of its more dubious qualities...you'd have a real shot at recapturing the magic for a new generation of young programmers.
They did, years ago. It’s called “Processing”, and it’s very popular. It’s also used by a lot of artists to let them make active or interactive art pieces without needing to be an experienced programmer.
Syntactical it is similar to java, although only the simplest Java. No generics, no inner classes, etc. And let’s face it, even at its most complicated, Java isn’t syntactically complicated.
> I wonder if it is really that easy to teach programming with this language?
Well, it’s been in use for a number of years, and is popular among non-traditional programmers, so the answer seems to be yes.
It captures that vibe of an old computer system (where you turn it on and are ready to program immediately) with simplicity and an awesome community to learn from.
What they don’t have is the low level, close to the metal feel the old BASICs has. Even though they were interpreted, you could address hardware such as video memory and devices directly which made them a great gateway to low level programming.
I first learned QB maybe in 2001, during high school days. Then I learned Python.
Writing graphical programs in QB was pretty easy. There were PSET(), LINE(), CIRCLE() that were straightforward. But with Python, I had to learn this thing called "Tkinter". What the hell these "root", "unpack", "mainloop" mean?
Seems it has since been open sourced.
(Unrelated, but I can also remember writing the first lines of code of my life in qbasic on a dos machine in ~1998; the blue screen definitely invokes childhood memories!)
PSET (1,1), 43
1. SimSAL Workshop , made years ago using a scripting language (SimSAL) i wrote at some point in Lazarus . I originally wrote it because up to that point i used QBasic in DOSBox now and then to try out algorithms and i wanted something similar running natively. Although these days i tend to use Lazarus directly.
2. VitriolBASIC  (sadly the site i had it is down and only that image remains from archive), a simple QBasic-like interpreter written in Java. Written purely for fun, i lost interest when i realized how hard and annoying it was becoming to run Java stuff on the browser (today you cannot do that at all unless you pay the certificate mafia and even then you get tons of scary messages).
3. WinLIL , this is just a playground for my LIL scripting language  ... i just wanted an excuse to shove it in yet another program. But it is a single self-contained EXE file that includes the interpreter, a simple programming environment, some extra commands for graphics and all the documentation i have available :-).
Some examples worth trying:
- PICO-8: A 'fantasy console' that you can code within itself in Lua; absolutely amazing, not the least of which because you can inspect the source of every game made in it and there's a huge amount of games you can explore from within a game browser inside PICO-8 itself. There's also a version for Raspberry Pi: https://www.lexaloffle.com/pico-8.php
- TIC-80: A PICO-8 like, a little more powerful. Runs standalone, in the browser or on Android: https://tic.computer/
- LIKO-12: Another PICO-8 like. Runs standalone, in the browser or on Android. At first glance it seems like a more powerful LIKO-12, like one of the more powerful late-80s home computers: https://ramilego4game.itch.io/liko12
- BlitzBasic / BlitzMax: https://github.com/blitz-research/blitzmax (and see also https://en.wikipedia.org/wiki/Blitz_BASIC). Blitz was amazing. The thing that always impressed me about BlitzMax in particular was just the amount of actually completed (and often commercially sold) games made by people with the platform. Incredibly impressive. I never got to try Blitz BASIC on the Amiga, though I have plenty of fond memories of AMOS BASIC and the Blitz experience on PC very much reminded me of that.
- Monkey2: From the creator of the Blitz languages. More powerful than Blitz. See http://monkeycoder.co.nz/ (and also https://en.wikipedia.org/wiki/Monkey_X).
- FUZE BASIC: I haven't tried this one but only heard about it because it has an upcoming release on the Nintendo Switch. Looks very much like that late-80s computer experience though. It looks like they even make a Raspberry Pi-based computer around it in the style of the BBC Micro: https://www.fuze.co.uk/
Needless to say, there's no shortage of these environments out there :)
It's was the perfect first language. It's so easy to play little sounds or draw graphics, and the environment is basically non-existent so setup is easy. So much fun!
If there's a modern equivalent I'd be interested to know.
From the article you can do everything Qbasic could, but also load PNGs (_LOADIMAGE), fonts (_LOADFONT) and MP3s (_SNDOPEN).
That's where it all began. Upgrades were done (went to 64K of RAM, also got a floppy drive and printer - then later the Color Computer 3, which was upgraded to 512K, and the CM-8 monitor - oh, there was a 300 baud modem in there somewhere too).
Amazingly, I still have all of my old machines, and they all work (except for my printer - it was the CGP-220 ink jet printer, and the heads are clogged completely, and no way to fix or get ink cartridges for it).
When I was about 11 or 12 years old my best friend and I decided we wanted to make video games when we grew up so we needed to know how to program. His dad bought him a "for dummies" book, which just so happened to be QBasic for Dummies, and covered how to load the QBasic environment off the Win95 install CD and, well, how to write programs. We both made it about half way through that book before we'd finished middle school.
I don't make video games but I am in software. He went on to attend Digipen (back when it was still directly affiliated with Nintendo) and he now works in the games industry in Washington State.
Compared to GW-BASIC, QuickBasic was a luxury :)
PC Basic does what GW-Basic used to do. You can type old Basic games into it and they still work.
I used QuickBasic later (QBasic was essentially QuickBasic without the compiler and a few other features cut out) and many other things since.
By the time we got a PC, Visual Basic was a thing. It just wasn't the same anymore :( Motivated me to move on to C.
I also used a few other micros like the Apple II, the Commodore 64 and the IBM PC Jr. for a while.
Here is one post I wrote about it:
Lissajous hippo, retrocomputing and the IBM PC Jr.:
:) I miss the community that was the QBASIC Prodigy BBS groups. I spent hours trying to design better games and utilites, only to be outdone by a random stranger. We'd have to first make the games, then invent new compression techniques to get the big ones posted to the board, and i think someone even had a splitter/combinator thing to put the encryption back together over multiple posts.
I also miss the ABC Code Packs (memories: http://www.manmrk.net/tutorials/basic/abc/).
Except, I won a pentium (286?) machine running windows 3.11 in 1998 as a 13 year old from a top hat raffle (yes, a magician's type top hat). True story.
It had a flavor of BASIC (I don't remember which) and accompanying manual which changed my life.
Now, as a 30 year old Creative Director in the "new media" field, I hope there are similar parallels for the "youth", especially within the rural regions of where I grew up.
If anyone has the capacity and wish to assist, a long term goal of mine has always been to provide a space for adolescents from similar backgrounds to explore these notions through the lens of Computer Science and Art.
I've had really good luck with FreeBasic. It supports classic QBasic as well as a lot more new commands, libraies, and is more modernized. You can also compile Windows, DOS, and Linux binaries. The drawback is that it doesn't have it's own GUI and is a bit harder to set up.
Compared to all other BASIC dialects I've tried (which doesn't include VB), it seems better engineered. Compared to C, the main drawback is the immaturity of the compiler, and error messages are often poor.
When I first started, I really had no idea what QBasic even was. I think I was just poking around the DOS file system one day looking for EXE files and found it.
Except the instructor felt the other kids would be dissuaded by my typing and told me I couldn't stay in the class.
And, similar to your case, typing was a prerequisite to taking any other computer course.
They wouldn't give me credit, but wouldn't let me stay in the class either.
I would up taking it in summer school of 9th grade, spent 2 days, the program clocked me at 139wpm and the teacher(a different one) said I couldn't stay there either. She talked to the office and I got to hang out in the school office for the rest of the summer.
What fun. All because they didn't want to make the other kids feel bad. At least they gave me credit for the class.
My parents had to buy a typewriter, despite having a perfectly good printer at home.
For what it's worth, I've fallen into the same trap many times myself.
Related XKCD: https://xkcd.com/974/
Or maybe I'm just justifying being lazy!
Myself and many others I've met who took up programming independent of their college degree seemed to have started because of laziness and impatience. We wanted something done, but we didn't want to do it manually (or all the work manually). My first real programs in high school were solving data analysis problems for my science classes and automating a survey that I was using for a science fair experiment.
You could really only count on someone having an 80x25 text display (usually 16 color but might be monochrome), a keyboard for input, and a floppy drive for storage. Once you learned to do 4 simple things - position a cursor, print text, read keyboard input, and read and write to the drive, you could do almost anything that any professional software could do. There might be a parallel port with a printer or a serial port with a modem, so learning to read and write those ports gave you more options, but again that was simple.
None of that required frameworks on top of libraries on top of dependency managers on top of package managers. You didn't need to memorize a 7000 class object inheritance hierarchy. Just a few simple statements and concepts that all easily fit in your brain at once with plenty of room left for working on the actual program.
Of course, you couldn't watch streaming videos while chatting with people online in another window. We've added a lot of complexity for the sake of GUIs, multitasking, media, and networking, and in the process killed the ability to learn or do anything simply.
Years later I got an old IBM PC JR with a Cartridge version of BASICA. That had a floppy drive (the 5.25 ones that were actually floppy) and I was able to save my programs. I wrote a few simple games. At this time, the Pentium had already come out, I had just been playing with older machine.
My next machine was a Pentium 75 Mhz with 16 MB of ram (which I eventually upped to the max 128 MB). I got my hands on a floppy drive and brought all my code over and opened it up with quickbasic. Unfortunately I had been relying on the CPU timing and all my programs were way too fast (e.g. the pong paddle would move instantly to the other side of the screen). And it wasn't until about a month in that I had realized (being self-taught, sometimes you miss things) that the line numbers were optional. I could create functions! The rest was history.
You may be thinking of the XL series.
We modified this for our project ETHDenver hackathon last weekend - a Drugwars-inspired cryptocurrency trading game: https://www.cachethegame.com
It was hosted at a system in the UK called IOWA. They had a really neat multiplexer “front-end” with lots of serial ports. Each host spoke to it using a custom protocol over a 19,200 baud serial connection. Other serial ports were connected either to modems (they had 10 phone lines IIRC) or to internal terminals.
I progressed to C and C++ pretty quickly afterwards, but writing (and re-writing and re-writing) this MUD engine in QB45 was a formative experience in my teens.
It's really special - visually editing forms/controls in text mode is great fun.
GAMBAS is another for Linux that reminds me of VB6 a bit:
Wikipedia also has a list of BASIC dialects which shows possibly full range of what was tried in BASIC variants on what platforms:
There's a number of proprietary, cross-platform BASIC's still being sold and updated that illustrate a demand for its advantages. Main one being it's close to pseudocode in readability. BASIC also got some attention for game development with dialects developed specifically for making that easier. Only one I can remember looking at was DarkBASIC. It's FOSS now under MIT license.
If it had functions as values then it would have had object based programming.
i think the good part about basic was that it supports both unstructured programming with goto/gosub (gets you going quickly) and structured programming (if you don't use goto/gosub and write functions). Maybe we lost this multi paradigm aspect with later (more powerful) languages.
That may have been because of Dijkstra and his 'goto considered harmful' rant : authors of programming languages do not like to support the unstructured paradigm out of fear that they will be taken as a not-so-serious-programming language. Somehow they did not take notice that unstructured programming is quite good as a teaching method and that one can choose not to use goto when it is available. I really don't think that it is such a strong habit that is impossible to unlearn. It is far easier not to learn how to program at all...
As time went on I moved on to C programming with DJGPP and Allegro to work on games with my brother (I think that was in the 90s). But QBasic will always hold a special place for me because I learned beginner programming principles by just playing around with it.
What are kids today using to do this kind of 'make my own tinkered games' stuff -- do they go straight to Unity, or still something like QBasic?
Python, with pygame, is the modern equivalent I think. It's relatively easy and straightforward for beginners, free, and very popular (lots of resources, tutorials, etc...).
For something more advanced but still python-ish, there's also Godot, which is a real engine and adds a visual IDE to game creation. Quite easy to install/setup too (everything comes in 1 file). Overall a very cool project.
I have a few pieces of code in the archives (and scattered on the net - funny to see my name from back then); there's a ton of stuff in there, that can really show off what was possible back then.
QBasic was a good upgrade from BASIC from 8-bit machines. Still, it is limited. VB then brough its power to Windows, it might have had a lot of quirks, but it was a good prototyping and RAD tool
I was reminiscing about gorillas, qbasic and nibbles.bas just a few days ago.
edit: yes! QB64 comes with Gor64.bas: https://en.wikipedia.org/wiki/Gorillas_(video_game)
There was one PC in our school, it was just when CD-ROM's came out. Encarta of course, but we figured that we could get it to play audio CD's too - until we got one stuck and got in trouble.
I didn't even have a computer at the time, but I was hooked.
The magazine format changed a couple years later, and they stopped including programs.
But when we started using computers at school, I remembered the instructions for accessing BASIC on our Apple II's, and thus me and my friends were introduced to programming.
I had to live with this for a few years and hated it. Fortunately, the Ipython notebook (now Jupyter) and Pandas came along, and to some extent I managed to stop using Excel.
Define "died". The platter(s) might still be okay.
I remember spending many days as a kid at my IBM PC to finish it. By the time it was ready everyone else in the family already knew all the solutions to the puzzles, of course.
(I haven't tried running it in QB64 yet.)
I'm glad it lives on!
I really wish Visual Basic would be open sourced from Microsoft, so the community would revive it. I still have fond memories programming with VB and the productivity it allowed - it had it's issues (oh, man...) but also made programming accessible.
VB6 is dead though, everyone wants COM to die so even if MS open sourced it there's no real reason to continue putting effort into it. There are alternative that work reasonably well though, like Gambas (open source).
The main reason is the sheer amount of software out there that businesses rely on to run their business, which they might not even have the source code to. Those that do have the code do hire people to maintain and extend the applications (shades of COBOL there).
It wouldn't surprise me to find out that new VB6 applications are being created - lots of people love it and loved using it (though I personally preferred VB5, because the compiler was separate from the rest of the system and could be used at the command line). VB.NET was widely viewed as a travesty to the language; some moved to C#.
What is strange is how few of these programmers seem to be aware of Gambas (and similar "VB-like" languages). I moved away from Windows at home in 1995 and move on to Linux; over time I became aware of other BASIC programming languages, but I moved away from BASIC as well, though it will always hold a place in my heart, since that's what I started out with.
So researchers already used to VBA, usually get IT to install VB.NET and go from there.
However I have started to see a trend of them moving into R.
Of course, Visual Basic lives on (as part of the free-as-in-beer Visual Studio).
It comes with a large collection of games & demos, including the gorilla game.
Compiling a single line of:
print "Hello world"
took more than 1 minute, the result is a 1.4 MB exe which launched its on window and displayed "Hello world".
The very same code, compiled with FreeBasic: much faster, much smaller, and a real command line app.
One very popular variant that's still sold and used today is/was known as the PICK system. It's based around a "multi-value" relational database structure (which is pretty cool all on its own - data is stored in "cubes" - rows, columns, then within each "cell" can be further dimensional data). It's main "claim to fame" was a certain level of interpreter compatibility - code from one vendor could be run on other vendor's products. PICK Basic compiled down to a bytecode which was run by an intermediate "interpreter", which was a kind of virtual machine. The bytecode looked a bit like assembler (and could be coded in directly if you really knew what you were doing). There were even a few companies that made hardware CPUs that could run the bytecode directly (instead of thru an interpreter VM). Think of it as Java before Java was a thing.
There also was (is?) one of the major industrial robot arm manufacturers who sold a version of BASIC geared toward programming their robot arms; I imagine that some of that is still out there running in the "wild".
For example from MikroElektronika
Today, BASIC is looked upon as a children's language. But back then, it was widely used for serious work. I can think of a few reasons why:
- It was available on pretty much every platform
- It was usually built-in to the computer, so there was no extra cost
- If the program you wanted wasn't directly cross-platform, the syntax was close enough that you could figure out the differences and adjust it to work on your machine
- Most consumer and small business computers didn't have the horsepower to compile FORTRAN or Pascal or COBOL.
There are probably others, but from what I've been reading in the old mags, those seem to be the big selling points.
Ironically Microsoft did the opposite, they killed Quick Pascal.
That was my starting point too, after some dabbling with Oric, C64, and GW-BASIC/BASICA. Nice little environment, though I wasn't all that impressed with the size of of the output executables - over 30Kb for a raw Hello World program.
In itself a daunting task, considering the choice of language it is really impressive.
I could write simple code and compile it into an .exe,
I remember trolling BBS's as a youth attempting to learn how to do the same thing, to no avail...
It's amazing, in retrospect, how important it felt to create a "real EXE". Nowadays, we write huge professional systems in scripting languages that need explicitly invoking with an interpreter - but back then, "grown up" programs were the ones that didn't need that.
The whole issue with creating a "real EXE" was it was incredibly obvious when your program WASN'T an EXE on DOS and still to this day on Windows, to this day it still irks me when I download something and there's a .bat file to launch it - but I could care less if there's some wrapper shell script on Linux.
I remember simultaneously being excited about the fast startup time, and also feeling that my program didn't seem "real" if it finished its operations too quickly. Real programs took time to do things, and something about it felt fake when the program responded immediately.
This is why Go's ability to compile to a self-contained, QuickBasic-like, exe makes it attractive to me.
You might be thinking of QBASIC (which came bundled with DOS), which wasn't the same as QuickBASIC (a commercial program).
When a friend first gave me a floppy with QB45 on it and I discovered I could now compile my QBASIC programs it was indeed a magical day.
.. because my "DOOM killer" was a top-down shooter and I had defined the map as a 2 dimensional array of tile IDs :D
I think this thread explains it, which is that QBASIC 4.5 could compile to EXE - http://qbasic.proboards.com/thread/466/bas-exe
The free version of QBASIC that comes with DOS didn't have a compiler.