RAD Basic – the Visual Basic 7 that never was – releases third alpha RAD Basic has edged a little closer to bringing Visual Basic 6 back to your PC with the release of 0.5.0 Alpha 3. We last looked at RAD Basic a year ago and soaked in a warm bath of nostalgia for a time when Windows applications could be knocked out with the same skills needed to persuade Sinclair or Commodore hardware to …
VB was a great tool. Like Access, it often times takes the blame for management issues at companies. Enterprising employee X hits on an idea of automating some boring, tedious, and error prone part of their job, so they slap together a quick proof of concept type app in VB6 or Access. App works great, then employee leaves or the company won't shell out to take their prototype app and have it turned into something a bit more proper. Over time the process might drift and/or Windows is updated, and the prototype app slowly starts breaking little by little until people just see some generic error about the VB6 runtime or Access and blame the tool.
Blame the craftsman/woman's patron, not the tool or craftsman/woman.
I've no beef with BASIC – it introduced me to programming when the alternative was ALGOL. VisualBasic less so. But Access did have lots of problems being yet another nearly SQL implementation, with the nearly part confirming the "miss is as good as a mile" aphorism: data corruption was just too easy and it was too closely tied to MS Office and the Windows Registry.
BASIC though was really built at a time when very few programmers were around. Pretty much everyone was a beginner or a white coated boffin. Even in 71 or so when I was taught programming at school most of it was in low-level numeric form. BASIC opened up programme writing to the masses. They were all beginners, almost by definition.
...and it's never really been successfully replaced. What we usually see is some sort of Introduction to Coding being used with a "black box", point and click, drag the various boxes around to make a "program" type things, followed by some sort of actually programming language where it takes a week or two to tech the kids how to use the overly complex IDE.
There may well be something out there already, but if not, the equivalent of ROM BASIC from an early 8-bit computer with simple on screen editing, interpretive BASIC would be better IMHO. Maybe something along the lines of BBC BASIC with functions and procedures, WHILE/WEND, REPEAT/UNTIL constructs and sound/graphics commands leading from simple to more advanced concepts. Oh, and a proper, printed manual listing all the commands with working examples :-)
BASIC was designed to help young students become programmers, normally often moving on to other languages once they understood what they were doing and got a job. Certainly BASIC has a lot of issues but once you manage to write completely functional BASIC code then it's quite easy to learn another language in a day or two.
I've seen PhD researchers in completely unrelated non-computing areas quickly figure out how to write something that they need in BASIC - maybe BASIC's not "great" but it gets the job done.
BASIC was never designed to help people become programmers. It was designed to allow other professionals to use computers without requiring programmers. It was the Google and the WWW of the day: the power of modern computing without the high-level specialists. The line-by-line compilation, the time sharing system and personal user terminals were the web browsers and AI of the day.
At the time there was a split between the SF idea of computers as intelligent thinking machines, and the real world idea of computers that they were big calculators, tabulators, or accounting machines. The world of computing laughed at Kemény for wanting to put computers into the hands of humanities and social science undergraduates: they laughed at Kurtz for thinking it was possible.
It turned out that that BASIC as a user interface was so good that it was adopted by people who's full-time job as 'programmer', with enterprise solutions written in BASIC, and applications written in BASIC for portability, but the intention of BASIC was to make computers available to musicians and anthropologists and authors and every other kind of liberal-arts undergraduate.
Some sort of BASIC was pretty much the "standard" way of adding a programming language to hardware back in the days when Visual Basic was relevant. Lots of industrial and laboratory equipment was programmed using an embedded BASIC interpreter. Every vendor had their own slightly different dialect of it.
There was a whole class of hardware known as "single board computers" which were 8 bit micros intended for embedded applications. Many came with BASIC burned into ROM. This is old style basic complete with line numbers and GOTO, rather than VB of course.
Intel had a version of their 8031 microcontroller called the 8052AH Basic which had a BASIC interpreter burned into ROM on the chip and it was a big seller in embedded applications. At least one other major company also made the chip under license.
I used a lot of BASIC in embedded industrial applications. It's what was available and would run on very limited hardware. It also allowed for rapid iterative development on systems (manufacturing cells) which were often unique and expensive. You would connect to the hardware using an RS-232 cable and program it by typing directly into it. If you were clever of course you would actually do your editing in a text editor on your PC and set up your terminal emulator to "type" the text file into the embedded system.
If you drove a car in those days, almost certainly some parts of it were made by equipment controlled by an embedded BASIC.
Yeah, but VB was never especially BASIC-like even in version 1 and progressively swallowed most of Pascal and had started out on Java by version 6. All that was was left of any significance was the use of parentheses for array indexing (as well as function arguments) and the equals sign for both assignment and equality comparison.
-A.
This. True BASIC (like the "Locomotive BASIC" I learned to program on, on the dear old Amstrad CPC in the late '80s) is very much a procedural, run-time interpreted language. It would have no idea what you meant if you started talking about objects. You had integers, "numbers" and strings and that was your lot.
VB is an attempt at an object-based version, and its younger, more virile cousin, Visual Basic .Net is just a wrapper around the .Net CLR, for those who don't want to learn C#.
And to be fair to "real" BASIC, it does teach people some of the fundamental programming concepts that higher level languages might abstract away, such as how everything is just an integer under the hood (in the case of the Amstrad CPC, usually an 8-bit one, and occasionally a 16-bit one).
Learning BASIC led me onto learning the Z80 instruction set (in an attempt to write things that didn't take an age to run). I was a pre-teen at the time, so most of the things I tried to write just froze or crashed the machine, but it set me up for a career as a software developer later on in life, and although most of the things I do these days are in high-level languages, that basis in knowing how a computer actually works is invaluable, especially in writing efficient code.
All that was was left of any significance was the use of parentheses for array indexing
To be fair, most languages (e.g. anything with a C-like syntax) use square brackets for array indexing.
What BASIC did, was to start indexes from 1, rather than 0, even though the index is, under the hood, an offset, thus teaching a whole generation of programmers to put fencepost errors in their code.
To a non-mathematician, the first item in a list is "number 1", but to computers, and those who design their languages, the first item in a list has an offset of 0. The problem comes in confusing the two concepts for simplicity. That's the "B" in "BASIC".
There's this too - https://en.wikipedia.org/wiki/Xojo
It was formerly called REALBasic but was renamed.
I have no idea how good it is. I tried the Windows version and it had the fetid stench of Mac software ported to Windows but that was a loooooong loooong time ago, probably when it was still called REALBasic.
I really enjoyed my time doing VB6. I thought it was a lovely language for the mundane, and for causal programmers. It was easy to use and simple enough, even if the ultra-hardcore didn't like it, the elitists sneered at its "BASIC" naming and heritage.
REALbasic was what I moved to when VB6 was no more and because of its cross-platform capabilities. It was okay but expensive to licence and the developers seemed more focused on new features and releases than bug fixing. I can't speak for the Xojo incarnation having never used it but it's where I'd probably head if I wanted to relive the VB6 experience. I believe there's a free version for Raspberry Pi.
RAD Basic has probably missed its window of opportunity - its failed Kickstarter demonstrates that, and is doomed to go nowhere if not free to use, if it ever gets out of Alpha.
All the cool kids have moved on to Python and Qt, or are resigned to whatever-dot-Net.
I still have VB6 installed on my Windows 10 PC because I can't be bothered to port code which has worked for years to something else.
I remember trying REALbasic back in the mid-noughties. I took one look (a couple, actually) at VB.NET and decided I'd rather jump off a cliff. REAL looked much closer to "classic" VB, but, as you said, was sort of expensive. And at the time, it didn't have context-sensitive help in the IDE, which I had (lazily) grown very used to in classic VB. So I kept on using VB6 - as a network admin, nobody gave a crap what I used for my one-off admin tools. I eventually moved on to Powershell, which, eh, isn't a whole lot better than vb.net, but at least it isn't pretending to be an earlier language that it isn't.
The successor to STOS and AMOS, AMOS 2, is now known as AOZ Studio.
Go on, you know you want to.
Many times, one simply has a job to do and neither the time nor the resources to spend months or years on a "proper" development project or (over)generalization to things other than relieving the immediate pain at hand. With two colleagues I once threw er, put together a little system (a mixture of VB2, SQL, and Excel macros) that provided a way of solving the "46 Million Dollar Problem" at my division of a huge manufacturing company. The Division General Manager said our duct-tape, chewing-gum, and bailing-wire tool was the single biggest factor that saved the division's bacon. We put it together in two days. Corporate IT wanted to schedule a four-month analysis and eight-month development project requiring around twenty people and, oh yeah, they couldn't get to it for at least six months. We would have been out of business by then.
Think of BASIC et. al. as a tool for the ER versus something for the medical specialist.
HP Basic was a very powerful system ostensibly for controlling scientific instruments but quite useful for other tasks.
Similarly, Microware OS-9 (NOT Mac OS9) provided a similar advanced basic on a very Unix-like system that ran on 6809-based micros including the late, lamented Radio Shack Color Computer.
Don't forget GAMBAS for current VB-like BASICs. FOSS and cross-platform.
I think Gambas would have enjoyed more success if it ran on Windows and was a close to or a superset of Visual Basic's dialect.
Personally though I think the biggest issue for any Visual Basic clone is that the language is only half the picture. VB was so very limited so that Microsoft basically augmented the language with OLE2 automation and ActiveX controls and of course many 3rd party controls appeared too. So any clone would have to support that too.
Microsoft Edge Internet Explorer mode counts as using an emulator so if they are using that they really didn't get rid of Internet Explorer completely.
Old Opera used to be so good, unfortunately they turned into into a Chromium skin.
Even Midori is now a Chrome clone - -
We actually have less variety of web browsers today that what we had when Internet Explorer reined supreme. At least back then the paid Opera was good, we had Firebird/Mozilla, and others.
Nowadays we have Chrome, we have Chromium, we have Firefox and the Firefox clones and that's like 98% of all actively maintained Web Browsers.
Once you break the fundamental difference between 1:1 of machine code and 1:many of a high level language, you're pretty much arguing over the price.
There's nothing you can't do in VB6 that you could do in any other language, as long as you were prepared to import the DLLs and fudge the data structures. Although I admit the fun factor does vary.
Hell, I clearly remember subclassing in VB6 to remove the resize arrows over a form.
I wish I could remember the key points of computing ... repetition, concatenation, expansion, decision and ?????
Me too. I loved that I didn't actually need to know anything about how Windows actually worked. I just created windows, plonked icons into them, and wrote code that "did stuff".
With a tiny little DLL written in C to bit bash IIC using some pins of the parallel port, I created an entire teletext reception system (complete with simple script language) in VB.
I took an electronics class in college in '96 or '97. At the end of the quarter, when we were using ISA breadboards and building circuits that we could control from the CPU, we did the programming with VB. Or maybe it was GWBasic. Eh, been too long, but I do remember it was BASIC. I was the only one in the class fluent in BASIC, so my lab partner and I were doing all sorts of whiz-bang stuff with flashing lights and 7 segment LEDs. Fun times. I got a solid "A" in that class.
I forgot to add I found my CDs from back in my college days recently and fixed a 19 year old bug with the installer I'd put together for the Lottery Number Picker. I don't know what I was doing back then, clearly being lazy or worse thought is (as means my memory is up the shit) I knew less than I remember knowing :)
The bug would mean the images wouldn't load for the balls, you had to create a directory with a specific name and copy them into it. I wondered why I never fixed that as was simple case of changing where the ball images were in the code. I thought I could blame Windows 98 as that's what I was still on back then but in the VM I recently ran it in, is Win98se so I can't blame that.
For anyone interested :) (you won't be)
https://youtu.be/DHgl_Db05n0
and after I fixed the bug
https://youtu.be/Sj-f1JzFlS8
and the really old DOS version
https://youtu.be/qZTIfBZBLo8
That depends really on which country you are from.
In some countries education believes in using industry languages for education, while some other countries choose languages based on educational purposes. In some countries it depends on the school/college.
Both cases have their arguments for and against (including that industry languages training most benefit big business that can use cheap graduates with minimal training and might have changed anyway when students graduate/after that initial job, and counter argument that the educational purposes argument in practice often degrades to teachers not having to less frequently update/rewrite their courseware than actual educational benefit )
I see the point for keeping old code bases maintained, but otherwise there are better options for basically every use than Visual Basic/RAD Basic. Visual Basic is overly verbose, poorly supported and inefficient (it runs slower than even JavaScript or Python), newer, better solutions have supplanted it.
I should mention I started my career as a Visual Basic programmer, but I write mostly C# and JavaScript these days with a bit of Java, Objective C or Kotlin. When you're starting a new project, take a look at the tools available, I'm convinced that there is not currently any situation where VB is the correct tool for a new project.
And there is no such thing as a "VB Programmer". Programming skills are very transferable, if you know how to program you can pick up new languages easily, especially similar ones.
I'm a sysadmin, not a developer, but I occasionally dabble in creating tools to make my life simpler. From VBScript to PowerShell to Kixtart... whatever gets the job done.
My confusion stems from that I know I've written code, recently, in Visual Studio, and it was in BASIC. So... um... what's the excitement here? As far as I can tell, Visual Basic isn't even remotely dead. What am I missing?
Thanks for trying, but that didn't help.
I mean, I remember the days of having to have the VB6 runtime installed to run its code. Today we need the .NET runtime. I understand these are completely different. But in terms of "I type BASIC code into an IDE, hit compile, and have an EXE", they're the same.
So my question remains... how are these meaningfully different from a "OMG, I totally can't use Visual Studio because X, Y, Z" standpoint? Still writing code for Win95?
VB.net is VB that has taken a poison pill of Java. I can only speak for myself, but when it came out 20 years ago, I looked at it, and didn't see anything compelling enough to it to warrant learning Microsoft's "new" VB syntax and way of doing things, and un-learning several years worth of classic VB. At the time, VB6 would still install and run fine on Win2k and XP, so I had no reason to change. By the time Server 2012 came out, I'd gotten enough of a toehold in Powershell that I rarely ever used VB6 anymore unless I needed a tool with a GUI (before I learned how to do a GUI with Powershell). And, if memory serves (it's been 10 years now), you had to stand on your head to get the VB6 IDE to run properly in 2012 - it was aggravating enough that I eventually gave up and just kept a Win2k VM handy with VB6 loaded.
That's my story, there should be others.
Okay, so what I'm getting from that is that there IS a (significant) syntactical difference. That makes some more sense.
My use case (write a simple widget every few years) has me looking up syntax regardless, so I didn't see that change.
And - off-topic - PowerShell GUI. Man. I can do it, up to and including multi-threading but what an obtuse mess that is. I'd love a proper "Visual PowerShell" where the GUI code is just handled and the meat & potatoes is PowerShell. My needs are things like "make a convenient front-end for helpdesk techs for off-board ex-employees consistently." Just ask for a username, scan (Azure) AD, confirm it's the right user, ask for a manager, check licenses, check groups, record the data, extract files and e-mail history, shove that into a Sharepoint site, nuke the user, grant the manager perms... it's all of a hundred lines of real-world code, but speeding up the process by adding clickable lists of users so you can just search by first/last name... worth the results but takes way too much time to code in PowerShell. End of rant. <Grin>
Yes, some syntactical differences, if memory serves. Enough so that most/many VB6 programs of much complexity wouldn't compile cleanly under .NET. I didn't get far enough into it to learn the differences, I just remember even MS was saying it was nigh-on impossible to do a straight conversion from VB6 to .NET every time, even with their tool. But, eh, those memories are faded, maybe somebody with better knowledge can chime in.
Yeah, I have a couple of beefs with Powershell. My biggest, and the one that "proper" PS scripters look down their nose at me about, is I wish a million times over that if we declare a global variable ($Global:MyVar) in the "script" scope, then any references to $MyVar within the script or any functions/loops in the script would point back to $MyVar would refer to that global WITHOUT us having to prepend $Global: each and every bloody time we use it. Am I a lazy former Pascal and VB hacker? Yes! Blah blah blah, proper scoping rules for the 21st century blah blah? Don't care. I recall there is a hackish way to almost get that, but I can never remember what it is.
My other beef is if a function has a "Return $something" statement (or several), then that's all that should be returned to the caller, not whatever other messages may have write-hosted, popped up or hit the pipeline while the function was running. But again, the proper PS guys explain that away.
ISTR lists, trees, etc were a little easier in VB than in PS, but I think that's just because PS's syntax for it is slightly uglier, and there's no automatic code generation for some of the base stuff like VB had. I admit, I was impressed with how fast a GUI written in Powershell runs.'
I've got a "new-user" script that does everything needed for a new employee - AD account, local shares and groups, DirSync, add O365 license, setup mailbox, setup archive, send welcome email. It's sweet, but is command line only, since I'm the only one who creates new accounts.
Most of the bad stuff that happens with a particular language is due to it being pushed beyond where the language was intended to go. BASIC has its place, you can do quite a lot of stuff with it and the Visual flavor when it came out (originally not a MS product) was a great idea, its a bit like adding a widget set to a scripting language like TCL. You could quickly stir up adequate applications, you didn't need to fiddle with the code to get the API right, you just wrote (and the fact it had very un-BASIC like things like variable scoping was a bonus).
The trouble comes, as it does to nearly all programming languages, when people add more and more stuff to it. Eventually te language becomes and exercise in programming elegance rather than a tool for expressing problem solutions. I put it down to something that I've noticed over decades of work -- our version of "idle hands' make the Devil's work" is that you just can't stop programmers making tools (its often easier and certainly a lot more fun than doing the mundane stuff that pays the bills).
Why are people wasting their time and talent on projects that the world basically isn't interested in? If people wanted to use VB, they use VB.NET from Microsoft itself, not some clone written by a one person team.
Why not put your effort in an open-source Visual Studio alternative, for example? Or an SSL stack written in Rust?
Worked on a product 20 years ago which had a 'layered architecture. The UI was done VB6 and the core, computational code was done in C++. At least that was the initial intention. Over the years, the abstraction reversed and most of the code ended up in VB6 and very little ended up being done in C++. When I joined 20 years ago, VB6 was long out of support but they had some very deep and tricky VB6 customisations and were wondering how to migrate to something else. Not sure what happened but it's probably still going strong!
I remember back in the day it was very hard and time consuming to build visual interfaces in C so I would often program all the complicated logic in a couple of C libraries then if needed a Windows VB application could be hacked together in a few hours. As a bonus the C code was very portable so you could easily make a Linux/Mac version and in fact I did almost all of my Windows development on Linux with a cross compiler to build Windows libraries.
VB might have been sneered at by a few programmers but it got the job done especially for very niche things and it's better to have a working application written in VB than no application at all!
There are several examples of the great simplicity of the backend in 'C' and front end in VB that I have worked on in the day. We developed a data recording system, the backend (highly optimised) did the reception of data and writing to tape in C, exposed a few methods as a COM object and hey presto, VB can now make calls to stop/start etc.. Best of both - No faffing about trying to make the UI agreeable with the customer in C, and none of the complications of reading data from custom hardware and drivers in VB.
Another great example was a small warehouse inventory system, VB front end and Access backend, used only by a couple of people. I just worked and was simple to develop. Using other tools would have massively over-complicated the job (this was 2002).
Completely agree.
I started out as a C then C++ developer. Knocking up UIs in C++ takes forever compared to VB, so as soon as VB3 came out I switched to using that for the UI and anything that needed to to be fast or interact with a C API, I'd develop in C++ and wrap it as an ActiveX control (remember them? Eurgh!).
I'm maintaining and occasionally extending a few large VB6 applications for my clients. A lot of the code has been rewritten as VB.NET or C#, so I spend time working in both environments and switching between them. What's amazing to me is that in *some* ways, VB6 is a more productive development tool, even after 20+ years of .NET.
The Register 
Biting the hand that feeds IT
Copyright. All rights reserved © 1998–2024
