Hacker News new | past | comments | ask | show | jobs | submit login
QuickBASIC Lives on with QB64 (hackaday.com)
237 points by mariuz on Feb 23, 2018 | hide | past | favorite | 133 comments

QBasic was my first programming experience.

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.

Qbasic is something that simply has no modern-day parallel.

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.

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

Cool! I haven't tried out Processing, but I have tried out the JavaScript port of it (processing.js), initially created by John Resig, who also created JQuery.




i took a look at the examples here [1] and the syntax looks similar to Java. I wonder if it is really that easy to teach programming with this language?

[1] https://processing.org/examples/

> the syntax looks similar to Java

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.

PICO-8 (https://www.lexaloffle.com/pico-8.php) is a good alternative to a very simple system with a focus on game programming.

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.

Closest thing I can think of today is https://processing.org. Processing has some serious flaws, but it's an all in one IDE with a library that makes it extremely easy to draw to the screen.

Every Windows computer comes with VBScript that’s just as streightfirward and a lot more powerful. Macs have AppleScript and Python among others. Even on the iPad and iPhone there are quite a few simple, powerful options like Codea and Pythonista. There are loads of great ways to code on modern systems.

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.

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

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?


If you're running in Python, there's also import turtle: https://docs.python.org/3/library/turtle.html

I found myself reminded of Blitz Basic.


Seems it has since been open sourced.

I immediately thought of Blitz Basic too, which is how I got started programming. They recently took down the website for it, which made me sad, as I used to frequent the forum a lot.

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

Or just use the web platform: JavaScript, HTML5 Canvas API, WebGL, all of that. I think it's pretty close in terms of getting a pretty (motivating) result quickly without much prior experience.

(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!)

The conceptual load of these things is much, much higher than QBasic, though, they're not nearly as easy to 'just use'. There's this:

    SCREEN 13
    PSET (1,1), 43
And then there's this.


My preferred term for this is “zero to pixels”. QB’s was very low—basically unmatched by most modern environments, which require considerably more setup; although that’s partly because they’re intended for more “serious” programming. We need more unserious, fun programming environments for beginners. :)

Over the years i made a few languages and environments for fun that included exactly that sort of low "zero to pixels" idea, mainly inspired by QBasic:

1. SimSAL Workshop [1], made years ago using a scripting language (SimSAL) i wrote at some point in Lazarus [2]. 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 [3] (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 [4], this is just a playground for my LIL scripting language [5] [6]... 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 :-).

[1] https://i.imgur.com/AuLjMsP.png

[2] http://www.lazarus-ide.org/

[3] https://archive.is/s3Qf6/9ef5d8071b45fe792347b0dc12a1de8bfae...

[4] http://runtimeterror.com/tech/lil/winlil.png

[5] http://runtimeterror.com/tech/lil/

[6] http://runtimeterror.com/rep/lil/

Does your LIL have anything to do with this[1] one described in an old issue of Byte?

[1] https://archive.org/stream/BYTE_Vol_02-10_1977-10_Implementi...

No, the same name is just a coincidence. Mine is Tcl-like.

There are actually quite a few applications around that attempt to do this.

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

Microsoft still ships SmallBasic, for free.


>Learning programming today isn't quite as simple as it was with Qbasic. It involves setting up a large toolchain...

It can be complicated but you can always open the console on your browser, or jsfiddle and type some javascript. An you can ignore the critics and do the w3schools course in a day or so.

I learned on just basic about a decade and a half ago and it was my segue into becoming a developer

Me too! I love QBasic so much - totally wouldn't be where I am today without it. I met a kid at summer camp when I was in middle school who told me he made his own games and fake computer viruses to scare his parents in Quick Basic. He mailed me a floppy disk with Quick Basic on it once we were home and I've been in love with programming ever since.

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!

Very much agreed on the ease of graphics and sound, and its influence on me as a student -- I wrote a version of Pong in about 250 lines back in the 90s. A single line of music was as simple as PLAY and a string language to specify duration and pitch. SCREEN followed by LINE/CIRCLE/PAINT and you had graphics. GET and PUT gave you sprites. Some of the fine people on Prodigy provided their amateur games and tutorials.

If there's a modern equivalent I'd be interested to know.

QB64 basically is.

From the article you can do everything Qbasic could, but also load PNGs (_LOADIMAGE), fonts (_LOADFONT) and MP3s (_SNDOPEN).

QBasic and QuickBasic are related, but not the same. QuickBasic was compiled to an EXE. QBasic was only interpreted. I never used QBasic, but I used QuickBasic extensively and remember when v.4.5 came out. I still have my QuickBasic manual, which I just can't allow myself to throw out.

As someone that loved QuickBASIC, it irks me when people confuse it with QBasic. QBasic was Microsoft's answer to "what should we do with GW-BASIC to make it feel fresh again?" Whereas QuickBASIC was a serious tool.

Showing my age a bit but it's amazing how such simple things can alter one's life. My parents brought home a heavily discounted TRS-80 Model I Level I with a whopping 4k of ram when I was a child and that started my life long love of technology/coding.

I started programming in Microsoft BASIC on my first computer - a TRS-80 Color Computer 2 with 16K of RAM. I used a cassette tape drive for storage, and a television for my "monitor".

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

Nice! Fellow old-timer here! I still have my original TRS-80 CoCo as well. A few years ago I wanted to extract my first programs and realized I could convert my tapes to .wav files and load them into an emulator on my Mac. This is the post I wrote about it (complete with source code): http://rb.io/blog/letter-defender-my-big-program-from-30-yea...

I have fond memories of my CoCo and poke 65495,0.

Likewise, my jump from the HP calculators' built in language was QBasic. And then, when it wasn't able to plot a Mandelbrot set fast enough (on a 486DX-33), I tried FastBASIC which was about 10x quicker - and that's how I learned the difference between compiled and interpreted languages.

QBasic was also my first exposure to programming!

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.

For me it was GW-BASIC on a Tandy 1000 our family found next to the university dumpster. Kids these days with their fancy-schmancy dropdown menus!

GW-BASIC too! Though in my case, running on a PC XT with an amber monochrome CRT. I remember doing graphics with GW-BASIC (on an Hercules videocard, I think you needed SIMCGA or something like it)... it was a bit like using the LOGO turtle, you had to go left, right, up and down.

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.

In Basic (not exactly QuickBasic, since MSX computers came with MSX Basic) I learnt how to program. And when I was able to alter some Inventory control for an uncle that owned a drugstore, it was great. The computer wasn't exactly cheap, but seeing it be used for professional needs when only big companies would have computers was amazing.

I cut my programming teeth in BBC Basic, which was a much better language than that found on many other 8-bit micros of the time. No silly 2-character variable names limit (IIRC it respected up to 40 characters), proper named procedures and functions so you could program with some structure (some 9-bits BASICs' had little more than GOTO <line> and GOSUB <line>, with BBC Basic and very little jiggery-pokery you could program without line numbers at all), and a built-in multi-pass assembler (which I played with for various tricks like sprites and a bit of playing with integer fractal calculations for trippy graphics).

I used QuickBasic later (QBasic was essentially QuickBasic without the compiler and a few other features cut out) and many other things since.

Amiga AMOS was my favorite "BASIC." They even sold an optional compiler :)

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.

Oh AMOS- thanks for the reminder. I had totally forgotten about it. It was really incredible for game development. I remember working on a Mario jump and run clone for a while to learn game development. It was a really great environment.

This was pretty much my route too. BBC Basic (Albeit on an Acorn Electron). Whilst my friends we're rocking the much "cooler" Spectrums, i didn't have people to swap games with so got my interest in programming there. Is interesting how parents decisions to buy the "wrong" computer got me started in the right direction.

The BBC computer with BBC BASIC was good. I used it some; I didn't have one, I used the one in the British Library in Chennai (Madras), from where I also got tons of good computer books to read, over some years while in college. (I used to max out the four-book allowance and borrow that many at a time to take home to read :) Apart from supporting just BASIC programs, it had the feature of allowing you to drop down to inline 6502 assembly language, just by including all the assembly language statements between square brackets, one statement per line.

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 also started on an Electron too, though we later got a juicier Master 128.

wahoo! I still have top fighting game (admittedly, this list is probably from 1998):


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

Same! It came free with my dad's 386 that he bought for work back in 1991 or 1992. He didn't have any interest in it so I read through the manual and tinkered with it.


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.

    pentium (286?)
What is the question here exactly, if a pentium is the same as a 286? They are vastly different processors with 3 generations between them and easily a ~100x typical performance difference.

I've used the QB64 for a few projects that extended old stuff I had done. But I've had some stability issues with the interface and applications. That was a few sub-versions so that may have been fixed.

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.


As a heavy FreeBASIC user for 13 years, I like to describe it as a subset of C++98 with BASIC syntax and decent builtin strings. Unlike C++ it compiles very quickly, and if you want faster code, it can emit C code and compile via gcc. the very nice fbfrog tool automatically translates C headers to FB headers, so you can use almost any C-compatible library and do almost anything you can do in C. Using it like C is not necessary a good idea.

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.

My experience with FreeBasic was about 15 years ago so things may have changed, but it had Allegro or SDL built in and was very easy to use to make little video games.

The first "useful" program I ever wrote was in QBasic. In 5th or 6th grade (can't recall which), for spelling assignments, we'd be given a list of words and we'd have to write them 10 times each. I asked the teacher if we'd be allowed to type the list and print them out and she agreed to it. I hacked together a little program where I'd type in a word and then it would automatically print out 10 copies of it to my dot matrix printer.

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.

My high school required everyone to take a "typing" class and the instructor didn't know the word processor installed could do cut and paste. Those of us that were computer savvy in the early 90s therefore were the fastest typists in the class by a wide margin :-)

Nearly the same thing happened to me.

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 brother had the opposite experience: we didn't know what "copy and paste" was, but one of my brother's classmates did. So they told the typing class professor, and he forbade everyone from bringing printed homework.

My parents had to buy a typewriter, despite having a perfectly good printer at home.

I had the same experience, except the teacher asked me, since I knew how to type and use a computer, if I'd like to take a programming class instead.

Are you my doppelganger? Because I did the exact same thing - back in 1984, though - using my TRS-80 Color Computer. My teachers had very little experience or knowledge of "home computing" - and had no problem with me turning in assignments I did on my computer.

I had the Color Computer 2 with a DMP-105 printer. I wrote an entire report using LPRINT statements

I love it when the effort put into being lazy is greater than the effort required to do the job in the first place.

For what it's worth, I've fallen into the same trap many times myself.

Related XKCD: https://xkcd.com/974/

I think with programming there is so much value to just trying out different things because you're constantly learning that this effort isn't necessarily wasted. Some people probably learn by working on meaningful projects, others (like me, apparently) are just trying to get out of doing something they don't want to do.

Or maybe I'm just justifying being lazy!

"We will encourage you to develop the three great virtues of a programmer: laziness, impatience, and hubris." -- Larry Wall

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.

Oh I didn't mean to imply it was an wasted effort. Far from it. It just amuses me how much effort us geeks put into the avoidance of manual or repetitive jobs. I don't think it's a bad virtue to have either. It's just the lengths we sometimes goto can sometimes be a source for humour.

Let's just hope you didn't misspell any of them :)

What strikes me is that back then we largely did the same things that we do now (run businesses, play games, manage personal data like calendars, notes, and contacts) with a fraction of the capabilities that modern hardware and software provide. And it was much simpler and easier to get into.

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.

I found a book on BASIC in the school library when I was 8, and my brothers showed me how to use QBasic to run the examples. Then I got one of my friends into it. We made a bunch of programs and games - even got one of the younger classes at our school to use a math game we made. Now we both have really successful, fulfilling software careers that started very early. Years later my school library had a sale to purge outdated books, so I went back to see if I could grab that first BASIC book I brought home: it now sits on my bookshelf to remind me what a big difference it'll make if I teach my kids cool stuff outside of school.

My first programming experience was on my Atari XE. It would run 2600 games, but if you didn't put a game in it would come up with BASIC. I didn't have the optional floppy drive, nor did it have a hard drive of any kind, so when the computer shut off, my program was gone. I used to LIST and write the programs into a notebook and give hell to my mom when she would turn off the machine while I was at school (I was 9).

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.

XE did not run 2600 games.

But it did run 400/800 games, which is probably what the gp post is thinking of.

Yeah, that's right it ran those other games. But the name Atari 400/800 doesn't sound familiar for some reason. Maybe there was another name for it at the time. I was 9 at the time, so I don't remember exactly. I do remember playing Bug Hunt, Dig Dug, Missile Command (built in), Arkon, Lode Runner. I was never able land in Flight Simulator II. I should go find an emulator and try now.

They were beautiful machines. I was a Commodore user at the time and had no idea what I was missing, but I own a bunch of Atari 8-bits now. Emulators are great, but you should hunt yourself down an original Atari 8-bit to collect.


You may be thinking of the XL series.

A QBASIC/DOS inspired Bootstrap theme - https://github.com/kristopolous/BOOTSTRA.386

We modified this for our project ETHDenver hackathon last weekend - a Drugwars-inspired cryptocurrency trading game: https://www.cachethegame.com

Happy memories. I wrote a MUD engine in QuickBASIC 4.5 (back in 1988 or 1989 I think) which ran on a Compaq 486. I wrote the engine, while my friends did the world building.

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.

For anyone who remembers the magic of compiling QuickBASIC programs but never experienced Visual Basic for DOS at the time, I highly recommend tracking down a copy and having a play!

It's really special - visually editing forms/controls in text mode is great fun.

I also started with BASIC. Easy to learn/read/write, compiled ultra-fast, ran fast, crashed less than C, and had p-code for portability. Great stuff for beginner. Anyone wanting an open-source solution for that should check out FreeBASIC which was simple to setup and use last time I tried it:


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.

TIL that Qbasic has structure types (user defined types) https://en.wikibooks.org/wiki/QBasic/Arrays_and_Types#User-d...

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

Like alot of others are saying I first programmed in basic. My dad had gotten a Tandy 1000 that we all played games like King's Quest III on. I wanted to learn to make my own games and he showed me how to do some simple things in basic. I can't remember if QBasic was included or I later obtained it somehow but ended up using that down the road.

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?

> 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...). https://www.pygame.org/news

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. https://godotengine.org/

For those that want a great "period" archive of BASIC code (not just QB!) - check out the ABC Packet archives:


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.

Important question, does it run edit: gorilla.bas?

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

Are you thinking of gorilla.bas ?

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)

Rejigging the gorilla.bas code is what got me from BBC Basic to Quickbasic and into PC's.

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.

Gave me my first exposure to software piracy. I wrote a skateboarding game in QBasic, sold it to a kid at school for 10 pence, and soon after all the computers were running it.

I recently was able to recovery a floppy that had almost 100 programs I wrote in QBasic when I was a kid. There was something magical being able to command a computer so easily that's hard to appreciate today. Often the simple magic of programming is cluttered with so much independant tooling that lack a simple cohesive experience, although there are benefits to use small small tools over one monolithic toolchain of course. Just yesterday I spent an hour trying to hunt down a JavaScript webpack build issue that has nothing to do with the actual code. It's a fact of life now, but there's a part of me that misses the one-in-one integrated experience. However, I don't miss Basic as a language... so very limiting and often forces you to not follow DRY principles.

As a kid, someone gave me a subscription to "3-2-1 Contact", a children's science magazine. Towards the back there'd be 1 or 2 pages of source code for a "game" written in BASIC. The one that still sticks in my mind was a a text-only downhill derby where you selected from a couple options for hill steepness, axle lubrication, and maybe car shape, and it would return how fast your car completed the race. There might have been fewer than 50 lines.

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.

Interesting comment in the article about how VB is still being used in some organizations. One company I worked for ran some critical business processes in Excel + VBA. I hope they've moved on from that. I imagine there's a lot of that lurking in Fortune 500 companies.

In engineering companies, Excel + VBA will never go away. Most engineers who are not CompE or CS folks really do not want to program. Excel is powerful for nonprogrammers, and the allure of automating some of it with VBA is almost impossible to resist. Excel gives you a platform where you can feed in numbers, do some calculations with a click of a button, and produce charts - all in one file. And it's trivial to tweak if you need to change something. An engineer with little programming knowledge can be "operational" quickly, and the "tool" is safe to pass around to customers.

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.

Keep hoping and hope harder.

This was my first language too. I remember sitting there all night when I was about 8 years old writing my first game - Dancing Dobbins (a horse racing and betting game). I had to manually draw each horse line by line and the refresh rate was appalling as they flickered across the screen. It got gradually more elaborate and foolish as I added features like horses going mad and attacking each other. I so wish I had the original code but it died along side the cutting edge 80meg hard drive.

Do you still have the HDD?

Define "died". The platter(s) might still be okay.

Here's the QBasic code for one of the first complete games I wrote in the 90s: https://git.elephly.net/?p=software/windelprise.git;a=summar...

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

Wow, I had totally forgotten about QuickBASIC. It came slightly late for me -- I cut my teeth on line-numbered BASIC in ROM on TRS-80s, and by the time of QB I was firmly absorbed into the Borland world (mostly Turbo Pascal and Turbo C) -- but folks who came slightly later to programming that I knew loved it.

I'm glad it lives on!

This is neat - remember using QuickBasic back in the day. Fun times.

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.

QBasic got me interested in programming, I owe a lot to it even if by modern standards it's a pretty terrible language.

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

Actually, it's debatable on whether VB6 is "dead". Certainly not sold any longer, but Microsoft keeps including the runtime DLLs in Windows; they still exist in Windows 10.

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.

VB.NET is widely used in life sciences labs, where most of the systems are Windows machines connected to devices like this one.


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.

BTW - Microsoft will likely never open source VB, because it used and incorporated a ton of 3rd party stuff (pretty much all the VB versions did) - it's a licensing nightmare. The best they have done has been to keep the VB6 runtime DLLs available and installed (they're there on Windows 10).

Given that COM has become the heart of Windows APIs since Vista, and is how UWP components are compiled into, I doubt very much that it will die soon.

It's not open source or free, but check out Xojo - xojo.com - which is a kind of cross-platform spiritual successor to VB6.

Of course, Visual Basic lives on (as part of the free-as-in-beer Visual Studio).

Visual Studio has VB.NET - which is barely recognizable as VB for those of us who used VB6 or earlier back in the day (I started with VB3 on Windows 3.1).

You can run the original QBasic on your browser at archive.org:


It comes with a large collection of games & demos, including the gorilla game.

OK, I just gave QB64 a try.

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.


When I was little, my dad had a DOS PC in his office. I remember writing a quadratic equation solver in QBasic. It was so unbelievably fast compared to struggling with pen and paper. Truly magical!

Despite the enormous welling up of sentimental joy I feel whenever QBasic is mentioned, on a more professional note I still find it incredible when I meet a programmer that goes through their days without breakpoints, or an interactive debugger, or a REPL/immediate window to try stuff out, or the ability to jump to the definition or docs (in hypertext!) of a function. Heck, I know some R programmers that don't even know they're allowed to write their own functions.

BASIC is a rediscovery of last months to me. As "most programmers" I classified it as a language completely unfit for any serious work. It turns out there are quite a few successful and popular projects using BASIC for specific applications, such as micro-controller or mobile programming. I had to deal with some internal barrier to give these projects a try.

There's still a ton of BASIC code being used and maintained today. Most of it by businesses. Back in the day (70s and 80s) the class of code was known as "Business BASIC"; tons of compilers and interpreters geared for business use were available on all computing platforms (IIRC, there's a version of BASIC for the Cray supercomputers of the day).

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

You can still get BASIC compilers for embedded programming.

For example from MikroElektronika


For the last few months I've been looking back at old computer magazines from the 70's and early 80's, and it surprised me how much heavy lifting was done in BASIC.

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.

The first 2 or 3 Ultima games were written in basic as well.

QuickBasic was nice, but I was more fond of Turbo Basic, but Borland ended up killing it.

Ironically Microsoft did the opposite, they killed Quick Pascal.

Actually, they sold it off, and eventually it became PowerBASIC.

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.

Ah, thanks for the clarification. I lost track of it.

In my part of the world GW BASIC was more popular.

People will laugh, but I used QuickBASIC and 486's to build and launch an auto auction in Las Vegas in the early 90's... Built a file-based system ( a database really ) to hold car data and allow searching ( index files... ), printing of invoices... you name it... it really was a full featured, easy to use "language" and much more.

Using QBasic with the RadioHands tutorials was one of my first times programming, and also my first exposure to assembly.


I got my start with programming in QBasic. Now I work at a Prominent North American Enterprise Linux Vendor. FWIW I don't write much code that gets merged into anything important, but I wouldn't be working in the tech industry at all if it weren't for the curiosity QBasic sparked in me twenty years ago.

An Argentinian wrote a MMORPG in QBasic/QB64.


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,

Any one care to explain how this was done??

I remember trolling BBS's as a youth attempting to learn how to do the same thing, to no avail...

QuickBasic could do this (IIRC it generated an EXE that bundled a bytecode interpreter along with your code). The slightly later QBASIC, which was a cut-down version of QuickBasic distributed free with DOS, couldn't make an EXE. The best you could do was to make a .BAT file that invoked QBASIC with the right options.

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.

To be fair, when you're on a UNIX-like system a program written in bash or a scripting language doesn't look any different from a compiled C binary from the endpoint of the user - shebang lines and the execute bit were a honking great idea.

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 this feeling too. It was one of the big motivations for me to learn C, back then: the ability to create a real .EXE that didn't need an interpreter. That, and the lightning-fast startup time of compiled programs.

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.

Sure, but now you've got the problem I've been dealing with day-to-day: You need to launch your code using a specific version of the interpreter that has been pre-loaded with all the specific versions of the libraries that you need.

This is why Go's ability to compile to a self-contained, QuickBasic-like, exe makes it attractive to me.

There was a 'Compile' option in the File menu.

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.

QBasic was the free version included with DOS and was only an interpreter. QuickBASIC was the full commercial version which included a compiler.

I remember doing it, because my "DOOM killer" took up too much lomem to run it and the QBASIC IDE at the same time.

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

You paid money for the commercial version of QuickBASIC and you clicked the compile button.

The free version of QBASIC that comes with DOS didn't have a compiler.

QB 4.5 introduced the compile option, the version shipped with DOS didn't have it.

I don’t remember the details, but QB was an IDE with compiler, like any IDE/compiler suite. Building an exe was a menu command, I think.

You could generate a stand-alone exe, which contained a copy of a VM, or an exe which required BRUN45.EXE to be present, which was the VM. The advantage of the latter option is that you save a lot of disk space (iirc like 40 kB) for multiple programs, since you only need to have a single copy of BRUN45.

Wow, I didn’t realize it was a bytecode+vm system until now. That explains why the “compiled” exes did not seem faster.

I've had a lot of fun reminiscing with QB64, it plays most of the games and demo's and junk I wrote as a kid perfectly except the ones that have music.

As my profile says, qbasic has a special place in my heart. I spent many, many middle school hours and late nights in it before learning c++ in high school.

maybe we should have something like basic for lambda, but i guess lua fulfills that criteria.

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact