BASIC is anything but dead
theregister.com
theregister.com
It was about simplicity, it was easy to make sound. To draw to the screen.
It was about accessibility. Computers with it would boot right to a basic prompt. To use a computer was to program, and you were certain to naturally be exposed to programming and learn by doing rather than in a classroom.
It was also about the fact you could easily open up other programs and read and modify them, much like older fashioned web and HTML.
That's why these new basic projects fail so often. Python is simply better, and the ease of use of modern computers and phones means that the push basic used to have is just gone.
Basic is being able to hear your data when you play it on a tape. It's about being able to cheat in your game by changing the code. It's typing code in from magazines and making games in math class. It's warm and fuzzy and you just can't bring it back.
but probably, looking back from old age, what i should have done was improve the algorithms i was using.
i think basic is a good thing. perhaps a bit sad that people today do not have instant access to it.
Drag a button on the screen, and with a click you could enter the code to run when it was pressed.
In comparison, lots of systems since then have been pretty powerful, but you exchanged that for layers (and layers) of complexity that many people never got through.
For example, I was pretty surprised the first time I used xcode. I thought it was apple - and they would make things easy. But in comparison to my first try at visual basic it was not intuitive, even after using it a while. (Did Steve Jobs ever try it?)
Many early BASIC implementations for microcomputers (such as tiny BASIC) prioritized memory usage over speed, so they tended to favor interpreters. But as others have noted, numerous compiled BASIC implementations existed as well.
Out of all the complaints I've seen about BASIC/Visual Basic, this has never been one of them.
OERN would make it so uncaught errors were silently ignored and execution would just continue on the next line as if nothing wrong happened. This would likely result in more errors, which would then also be ignored.
Something broke but we still moving to the next line.
However, if someone is going to learn, I'll bet they'll pick up python in a similar amount of time, and get a lot better tools when they do it.
BASIC was invented in 1963 and exploded in popularity in the late 70s. Python 1.0 didn't come out until 1991.
The commenter you're replying to argues that BASIC no longer has the advantages it had in 1963, which are unrelated to the language syntax, and that Python offers a closer alternative in that it makes programming accessible.
It has both value types and reference types and both can be passed either by reference or value, giving four ways of passing parameters compared to Python's one way.
It has both early and late binding, compared to Python which again has only one kind.
It has "default properties" on objects, which lets you sometimes use some objects directly in place of some of their properties but sometimes not.
It has different syntax for function calls in expressions and statements, combined with a completely redundant third way (the "call" statement) that confuses matters further.
And in addition to being both statically and dynamically typed (with "Object" declarations) it's also both strictly and loosely typed (with Variant values).
It was written in time with completely different paradigms and the two languages weren't even built with the same design considerations in mind.
Obviously, newer languages are going to tend to be easier to work with for beginners, that should be a given. We've made massive improvements in the field in the last few decades.
The whole point of this comment chain is to discuss whether BASIC was easy to use so it's clearly not a given.
Newer languages have the benefit of hindsight and rapidly improved technology. Better graphics, more power, fewer of the heavy limitations that came with early technology. Between the time that BASIC and Python first came out, we went from System/360 mainframes to Windows 3.0 on our home desktops. Obviously newer languages are going to be able to take advantage of this increased power and wider abilities of computers.
It should be plainly obvious to anyone who takes more than a second to think about it.
Because "easy" is a somewhat relative term. The category will shift over time.
The category shifts over time, sure. But what does that have to do with BASIC being easy or not? They're two separate topics.
"In hindsight, that wasn't actually easy. It was a massive opportunity for highly motivated learners, but the amount of motivation needed was more than what can fairly be called easy."
I'll compare to an early bicycle with no pedals. They were a breakthrough at the time, but in hindsight they hadn't reached "easy".
And just like making a better bike, plenty of the issues with BASIC could have been fixed on the equipment of its heyday.
And it's not just that things improved over time and you need to be new. There are very old bikes that are plenty easy. But it took a while to figure out.
Subroutines don't.
Is that a pointless distinction? Why?
Who ever needs to refactor BASIC!?
On the C64, I find even 6510 / 6502 assembly to be easier to follow than C64 BASIC.
Yes it was.
http://www.vintage-basic.net/bcg/superstartrek.bas
https://www.atariarchives.org/basicgames/showpage.php?page=1...
1964 BASIC did support single-line function definitions (see page 13.)
Dartmouth BASIC kept evolving into the 1980s and seems to have turned into a pretty capable language that retained much of the accessibility of the original. I wonder what would have happened if True BASIC had been a free/open source project instead of proprietary software.
Simple numerical/mathematical programs are certainly useful today, especially for students and researchers - BASIC emerged from Dartmouth's math department after all. Of course now we can run them on pocket calculators - some of which still run BASIC!
As I understand it, subsequent editions of BASIC running on Dartmouth's time-sharing system were used for a wide variety of applications, including:
- numerical programs (including scientific and engineering computation)
- simulations
- text formatting and document preparation
- statistics and data analysis
- communication programs such as online chat
- data storage and retrieval
- course management and grading
- games
- printing things from form letters to large signs
etc.
Regarding the limits of 1960s computing, it's worth noting that primitive computing systems, along with numerical and control software, were useful in helping to send humans to the moon and back (among other impressive accomplishments.)
Those are extremely basic functions that can only do a simple math operation on a single number. This is a function in the math sense, but not useful for programming.
Personally I'm kind of impressed that it existed back then at all, as well as the simplicity of original BASIC that enabled regular people to write useful programs, nearly 60 years ago.
Lucky gosub came soon after which left a return pointer on the stack, making things a lot better and basically being like an early function call.
Only problem was you could still goto around making life really confusing for yourself :) A lot of bad habits were learned this way :P
The appeal of VB lives on in WinForms with C# as the backing language. Initially MS tried hard to keep VB.Net around as a fully emancipated partner but it turns out everyone just moved over to C#.
I agree completely. The language itself was pretty crap, but there was nothing like it for rapid layout and wiring of a GUI. IMO, even modern tools like the storyboards and visual components in Xcode don't quite make it (they're more powerful, certainly, but also much more complicated to use).
Not very hard[1]; "making Visual Basic.NET not backwards-compatible with VB 6.0. This was literally the first time in living memory that when you bought an upgrade to a Microsoft product, your old data (i.e. the code you had written in VB6) could not be imported perfectly and silently. It was the first time a Microsoft upgrade did not respect the work that users did using the previous version of a product.
And the sky didn’t seem to fall, not inside Microsoft. VB6 developers were up in arms, but they were disappearing anyway, because most of them were corporate developers who were migrating to web development anyway. The real long term damage was hidden.
With this major victory under their belts, the MSDN Magazine Camp took over. Suddenly it was OK to change things. IIS 6.0 came out with a different threading model that broke some old applications. I was shocked to discover that our customers with Windows Server 2003 were having trouble running FogBugz. Then .NET 1.1 was not perfectly backwards compatible with 1.0. And now that the cat was out of the bag, the OS team got into the spirit and decided that instead of adding features to the Windows API, they were going to completely replace it. Instead of Win32, we are told, we should now start getting ready for WinFX: the next generation Windows API. All different. Based on .NET with managed code. XAML. Avalon."
[1] https://www.joelonsoftware.com/2004/06/13/how-microsoft-lost...
QBasic was really cool at the time. I wrote a lot of (very crappy and slow) games in it. The documentation was all readily available and it had a lot of power. QBasic (and VB) were very "batteries included" and that was amazing.
But, and this may sound harsh, I've always felt that BASIC was a language of desperation. You use it because it's the only thing available to you, not because you actually want to use it. There was a time where some form of basic was available on literally every computer. This continued well past the 80s with VBA and gave a lot of people the power of extensibility over their applications.
Back when I was writing a lot of BASIC code, I quickly found myself running into walls and realizing that it just wasn't a great environment to build anything serious in. The lack of a real compiler in DOS was the primary reason I found Linux and C in the mid 90s. Once I had my hands on a C compiler I never wanted to look back ever again.
(I know that QuickBasic and Visual Basic existed and could create binaries. But, I was young and couldn't exactly afford them. Before finding C, I was using a BASIC environment called ASIC, which wasn't quite as nice as QBasic, but could produce binaries.)
It makes me wonder how things might have been different for me if DOS came with a C compiler and something like raylib. The lack of a real (free) compiler drove me to Linux. Would I have still gotten into Linux? I don't really know!
QuickBasic and all the variants filled a niche that exists in multitudes now but did not exist in the early 90s. There weren't many high-level languages with garbage collection in common use.
But all my friends had pirated copies of every development tool. I don't know how we even got it all. We were lucky to be adjacent to a larger city and therefore have closer access to files and information.
Very small binaries. Unfortunately you had to include the rather large run-time libraries with them (BCOM*.LIB or vbrun*.dll respectively). IIRC vbrun300.dll was >300MByte which was rather large at the time, as well as the library functions it contained an interpreter and your executable wasn't fully native code (your code was transpiled to something the interpreter could process more efficiently, and the executable had a small chunk of native code to load the RTL and get it to execute the rest). IIRC VB6 was the first version to properly compile to native code.
QuickBasic was a paid-for, commercial compiler. It builds executables.
QBasic is a different product: a freebie with MS-DOS 5 and later. It's an interpreter.
Either way, what would start off rationally would end up in chaos. Part of that was the language, and Microsoft is to blame there; the fix, C#, came too late. But the other, larger part was the failure of component development. And that's what people miss and that's what still remains to be solved.
Because it wasn't a fix for VB - it was just the answer to Java.
Somewhat unfortunately, that "answer" swallowed the whole MS development ecosystem, and the VB world never really recovered.
Yes, it was an answer to Java but remember, VB apps didn't scale. They exploded at scale. And no matter how much you, as an organization, promised yourself you wouldn't scale up that VB app, it kept happening. So it was also an attempt to try to fix that.
I learned quickly how SLOW VB was, but was in denial about it. I wanted to make it work, but anything that required more than a few lines of logic made it impossible to maintain even 30 fps. At the time, though, I was afraid of C/C++. I thought "Those languages are too complicated! Why would anyone use them when VB is so simple?"
Yeah...I learned.
When I was young, I saw the same until I worked with a team of professional devs and the code was clean and performant and easy to get around in.
> VB4-based ERP system that was very slow
Yep. VB4 was made for the transition from Windows 3.1 to 95. The first effort was good enough but not great. IIRC, it compiled to byte code and then a runtime would interpret it. Once VB5 came out with native compilation, the resulting code became very snappy.
MS also had some awesome tech around DCOM in VB - transparent RRC was very futuristic at the time.
It’s the best drag and drop interface builder I’ve seen in an open source project and it’s cross platform and compiled to static binaries for easy distribution.
In BASIC land, the QB64pe project has a maintainer for Inform-pe, a pretty straightforward drag & drop interface builder:
https://qb64phoenix.com/forum/showthread.php?tid=1311
Here's an example running under QB64 (though not Phoenix Edition/pe):
https://www.youtube.com/watch?v=a9pNGBaIr94
Background on the Phoenix Edition:
https://qb64phoenix.com/forum/showthread.php?tid=259
There's also Purebasic and Gambas, though Gambas isn't cross-platform...
https://gambas.sourceforge.net/en/main.html
Zooming further out you have e.g. Defold and Cerberus X, which I'm not sure about the drag & drop but GUIs are certainly doable.
https://www.cerberus-x.com/community/index.php?pages/about/
Then there are Wonkey and wxBasic...
https://wonkey-coders.github.io/
Et cetera... :-)
Personally I'm pretty fascinated by the way these projects typically center around a traditional forum, with various software structures in place that shape the user experience.
For example, prolific library authors may be invited to publish directly to their own subforum and kind of use it as their own website, etc.
When new projects start, spin off, fork, etc, the forum is often the first part of the user experience to see created, frameworked and decorated in depth.
One advantage of this particular coding ecosystem is that you can use Delphi docs, techniques and tutorials as well, which can be helpful to know.
But if your specification is "cover all aspects of Lazarus itself at confirmed 1:1 functionality with the current major version" then it might be a difficult ask.
There are some really great resources out there, but they are not going to meet every definition of decent docs.
For me it was enough to watch some YouTube tutorials[1] to get the gist, identify some idiomatic workflows, start building, do a bit of searching in different documentation resources, and ask follow-up questions at the forum.
It's nice that we can also ask ChatGPT for help these days too.
1. I thought this was a good example of a set of YouTube tutorials demonstrating working with Lazarus: https://youtube.com/playlist?list=PLYT8oqHJjWzTsIzzGN-Y1wKM9...
The drawback is that there is usually relatively little information outside of the forum and uncommon that code is shared on things like github, instead code sharing is typically done by copy&paste on the forum, which makes it a bit harder to track and standardize conventions.
I wrote the linked article because I wanted to explore dead easy programming environments for people who liked BASIC and VB, partly because 40 years ago, I liked BASIC myself.
C++ is the anti-BASIC. So are virtually all modern programming tools. Vast complex hard languages designed by professionals for professionals. Anything with braces in it wasn't designed for beginners.
Python is also very much a C-ish Unix-ish tool, too. It's just that Unix folks are so used to this that they don't notice.
What does % mean? Oh, well, it depends. Where?
How do you print a number? Oh, well, it depends. You can use %d but also %f but only if you want so many decimal places...
This is ugly crufty stuff, but if you're used to that and grew up with it, it's normal.
Python only looks easy and simple if you're used to C.
https://www.folklore.org/StoryView.py?story=MacBasic.txt
and would give a lot for something contemporary and cross-platform along those lines which was likely to stay around. Thought that was going to be Runtime Revolution/Livecode, but that went back to closed source --- I suppose I should look at Lazarus/FreePascal (but I didn't do well with Delphi back in the day).
Applescript Studio seemed promising --- really wish that that had been opened up to make iOS apps.
If by BASIC you mean the line-numbered language with single-character global variable names, with no flow control beyond GOTO and maybe GOSUB, which encouraged, nay, demanded humans crunch their own programs by removing as much whitespace as possible to fit them in RAM, then it wasn't a good language.
If by BASIC you mean the block-structured language with most modern flow control features, normal ideas about variable names and scope, which allows people to write GUI applications in a short period of time using GUI builders and easy access to libraries written in other languages, then it is a good language, but still not my favorite.
No. I actually liked VB when I was a teenager. It was very easy and (using ms parlance at the time) quick to develop small applications. For me it was not much more from a mere toy. I know some people used it for serious purposes, but I'm sure many of these uses were makeshift prototypes that eventually nobody had the time or money to rewrite. I don't think many serious and popular apps were written in VB and were maintained for a long time. I don't think it was adequate for that purpose and I don't know anyone who thought it was.
I used to joke that anyone claiming to be a "Very senior VB developer" was basically saying, "I don't know how computers work".
While it was a funny way of blowing off steam (and indeed senior VB devs didn't seem to know things like calling conventions or static linking), therein lies the miracle of VB. People could make business applications without having to know that stuff.
Often enough, they had VB devs for the frontend, and the heavy lifting done in *.dll's written by more hardcore C++ devs. I guess it worked out well enough that way.
But VB did so much of the work for you. And it was BASIC, which I already knew well. So it was exactly what I needed to understand the fundamentals without having to boil the whole ocean at once just to get a window with a button on my screen.
Agree it wasn't really suitable for large scale projects (although it got used for them anyway heh). Somehow VB apps always looked and felt "wrong", like they were a cheap knockoff. But for learning, and writing quick non-commercial apps, it was just right.
All that said, I feel no nostalgia or desire to go back.
• no line numbers
• indentation-based code blocks for conditionals, loops etc.
• string/byte/word/float/boolean variables
• pointers
• arrays, hashes and record types
• editor with auto-indenting, code folding and immediate error highlighting
• a super-fast interpreter and the ability to compile programs
• 600+ function library covering hardware/OS calls, matrices, collections etc
Really, it was an amazing language and I was very lucky to start on it, as it made the jump to Turbo Pascal a few years later relatively painless.
GFA Basic v3 Manual - http://www.atarimania.com/st/files/GFA_BASIC_Version_3_Inter... GFA Basic for Windows - https://gfabasic32.blogspot.com/p/about.html
As others point out, many hobbyists still use variants of BASIC...I don't think we can claim it's the most practical language for most uses, but it has its niche for sure, and is fun to use.
Visual Basic, however, while at the time representing a _fantastic_ entry point to development (at least it was for me), has been legitimately replaced by other, newer models, some of which the article notes.
Before VB setting up a GUI application was hard and required a lot of specialist knowledge, then VB made it easy, and its replacements on the web are making it hard again :-). I still don't know an easy way to set up a web with a database that also allows you to go into depth if needed.
It is VB, but for Python and for the web!
Did that for a few years before moving on to AMOS (also a BASIC, though definitely more modern and useful -- it even had a compiler) on the Amiga.
The summer after Junior High I started learning C on DOS (Turbo C!) and at that point I was done with BASIC.
I don't think I could have started with C in grade school, BASIC is what got me hooked on programming :)
When I started using Python, I missed being able to draw my GUI with the ease of VB, but not for very long. I discovered that building a GUI with Tkinter was nearly as easy, except for the part about laying it out visually. But I also read enough critiques of GUI's, to know that my own layouts were actually quite mediocre, and that a simple top-down layout using Tkinter's defaults was usually no worse.
So, VB certainly got me to a certain point, for which I'm grateful, but I no longer feel a desire to go back there.
There's even the original BASIC version of Oregon Trail!
For a native BASIC interpreter, there's an enhanced version of Applesoft BASIC built-in to the microM8 Apple II emulator -- it has various enhancements including 3D voxel graphics and the ability to draw in SHR (Super Hi-Res) https://paleotronic.com/microM8
VB was great because it made easy stuff easy but it also made more difficult stuff possible. You could reference other libraries, of course. You could also directly call Win32 APIs. But you didn't need to that. You didn't need any boilerplate or ceremony -- you could drop a button on a form, double-click on it to add code, and make it do something without knowing anything about the infrastructure to make that possible.
As far as I know, there are no tools that do something equivalent now that aren't so sandboxed that it's a dead end.
Maybe, but it certainly isn't the new Visual Basic.
Even in (was Delphi, now) Lazarus, there's much more to know when you need to create a simple application.
After the low-level stuff it was MS-DOS 3.3, with DEBUG.com for assembling intel assembler, and later MS-BASIC, Turbo Pascal, C, and all the later languages.
BASIC still has a soft-spot in my life, I wrote a trivial implementation of BASIC in golang which is complete enough to be fun, but missing specific features for running things like the widely-reshared Star Trek game. Maybe I should setup a stretch-goal of completing a bunch of common games/programs and work on it some more.
BASIC was never my cup of tea, but I used it because it was all that was available at the time. And books of programs really helped.