Hacker News Reader

Comment by rlopezcc | Hacker News Reader

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.

View on HN

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.

I found myself reminded of Blitz Basic.

https://en.wikipedia.org/wiki/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.

https://stackoverflow.com/questions/4899799/whats-the-best-w...

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.

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.

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

https://en.wikipedia.org/wiki/John_Resig

https://en.wikipedia.org/wiki/Processing.js

https://en.wikipedia.org/wiki/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.

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.

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

>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

Microsoft still ships SmallBasic, for free.

http://smallbasic.com/

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

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

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

https://sourceforge.net/projects/pcbasic/files/

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.

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

https://jugad2.blogspot.in/2012/09/lissajous-hippo.html

I also started on an Electron too, though we later got a juicier Master 128.

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.

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

http://nordman.tripod.com/qgames.html

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

Similar.

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.

Reply on news.ycombinator.com