
QuickBASIC Lives on with QB64 - mariuz
https://hackaday.com/2018/02/22/quickbasic-lives-on-with-qb64/
======
rlopezcc
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.

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

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

~~~
MichaelMoser123
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/](https://processing.org/examples/)

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

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

[https://www.freebasic.net/](https://www.freebasic.net/)

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

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

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

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

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

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

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

~~~
cmrdporcupine
XE did not run 2600 games.

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

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

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

------
ErikAugust
A QBASIC/DOS inspired Bootstrap theme -
[https://github.com/kristopolous/BOOTSTRA.386](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](https://www.cachethegame.com)

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

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

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

[http://freebasic.net](http://freebasic.net)

GAMBAS is another for Linux that reminds me of VB6 a bit:

[https://en.wikipedia.org/wiki/Gambas](https://en.wikipedia.org/wiki/Gambas)

Wikipedia also has a list of BASIC dialects which shows possibly full range of
what was tried in BASIC variants on what platforms:

[https://en.wikipedia.org/wiki/List_of_BASIC_dialects](https://en.wikipedia.org/wiki/List_of_BASIC_dialects)

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.

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

~~~
Momquist
> _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](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/](https://godotengine.org/)

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

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

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

[http://www.phatcode.net/downloads.php?id=204](http://www.phatcode.net/downloads.php?id=204)

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.

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

~~~
crtasm
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)](https://en.wikipedia.org/wiki/Gorillas_\(video_game\))

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

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

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

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

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

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

~~~
exikyut
Do you still have the HDD?

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

------
rekado
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...](https://git.elephly.net/?p=software/windelprise.git;a=summary)

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

------
ubermonkey
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!

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

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

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

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

[https://www.biotek.com/products/imaging-microscopy-cell-
imag...](https://www.biotek.com/products/imaging-microscopy-cell-imaging-
multi-mode-readers/cytation-5-cell-imaging-multi-mode-reader/)

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.

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

[https://archive.org/details/msdos_qbasic_megapack](https://archive.org/details/msdos_qbasic_megapack)

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

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

Hmmm....

------
mgeorgoulo
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!

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

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

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

~~~
pjmlp
You can still get BASIC compilers for embedded programming.

For example from MikroElektronika

[https://www.mikroe.com/mikrobasic](https://www.mikroe.com/mikrobasic),

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

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

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

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

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

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

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

[http://www.petesqbsite.com/sections/tutorials/tuts/vicstuts/](http://www.petesqbsite.com/sections/tutorials/tuts/vicstuts/)

------
grafelic
An Argentinian wrote a MMORPG in QBasic/QB64.

[http://www.indiedb.com/games/guerreros-
qb](http://www.indiedb.com/games/guerreros-qb)

In itself a daunting task, considering the choice of language it is really
impressive.

------
cat199

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

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

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

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

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

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

