30 years later, QBasic is still the best | Hacker News Reader

30 years later, QBasic is still the best

nicolasbize.com

317 pointsohjeez131 comments

I have my tiny share of a QBasic Story. Please read this with a light heart and don’t judge me.

I was introduced to Computers — as theories in school classes in the summer of 1992. By winter of 1993, my school got computers and I spent a lot of my time there, including many practices during the holidays.

I spend extra effort to learn things that were not taught in the school. I learnt QBasic and started writing tiny programs. My own trick was to use Graph Papers to match co-ordinates to plan game programs. One of them was a game where shapes are draw on the screen and you shoot it with an arrow. You have to hit spots on the shapes to do something - explode, write out names, etc.

I asked one of the girls to try it. She did and finally shoots a “heart” symbol and it burst with her name. I think I coded many things manually to make that happen and not very “programmatic”.

She became my first Girlfriend and we were for about a year. After that, we got drifted apart as we went to different schools in different states. No email, no phone.

originally Facebook was created to find people like this

romanticising the past eh?

originally Facebook was created to find out who is hot or not ...

https://en.wikipedia.org/wiki/History_of_Facebook#FaceMash

>They "trust me", Dumb fucks

Yikes, never saw those blog entries before. Talk about the pot calling the kettle black...

> My own trick was to use Graph Papers to match co-ordinates to plan game programs.

Yes, graph papers! I had an XT with a monochrome Hercules monitor, while in the factory where my father used to work there was a full blown 486SX. Envious of the plethora of the available fonts, I magnified the letters of the System [0] font with Paint, transferred them to a graph paper and took them home. Then for each character I wrote a separate (Turbo)Basic subroutine which would draw it in graphical mode exactly as it was on the paper. Finally I assembled these routines into an elementary editor. Nostalgia, yeah.

[0] https://en.wikipedia.org/wiki/System_(typeface)

I like BASIC and recently been thinking it might be nice to do some modern game dev on BASIC. My father got me into programming on a TI-99/4A [0] machine, so the BASIC language always has a place in my heart.

However, I recently also came across a nice game development course from Harvard, CS-50 [1] (an excellent course, much recommended!). And for CS-50 the Lua language is used in combination with the LÖVE [2] framework.

After previously dabbling with SpriteKit [3] and Swift I have to admit LÖVE has been extremely pleasurable and fun to use. It's really nice to get some quick results. And you can easily build for multiple platforms (iOS, macOS, Windows, Android, ...)

I also love that I'm able to develop just using SublimeText [4], a very lightweight editor and pretty serviceable for doing Lua dev ... no IDE required, just like BASIC.

It's a nice change of pace from the normal heavy-handed Xamarin (C#) / Xcode (Swift/Objective-C) dev that I do in my day-to-day work, making "boring" business apps.

---

[0]: https://en.wikipedia.org/wiki/Texas_Instruments_TI-99/4A

[1]: https://cs50.harvard.edu/games/2018/

[2]: https://love2d.org

[3]: https://developer.apple.com/spritekit/

[4]: https://www.sublimetext.com

There is SmileBasic for the Nintendo Switch.

+1 for the TI-99/4A, that was my introduction to computers and Basic too. I spent quite some hours typing in program listings from computer magazines from the library... none of which had versions for the TI or ever worked in the TI's odd Basic dialect.

You should check out QuickBasic: https://www.qb64.org/portal/

That project name is QB64. QuickBasic is from Microsoft.

Ahh, the good old 99/4a. I wrote many a game on the best and actually had the Forth cartridge for it. I had a dual drive setup which actually worked into about 3 years ago.

Tell me you had Extended Basic, the Editor / Assembler, the speech synthesizer, and the expansion box for the TI. :) I didn't have E / A or the expansion box, but I did have Extended Basic and the speech synthesizer, and just those were a lot of fun. Using a cassette tape as a storage device was kind of clunky, but it worked; I would have much rather had a floppy drive or 2. OTOH, I don't miss the primitive editing mechanisms. Line numbers suck.

Two cartridges were compulsory: Extended Basic and Tunnels of Doom. I also had the E/A and expansion box with floppies - which came in handy for loading subs on the fly in Extended Basic, as well as being a better setup than tape for ToD. It was a little awkward with the only "namespace" being line numbers, but it worked.

Hell yeah, I forgot about ToD for a minute there. I was obsessed with that game for a while in middle school. I tended to play with a friend of mine who also had a TI-99/4A, and we very quickly figured out the optimal party was 2 fighters, 1 wizard, and 1 rogue. I'm not sure how many times we finished that game.

It's amazing how many people love ToD. There's even a Youtube video of a guy playing the theme music on a music box: https://www.youtube.com/watch?v=euMH2fCERAc

I'm currently working on trying to get it to run in MAME. I have a TI-99/4A successfully booting to BASIC, but I haven't got ToD itself to boot yet.

I never played ToD, but recently I looked at some movies of this game on YouTube and it's really quite impressive how comprehensive this game is on the low-end hardware of the day [0]

---

[0]: https://www.youtube.com/watch?v=oa7MYYmB4XQ

ST4? How is the beta going? Smooth?

Me and QB had so much fun together. I would come home from school, have something to eat and then get back to programming one of my dozens of game ideas that usually went nowhere near being completed.

I remember how I spent one Christmas plotting a Christmas Tree scene with the gifts and everything on millimeter paper and then transferring and animating all that to QB in SCREEN 11 (640x480) graphics mode. My parents weren’t that impressed, but I was so proud of myself.

I envy that kid sometimes.

I owe Basic a lot. It got me into programming on our first family pc, a Compaq Presario around '94. QBasic was accessible on every windows installation from the command prompt. You could read the programming guide built into the editor and have your first running code shortly after. That was its true power.

One of my first programs was teaching me french words, asking me to translate them in a random order until I got them all right. It was truly magical.

I also made pixels move, trying to write games, but I quickly ran into limitations and problems organizing my code. If you like a small challenge, watch a few minutes of this video about a game called Noita, where in the beginning Q-Basic was used to create some simple physic simulations [1].

It was hacky yes, but I think if you're starting out, it's much more important to get something running quickly than learning how to do it the right way. When people speak of basic, they always seem to have the impression that you're spoiled for life after touching it, but I think that's wrong. You can always learn more and improve. It's breaking down barriers of entry, which is key. A simple editor, with an inbuilt help page and a run button is all you need.

[1] https://youtu.be/prXuyMCgbTc?t=102

Same for me, but ’93, a different computer model and I borrowed a Qbasic manual from my brother who was in college

I wanted to make a classic BASIC interpreter for Repl.it, and as I was slowly evolving it -- making line numbers optional, adding labels etc -- I discovered that I was reinventing QBasic!

Docs: https://docs.repl.it/misc/basic

Source: https://repl.it/@amasad/pg-basic

I made a simple BASIC interpreter in golang, and one of the sample programs allows you to enter BASIC into a browser and see a PNG of the output.

I called that "visual basic" even though it is nowhere near the same thing!

https://github.com/skx/gobasic

I had way more fun than I expected tinkering with it though, made me very nostalgic for the ZX Spectrum which was my first computer.

Basic was, and still is, an excellent language for introduction to programming. Yes, there are things you shouldn't do, but that applies to every programming language.

There is nothing quite so simple, pure and fun as the older programming languages. Everything is a little bit bloated today - but it is infinitely much better when done right than you could ever do with these old languages.

for introduction, kudos! just mastering the branch/loop/return you have learned the basics of all programming.

I agree. I forget when I first started playing around with BASIC, but it helped once I got to high school and had a TI graphing calculator. Those calculators have a variant called TI-BASIC and I had a lot of fun coding and playing my own “Guess A Random Number” game.

One must definitely beware of looking back with rose colored glasses. A couple years ago I came across the BASIC source code for Oregon Trail, and I thought, "Hmm, might be fun to convert it to C." Started poking at it, and... Blargh! It was pretty disgusting. I don't think the program, disgusting as it was, was really unusual or bad for the time, though, and I am certain I wrote similar code on my trusty TI99/4A and thought it was just fine at the time. But then I was just a little kid, and maybe it's just right for a kid, I don't know.

MECC was the organization that introduced me to computers. It was an HP 2000C timesharing system that could only be programmed in BASIC. I never used Oregon Trail but I did write my own game. I have to agree that a simple dialect of BASIC is perfect for learning, even if it's very crude by modern sensibilities.

Does Pascal serve that purpose better, and even now through Lazarus provide a very viable software development platform?

Maybe. If I wanted to stay BASIC, I'd probably go with Xojo.

A Commodore 64 emulator on a raspberry Pi connected to the family TV is what I used, with similar results. My boy was instantly programming and in awe of all the magic the words could weave. Boot straight into BASIC.

This one: https://cmaiolino.wordpress.com/

Qbasic was the easy step into programming, but it was with turbo-pascal that I had most fun. I still recall eagerly awaiting for the monthly magazine that brought a floppy disk with source code I could study and try. But the best part, in the IDE, was the documentation, every keyword had an easy to access text explanation and fully working example. Borland was really great at this, same happened with turbo-c.

But there’s definitely magic to Basic, from a sheet of paper with line numbered, easy to understand (closest to language), instructions you can copy into a simple ide, to immediate results. There’s no entry barrier.

Such a nice story to read, thanks op.

Promitive as it was, QBasic had the right mix of commands people wanted (drawing, colors, music, file access), with the immediacy of running and seeing where your errors were (stepping through code) to make many a beginner coder motivated enough to stay with it to learn and develop beyond. I'll always owe it a debt for being my outlet through my middle school years.

The warm feeling inside when I just see the word “QBasic”. Prior to QBasic I was always drawing and tinkering with physical objects. QBasic made me realize that computers are just an other canvas. One where you aren’t just a consumer but a tool that allows you to contribute, create art, build useful little programs and games (to play with my siblings during rainy days). As a 10yo then, it felt I could conquer the world. Magical tool.

This is exactly what i feel. I discovered qbasic shortly after I played with super mario on NES and I thought that qbasic could be my gateway to create games.

Funny I ended up developing LOB apps instead of games because eventually my interests led to databases and dynamic apps.

I guess if tools like unity or real engine existed back then I might have been a games developer. Maybe. Now i still play around with unity but not as much as i want to because of several side projects.

Antirez (of Redis) made Load81[0] for this reason; I can recommend it; batteries included and modern. I did a lot of prototyping on it on the OpenPandora while traveling and a few of my friends said their kids picked it up as easily as they did Basic.

[0] https://github.com/antirez/load81

QBasic was so much fun. Also because pre Internet time, the included help for each command was so good.

Just the random number generator was no so good.

  SCREEN 12
   DO
    x = RND * 640
    y = RND * 480
    c = RND * 16
    r = RND
    PSET = (x,y),c
   LOOP

enjoy :-)

https://imgur.com/a/SSfaewf

What a classic. Definitely done this back in the day, but likely using WHILE or just straight GOTO.

> QBasic was so much fun. Also because pre Internet time, the included help for each command was so good.

QBasic wasn't pre-Internet (I had access to the internet before it was released.)

QBasic was pre-web, by three years, though.

BASIC is a good place to start, but so is Logo, and there are plenty of modern Logo interpreters such as https://turtlespaces.org

Second this. I myself started with logo when I was 7 years old. Gratification was way more "immediate" than BASIC. After a bit, I moved into Basic, where I spent days and days doing small games, until a family friend introduced me to C and I found Allegro.

I miss those days...

I had a similar Logo -> QuickBasic -> C(DJGPP)+Allegro trajectory early on. What is the modern equivalent for kids today?

Red is based on REBOL is which was based on Logo.

Must have been around 1997. My dad was in his 40s then and had never programmed or learned coding, but is a tinkerer at heart and used to love to make small IC devices after his day job (which was not related to technology at all). He learned it, loved it so much, and created so many nifty little pieces of software - a file encryption program, an alarm clock, a stop watch, tiny fun games etc. He used to be so excited to show me his programs (I was 7 or 8) and helped me to pick it up as well.

Later he started learning C++ to write more advanced programs, and although he did create some programs, I could see the complexity putting him off. Just the knowledge that that was the real programming, and that he was not enjoying it any more discouraged him, and he stopped coding altogether. It makes me sad. I wish he could have stuck with Basic and just created more cool stuff with it. There definitely is just something so cognitively easy about QBasic.

I will never forget the day that I spent debugging an early QBasic program that included a line similar to

  5 = x

for an assignment in the first draft. There were tears and deep frustration at the moment I discovered that assignment had a directionality. The author's story brings back so many memories of learning and growth.

For those too young to know -- magazines used to come with page-long Basic programs for games that you could type in, debug (there were always typos), and play.

Honestly it's pretty strange that assignment has a directionality.

It has to though.

X = Y; // what should change?

X_{t+1} = Y_t

Doesn’t have to.

You say nothing has to change, but what you write to support it is explicitly that X changes based on Y, since you are just making the time sequence explicit in the code instead of implicit in the operator syntax.

In a declarative language, nothing.

But computation has an intrinsic directionality. If you have two expressions a, and b, and you want to unify them in a declarative language as a = b, then having an unknown subterm in one or the other can make the computation have a completely different complexity, making one direction easy and the other intractable. The P vs. NP problem is a famous question exactly about this directionality.

Here's a simple example (in a declarative language that allows non-terminating computation; in a total language similar examples can be given, except "impossible" means intractable rather than non-computable, which, for all intents and purposes is the same):

    X = terminates?(P(1))

If X is known then finding a P is easy; if vice-versa, finding X is possibly impossible.

Oh, I meant in the special case of something that can only be an r-value on the left such, such as a constant or function result. But yeah, it could still confuse newbies, because the problem is not understand that it's procedural.

Whichever isn't currently bound to a concrete value, or neither (except that they become bound to each other) if neither is; if both are, it's an error should occur, since they cannot be unified.

The primary difficulty that I had was the overloaded usage of the "=" character. I had a clear mathematical understanding that the "=" symbol was symmetric, that 5 = x and x = 5 were equivalent. That someone could abuse that notion so brazenly was the source of my frustration.

Some languages use directional notation for assignment (see [1]):

    5 -> x

is clear.

[1] https://en.wikipedia.org/wiki/Assignment_(computer_science)#...

Pascal and related languages use the notation

  x := 5

I have heard that this was to mimic (in ASCII) the look of an arrow:

  x ⇐ 5

My first thought was, if they wanted an arrow why wouldn’t they go with:

    x <= 5

But of course, that means “less than or equal to”.

You could do:

    x <- 5

But I suppose the mere presence of the “less than” symbol is weird in context. (Although, maybe not inherently weirder than using the equals sign for something other than equality?)

Perhaps we would have been better off if we’d all just agreed early on, that @, #, or ~ should represent assignment.

The original 1963 version of ASCII had a left-arrow (←) symbol, but it was replaced with underscore (_) in the 1965 version.

One of the reasons I still quite like Pascal.

I know it's more verbose, but I'm deeply fond of Applescript's syntax for assigning variables:

    set x to 5

The first time I saw X = X + 1 in a ZX Spectrum basic program listing, I thought it would cause the computer to catch fire.

I was 9 though.

Zx Spectrum was actually less confusing because it required LET before variable assignment.

Ah yes, it might have been GW-Basic then. My uncle had a ZX Spectrum I would play with but the books I could get were all for IBM PCs.

My dad was offended that such an algebraic abomination should be the way the computer represented things. I started putting the LET keyword in front (which was strictly optional), and it bothered him a lot less.

Just introduce your dad to Prolog.

> I thought it would cause the computer to catch fire

Star Trek taught at least a couple generations that if you pressed the wrong key or programmed in something illogical the keyboard would burst into flames and throw you across the room.

I got my first computer in 1995, but it wasn't until 1998 that a classmate told me about QBasic. I remember my first "program" was a text-based RPG, except I didn't know about variables so it was basically just a digital choose-your-own adventure book where I enumerated all possible outcomes. I must have written a few thousand lines before looking at some of the pre-written programs and the help manual and learned how foolish I was.

The next few years would be an escalating arms race among friends for who could make the coolest game, culminating with an extremely slow ray traced 3D shooter

I became pretty good at programming, but having matriculated into college in the early 2000s when software engineering was somewhat unpopular, I'm a physicist now. When my son gets a bit older QBasic might not be a bad starter language

you should've seen my programs before I learned about arrays.

The big advantage for using BASIC to teach young children is its concreteness. In my experience, some kids have trouble understanding nested blocks (for example in Python, why the stuff in an if block is different than the surrounding code). With BASIC and GOTO everything is explicit and concrete and at the same level. They just have to trace though the program one line at a time to understand it.

I also find the idea that “if you teach kids bad procedural programming, they’ll form bad habits and struggle with modern languages” to be specious.

I grew up with BASIC (Q and TI), then learned a small amount of MATLAB as a physics student. When I took a class in Scheme later in college, I was blown away by how its syntactical constructs prevented me from making the kinds of errors that plagued my imperative/procedural programs - at the cost of some cognitive overhead.

Cutting my teeth with GOTO didn’t make me resistant to structured (or functional) programming, it gave me perspective on why it’s often necessary.

Strongly agree. The constructs are easy to move past, and worth the simplicity you get with the initial learning curve

I must admit that I'm ever so happy to have seen this post, QBasic was massively important towards me becoming a programmer. Kudos for the post, it's important for me to know that my nieces and nephews might see computers the same way I did: through an uncomplicated lens.

The appeal for me was to give, as you wrote, a simple interface to programming. The Apple RAM II I had was not as easily accessible for programming at my single digit age. QBasic was available on the 486 SX based MS-DOS OS we had, and it opened my eyes. Within a year or two I was reading Herb Schildt' "Teach Yourself C" and using Borland C for the first time. But at a young age you need that first step to be accessible!

Nice one...

Not sure you are aware but there is a modern single board computer you can buy or build that boots to MMBasic which is a modern elegant and performant Basic heavily inspired by various Microsoft Basics.

The computer is called Colour Maximite 2 and has a small but devoted community that’s constantly improving the platform.

You can purchase CMM2 from a handful of vendors or make your own.

I highly recommend one for a kid that is starting to dabble with programming.

Kind of a homepage:

https://geoffg.net/maximite.html

8 bit guy review:

https://youtu.be/IA7REQxohV4

Scratch is also pretty good if you need to deal with many kids and can't have a prepared / common experience on devices. I introduced a group of ~12 to programming and the initial issue is that not all of them had consistent access to laptops, or much experience with longer typing.

Being able to start with any tablet was great for that group.

The post reminded me to look up a game called Black Annex, which was being developed by a solo developer in QB64.

A previous post: https://news.ycombinator.com/item?id=17164068

https://store.steampowered.com/app/248590/Black_Annex/

https://www.pcworld.com/article/2033318/black-annex-is-the-b...

https://www.youtube.com/watch?v=ZqlveWIhCFI

Lance, if you see this thread - I hope you find the passion to continue this project. What you built so far was an incredible feat.

This is great.

I learned on Basic XE on an Atari XE, then GFA Basic (2, 3, and 3.5) on an ST. I still find reading Basic code to be considerably easier than most other "starter" languages. GFA was remarkable for its time, with its compiled code executing with performance rivaling some of the C compilers on the ST.

Hi, long time reader but never posted before. When I started working with computers in my first job in 96, I discovered QBasic. Then by just following a sample program on how to play music notes, I was able to make the PC play a custom song. What an exciting discovery! Too bad the program could only play beeps and didn't support polyphony. Then I think this was my first "hack" into programming: I created a version of the Christmas Carol "Joy to the World" that sounded like 4-part harmony by simply making the duration of each note comprising a chord to the be very very short, and then between notes (chords) I added a rest (silence) so I could distinguish each separate note from the melody. It sounded like arpeggios. Fun experience, but too time consuming.

I think that `20 GOTO 10` is the single best line of code to start programming with. It yields lots of thrill learning that you can repeat whatever you want.

If anyone was ever alarmed by the GOTO et al within BASIC, it's worth remembering that the 'B' stands for "Beginner's". I think the language serves an excellent role in firing the curiosity of an amateur, whether young or old.

GOTO is like weed - some people swear it corrupted the minds of a whole generation, others are just like "Whatever" and moved on.

Ca. 1990 I wrote an X.25 Network Integrity and Performance System (NIPS) in QBasic. It polled the PADS (Packet assembler/disassembler) for statistics, and displayed traffic and error conditions on the control monitor. Worked great.

I just bought ZX Spectrum Next issue 2 on Kickstarter. When I got it delivered my daughter turn 5. I think that it was good move, I also started with Speccy 33 years ago. Thanks to my dad which keep sitting next to me while I was trying to code I am a dev. I will not set the only way (my way), if she prefer taking care of animals or writing diaries I will not push her into STEM, but I will try to show her that having technical job pays off

What? Lock this man up for not teaching his son Haskell first!

I jest. People take the whole "imperative bad!" thing a little too far. I have fond memories of QBasic and certainly cut my teeth on it as a child. I did more TI-Basic on my graphing calculator since I could do that on the school bus. It can't have been too hazardous for my development since I independently rediscovered the idea of the "game loop" in my meddling.

I started with GW-BASIC on a PC. QBasic is so modern :D

Ditto.

Besides some Scratch early on I really got into programming in TI Basic on my graphing calculator and it was pretty great. Minimal learning curve to start writing useful programs, and sets you up well for high level languages. That being said I would probably still recommend Scratch for teaching kids to program, and Python for adults.

The weird thing about QBasic is that it came out in 1991, when Windows was already well established. So even though I started developing in the 90s, I immediately used Visual Basic and never even heard of QBasic for at least a decade or so later... maybe more. Lately there's been posts on HN reminiscing about QBasic, which is great, but it seems almost like a niche group of people who in the 90s were still using DOS a lot. (Which, granted, was a lot of people). But I completely missed it - it almost feels to me like it didn't exist and someone retconned history to add it in.

Now TRS-80 BASIC? Or Delphi? PowerBuilder? Or - wait for it - LotusScript? Now there's some languages to celebrate! (Joking, of course). I used all of them, the latter ones to make a living at one point or another.

> Lately there's been posts on HN reminiscing about QBasic, which is great, but it seems almost like a niche group of people who in the 90s were still using DOS a lot. (Which, granted, was a lot of people). But I completely missed it - it almost feels to me like it didn't exist and someone retconned history to add it in.

VB costed money, Qbasic came free with the operating system. There was an active QB scene well into the late 2000s owing to the fact that many poorer families would buy secondhand equipment that had Qbasic on it totally free.

Windows was not “well established” before 3.1, which was released in 1992. Arguably, even after that DOS was still important until Windows 95.

The weird thing about QBasic is that it came out in 1991, when Windows was already well established. Windows wasn't that well established in 1991, and QBasic was a direct replacement for QuickBasic (and VB was the premium-cost replacement for the Professional Development System that was the upmarket companion to QuickBasic), which itself was the successor to GWBasic on PC and there's probably a fair amount of conflation of them in people's memory.

> it seems almost like a niche group of people who in the 90s were still using DOS a lot.

It wasn't really a niche group that was still using a DOS a lot before about Win95; Win 3.1 was separate add-on on top of DOS, and lots of important software still targeted DOS exclusively or had separate DOS and Windows versions.

I ran across http://www.hedycode.com/ which is another take on kid-friendly programming languages. I ran the first few examples and it looked interesting - plus it runs in a browser so no archeology needed :)

I learned programming via BASIC (not QBASIC, on a Modular One https://www.wikiwand.com/en/Computer_Technology_Limited)and I agree it is a great way to learn how to write code (look at all those little kids who used to dodge into WHSmiths in the UK and write small, rude programs!)

But the thing that always pissed me off was that it did not support proper functions (one-liners, yes) to the extent that I wrote a preprocessor in BASIC that did support them (rather badly).

One thing I have always stressed to the many people I have taught is "Write functions, write lots of functions, you cannot write too many functions!"

Logic is logic. If you learn logic in if then else, goto, gosub-return, it's all good. These are still basic building blocks of logic.

If you get the logic part of programming, you can pick up the more complex aspects.

I'll just leave this here... https://www.youtube.com/watch?v=-vDpzoYgNd0

Love it! I started out by manipulating simple games in qbasic. Then switched to Visual Basic and made my first serious yet small projects. In the meantime got into web design and always thought I was doing something wrong when creating a UI with HTML & co - so painful compared to the drag and drop UI creation in Visual Studio. Same when I've learned Java: UI creation was a nightmare. Sorry for going off rails...QBasic was just awesome!

I wonder why not qb64... ( https://www.qb64.org/portal/ )

I can't help but notice that many of those who breathlessly exclaim that starting with GOTO will cause brain damage started with GOTO themselves.

I also notice that, "I did [x] and ended up fine" doesn't seem to consider the possibility of ending up better than fine without doing [x]. Still, I greet these arguments with suspicion and find them somewhat self-destructing.

I sound like an old fart saying this but, "When I was a kid, GOTO is all we had AND WE LIKED IT!"

The whole "don't use GOTO!" thing is really something that started cropping up when we started to get C and Pascal compilers, and it became something not as good to use. Before them, it was BASIC all the way baby, and we used GOTO because it worked for what we had.

I learned to program from two QBASIC games that were on the school computers, Nibbles and Gorillas. My friends liked to watch me make mods for the games or code from scratch, so I was doing "live coding" from the beginning. I think it must have shaped the way I program, giving the mindset of explaining what you're doing and why as you go.

My first computer was a used 286 - no Windows, just WordPerfect, Oregon Trail, and QBasic. Between that and the TI Basic on my calculator it really cemented my love of code. (I had just taken a class in high school teaching Turbo Pascal; I grew up in a super poor family where everything was out of reach unless I put the pennies together myself)

At least QBasic gives you modern-style loops, no requirement for line numbers, etc.

It's a good starting point and it won't force bad habits on you. It's really too bad that Microsoft never managed to make VB.Net anywhere near as clean as QBasic/QuickBasic or the DOS version of VisualBasic.

QBasic was my first language, and I don't knock it for the purpose it served at the time, but for a new programmer, I'd point them at either JS (if they really want to do web things) or Python. BASIC had its time, there are better languages now, and that's ok.

Better languages sure but more difficult ones. I don't do Python very often but there is a still a lot to unpack there. JavaScript is in some ways easier but some ways harder.

QBASIC is on a whole different level.

When my daughter was little, I taught her how to program using Visual Basic longer after it was obsolete. But getting a window on screen and interacting with it is 100x easier there than with Python.

Seeing this post and replies makes me feel like I'm part of a qbasic reunion, which had such a wonderful and enduring effect on me. Reading this article brought back that feeling of having my imagination captured and a whole world opening up to me.

I learned qbasic (my first programming langauge!) in middle school in 1999/2000. I guess our school district's shitty budget that resulted in seriously outdated computers did have some benefits.

(2016)

Really? Has something changed?

I got a Dummy's Guide to QBasic and wrote a very simple text-based RPG in like 5th grade. (a simple weapon shop plus battling monsters and a simple plot)

Ahh, QBasic, gateway drug into programming for many of us.

BBC Basic on the BBC Model B was the equivalent in the UK

Lovely post and like everyone else here I cut my teeth on qbasic as well. Great idea to bring it back to teach young ones the basics, pun intended :P

My first language. I had a QBasic book for children and an Epson Equity and would spend all day making toys and whatever I wanted.

Could Why’s (Poignant) Guide to Ruby work as an introduction to programming for kids?

And you can run it on your iPhone/iPad using iDOS app.

I would argue Python could be comparably rewarding. Even Go, if you go beyond the initial hurdle why there has to be a main.

Both do not offer a nice IDE out of the box though.

Who used VB macros in old ms word?

Not to be contrarian, but Python is even simpler than Basic. You don't have GOTO, but you don't need it. Just using a subset of Python language you can do anything you need, and with less syntactic noise.

How do you draw a line on the screen in Python? Here's BASIC. I'm not saying this is good. But it is easy.

  SCREEN 13 
  LINE (X1, Y1) - (X2, Y2), COLOUR

> How do you draw a line on the screen in Python?

Using only stdlib:

  import turtle
  turtle.penup()
  turtle.pencolor(colour)
  turtle.setpos(x1,y1)
  turtle.pendown()
  turtle.goto(x2,y2)

I am guessing that is straight-up LOGO on Python.

Not exactly, but the turtle library was inspired by Logo, and designed to enable fairly direct translation of Logo code.

It is turtle library inspired by Logo alright, but important thing is that it was available from very early versions of python onwards, and by default available when python is installed.

I didn't realize the lib was in there by default. It is instantly recognizable as Logo, although the syntax is clearly python.

This video from Mathologer about solving polynomial equations might be just as easy to implement in Python with that library as it would be under NetLogo (a more multi-dimensional science-oriented implementation of Logo), which certainly justifies having a turtle library to begin with: https://www.youtube.com/watch?v=IUC-8P0zXe8

I'd hate to program that under BASIC.

I tried it and it works. But that drawing window seems almost broken. It doesn't repaint properly when I resize it, and closing it seems impossible.

This is where a lot of modern languages are hard for kids. You have to find a library to do things you want to do.

It obviously depends on the Basic version but I think it's hard to argue that Python is simpler than Basic in general (e.g. OO, FP are quite complex topics for newbies) plus all the libraries - it's a lot for a beginner to take in.

I do think that there is an interesting point around whether you could usefully define a subset of (say) Python as a better first language. I've not seen anyone do that but seems like might be worth trying.

BASIC was my first language, and today my favorite is Python. Not to claim better worse, but I can think of some differences from a teaching perspective:

1. BASIC was typically either built-in, or accessible via a single command from the disks that came with the computer. Beginners often get lost trying to install Python. If three beginners independently google "install Python" and follow the first blog that comes up, they will get three mutually incompatible installations.

2. The BASIC interpreters were self contained -- you learned a small number of keywords, and everything else had to be composed from them. Python is huge, and some of its keywords are conceptually brutal for beginners. And that's before you introduce even a few of the familiar packages.

3. Look at the official list of Python keywords. Half of them describe concepts that are brutal for beginners.

I'm not saying progress is a bad thing. The Python ecosystem can be bigger today because code is so easy to transport. It needs to be bigger because more complex programs need that stuff to have a chance of working. But teaching Python involves a dilemma that didn't really have to be considered for BASIC: What small subset of this thing do we try to teach?

We end up with a subset that looks like BASIC, and we simply tell them how to install it so they have a reliable starting point.

> you learned a small number of keywords, and everything else had to be composed from them. Python is huge

QBASIC has 60+ keywords, Python 3 has 35.

> Look at the official list of Python keywords. Half of them describe concepts that are brutal for beginners.

Here's the list:

False await else import pass None break except in raise True class finally is return and continue for lambda try as def from nonlocal while assert del global not with async elif if or yield

Which of them do you think “concern concepts that are brutal for beginners”? (I could maybe buy async, await, and yield.)

OTOH, QBASIC’s BLOAD, BSAVE, PEEK, POKE, and CALL ABSOLUTE, among others aren’t particularly dealing with beginner-friendly concepts.

Good reply. Maybe the passage of time has smoothed my memory.

You can teach beginner programming with a subset of what python offers. Same with Ruby. Printing to console, assigning to and mutating variables, looping, conditional, and basic arithmetic require few keywords and very few extra symbols.

Those two languages make easy things simple. Basic does too, but with a not more noise ($).

You also don't need top install any language these days if you just want to learn. There are web based environments like repl.it where you can learn and practice basics.

No way. Qbasic has built in graphics and sound. Putting pixels on the screen is way simpler than python.

> Just using a subset of Python language you can do anything you need, and with less syntactic noise.

Okay, I'll bite. How does one check for keyboard input without blocking in Python?

And remember, you said "simpler" and "subset", so do your best to avoid imports.

Turtle is packaged with the default python distribution, for as long as I can remember, so I don't find importing it that much of concern in this case. It is like importing math.

That doesn't answer the question.

Reply on news.ycombinator.com