
No no no no no no no NO!
VB was shit then, it will be even more shit now.
Many moons ago, I wrote the same program in VB3 and Delphi as a comparison. The Delphi version was orders of magnitude faster on the same PC.
The beast is back... almost. A "100 per cent compatible Visual Basic 6 solution" has been promised to the backers of a Kickstarter. There is, however, no word on how much it would cost to ensure it stayed dead. Visual Basic 6 was the last hurrah in a succession of languages first introduced in 1991 and seemingly killed off …
VB5 and 6 did keep me busy for several years. By writing C++ to get around VB's very restricted subset of COM and using the much more powerful debugger to debug things that the VB6 debugger couldn't help with.
One of the latter cases was the first bug I used the internet to help solve... using Lynx (no GUI browser for me!) to find the offset of the reference count in VB6 UI components.
And thus work out which set of components were stuck with circular references (app worked fine in the VB6 IDE, but the built version would crash on exit every time).
The right tool for the right job. Look how hard 'codeless' development keeps being pushed. VB wasn't that far off the mark, just plumb all the events and off you go.
For small applications fronting a simple database it was ideal.
The problem was when people tried to write stuff that should have been considered beyond the scope of VB.
It was really really easy. Horses for courses of course. I wonder whether my code is still used, but when at the job, had exactly ONE complaint (a logical error). Otherwise worked flawlessly.
Dumped it the moment I saw .NET. And by then was mostly using Linux.
There is GAMBAS on Linux, never tried it seriously, though.
Well, as long as your company doesn't have Eur 5000 annual revenue: (from the license text:)
"Once your company's total revenue reaches US $5,000, or your team expands to more than 5 developers, you can move up to an unrestricted commercial license with Professional edition."
which is kind of well, always. (it doesn't say only the revenue of Delphi program counts)
My version of Breakout written in AMOS got me a job at Bullfrog back in the early 90s.
It had a double height scrolling screen that followed the lowest ball, and I wrote all the scrolling, multi-ball and bat code in their asm-esque interrupt language (AMAL iirc) that used the Amiga hardware directly.
It made it easy to write software on what was, to me, a completely alien system. It wasn't perfect, certainly [*], but it did the job with the minimum of fuss.
* - I've never met a mainstream language before or after that didn't have any support for binary shifts. Extracting data from a bitmap using integer division and rebuilding the bitmap using multiplication was tedious and painful.
I got started on it. It was so easy to make GUI applications that you could draw the GUI, add some code behind the buttons and you've got a program in like five minutes. Press F5 (?) and you're running.
That you could make real programs that looked like real modern programs was important. The alternatives, such as Python, were (without substantial learning) CLI only interfaces meant that they felt old fashioned.
It was so easy to get started with that I remember at first I didn't know what a variable was so I was using hidden text boxes as "variables". With that level of ineptness, i was still able to produce things that worked with a little bit of help from Google ( or was it Ask Jeeves? or Yahoo or something?)
Yes, ew, but that's how flat the learning curve was with it.
I was later less impressed when I came back to it and found that you can't do if ( variable_containing_boolean_true ) { stuff } - because true equated to 0 or -1, or something. Why?
I had something that worked well enough with VB 1, then VB 2 broke my hacks, and I re-did them, and then VB 3 released and I had to fix a few more little things, and it never really did work quite as snappy as VB 2. I assisted others with some VB 5 stuff but that's about it. I kinda gave up on VB. That shared lib always created install problems and refused to work on newer OS's, forcing you to upgrade to a newer VB, and the coding challenges to make your VB hacks work again.
Too bad, because when it first came out, VB 1 was _REALLY_ cool! Windows applications in minutes/hours instead of days/weeks.
I am still performing some programming using VB6, mainly because it can read and write without problem data files created by a QuickBasic program...
It would take one or three month of full time programming to translate the QBasic program to a modern language, but I don't have the courage to do it yet...
VB used to be a decent rapid UI development tool that could assist writing a user interface in a short time, to help you test out ideas. Shipping a VB application to customers, however, DEFINITELY had its shortcomings.
Still, the whole "Rapid development" thing made learning the basics (pun intended) worth doing.
[then you'd re-write it in C or C++ or similar and ship THAT version, once the UI bugs and features were worked out]
Learned Pascal and C at (what is now a) uni, but first job was in Pick shop, so back to BASIC. I tried to make my code as Pascal-like as I could, which bemused my colleagues.
The PC revolution happened and I got a gig writing DOS programs. In C, natch, with some assembler. And then Windows took off. Like everyone else I acquired a copy of Charles Petzold's "Programming Windows" and was horrified to learn that simply putting the words "Hello, world" on the screen required 80 lines of code. That's why VB took off. Not because of BASIC, but the Visual part. You could put the words "Hello, world" on screen without writing a single line of code. The language itself was slow and pretty clunky, but you could still write the serious stuff in C and compile to a DLL and call that.
The BASIC part got better over time, swallowing a lot of Pascal along the way and a little bit of Java. By the end, you hardly ever needed to code anything in C unless you were doing *very* low level stuff. All it really lacked was proper inheritance, strongly typed generics and the option to base collections at index zero instead of one. But instead they gave us the almost completely incompatible VB.NOT, so we switched to C# and, later, JavaScript.
I've still got quite a lot of old code to maintain. Firing up the IDE is certainly a trip down memory lane, but it takes hardly any time to get back into the swing of it. There's precious little code-completion, and I miss the ability to just magic up an object without having to add a tedious boilerplate class definition -- in its very own source file -- but it's still perfectly usable. Even under Wine on Linux.
Being able to target 64-bit platforms would be nice, but for new projects, no, I don't thinks so. When VB was king there was nothing like it for quickly knocking up a GUI. Now there's plenty of choice, and you don't have to fight the limitations of BASIC. Had something like this been around in 2002 it might have been a different matter. Right now, I don't see much point.
-A.
I'd been coding for years and when VB appeared I thought it was horrible but I then discovered that if you are trying to demonstrate various functions to PhD's with expertise in non-coding areas of life, then VB code samples worked 100% all the time.
I expect we'll see lots of "BASIC sucks" comments but move into the future and every comment we see will be applied to today's languages - saying that a coding method sucks tells everyone a lot more about the commenter than the language.
Once upon a time something which needed hitting could be solved with a rock, or anything heavy really.
Now the hammer has to be a cool alloy subject to precise heat treatment with a sustainable-sourced particular wooden handle treated with unicorn sweat.
Next week, the hammer spec. will have changed - so do try to keep up.
A real engineer will use the tool they have to do a good job. Sod the fashion.
Yes, I am too old, and have just been to the pub :)
Modern builders still use the same rule of thumb - if it falls down then you obviously didn't understand something properly. My house had a structural problem. The structural engineer said "ah yes - that was the approved standard in the 1970s - until the problems started to appear".
People knew about stress cracks on sharp metal corners. A few Liberty ships sank - and Comet aeroplanes crashed - before people remembered you don't use square corner openings in a flexing structure.
Way back in 1995 I used Visual Basic for MSDOS to write a load of Ops utilities to automate and manage the overnight jobs I had to look after on the graveyard shift I worked. I loved VB-DOS as it was perfect for the DOS workhorse machines we had that didn't have Win31 installed. This was way before PowerShell was even a glint in Microsoft's eye.
I have a fondness for VB the language but only nostalgia, it simply doesn't cut it given modern multi-threaded languages like Rust,Golang, Python even C#, plus langs like C++ are still going very strong. Leave VB in the past along with all those VB books we all bought and we should move on.
VB6 had multithreading
not multi-threading per se, as i recall. VB had a 'DoEvents()' [or similarly named] function that would call the message loop handler. It could make it LOOK like you were multi-threading. It's like cooperatively pre-emptive tasking.
In fact, this was present in VB 1
What I used to do for time consuming operations is disable the window that was doing the task by setting the 'Enabled' (I think that's right) properties to zero, then do the function that is time consuming while the hourglass cursor is visible, where the polling loop calls 'DoEvents()", and then fix it back once the operation is complete. typical example: waiting for DDE transactions or file transfers.
(Shudder)
Brings back nightmares of being in the basement of a customer site, standing at the server rack debugging on a locked-down WinNT DEC Alpha through a crappy 640x480 KVM with a crusty trackball.
Some of VB6's greatest hits:
Method '~' of object '~' failed
Binary Compatibility DLLs
REGSVR32
HKEY_CLASSES_ROOT, CLSID and InprocServer32
You've never lived :-)
Many people, myself included, like to don medieval-ish attire and congregate at castles and markets with the like-minded.
So, why not bring the hobby of reenactment into the digital age?
In real life, I am an app developer for Android;
but in my spare time, I am a VB6 developer.
...but it was a useful one for doing a particular job, such as quickly knocking up a UI for the embedded systems I was developing.
Unfortunately when the only tool you have is a hammer, all problems look like nails and so it got used for everything far beyond its means.
It's inability to do bit manipulation and the utterly awful serial interface control added to the challenge!
"And, Or, Not and Xor are all bitwise in classic VB"
Ah, perhaps they were, it is a while ago now, but there was certainly something that could trip you up. Perhaps there was automatic type conversion that could happen if you weren't careful how you handled the results... I certainly have the mental scars from problems of the type "0 <> 0"!
What always made me shudder wasn't the VB6... it was the crusty ancient C++ code behind the VB6 VM and all the tooling.
There was a lot of infrastructure there just to drag a button onto a visual form. The script interpreter is all behind closed doors, who knows what madness lies behind it (and still in Microsoft Office as VBA).
I still can't decide if Microsoft were better developers back in the early 90's or if they are better now. Either way, I do not want to be near the code of one of their projects of this maginitude.
"Visual Basic 6 was arguably the peak before it all went downhill for the language at Microsoft"
No kidding. I took a shot at VB.NET, realised it had nothing to do with the gorgeous language it was riding the name of and so began my move away from windows part from gaming.
I knocked out so many quick and useful programs as well as it being the language of my first employment. It had limitations but I found ways to make it use pointers where necessary (real memory pointers not 'byref'). I wrote plenty little utilities which I now script in python and bash which run on the command line.
I doubt it would have much hope beyond hobby now as everyone moves towards the web (where giu's can be knocked up reasonably quick). I am one of those who argue the language was a well made tool which applied properly would easily bring rewards.
"No kidding. I took a shot at VB.NET, realised it had nothing to do with the gorgeous language it was riding the name of and so began my move away from windows part from gaming."
Microsoft did this so they didn't need to officially say they killed Visual Basic. Otherwise that would shine bad light on the lifespan of .NET.
They are good at muddying up names to be fair. So many of my students honestly think that C# is the continuation of C++. That is fairly cringeworthy. Unfortunately C, being an open standard had no company backing it to defend the name.
Trivia: C# was originally called Microsoft Cool before a last minute name change. How tacky is that!?
VB.NET may have had little to do with VB6, but at least MS used the opportunity to fix the faults and limitations of the language (Interface only inheritance, archaic error handling, 254 controls on a form, inconsistent array bases (some arrays are zero based, some are one based) to name a few).
The problem was that VB.NET was so different that developers may as well have just learned C# instead, and some of the capabilities of C# weren’t provided in VB.NET.
This post has been deleted by its author
The software industry isn't short of prima donnas.
Look at the posts here and see how people are critical of VB for speed and other perceived design issues. Trying to be superior and only exposting their own frailties.
One of the main factors in selecting a development environment is selecting the right tool for the job.
So never use Jave or C# for embeded code in a pacemaker - the garbage collection may just cause your heart to skip a beat, Literally.
So should we kill the languages for these shortcomings? Of course not, they have many other uses. VB had as its strength and main weakness the fact that it was easy for beginners to get in and create useful applications. True, they were applications that were badly structured and written and left a lot to be desiredm but they allowed people to be productive.
Yes, those of us who had a proper education in computing could look at it with scorn, or, leverage it's capabilities, enforce structure through standards and work past it's weaknesses. I chose the second approach
As a VB interviewer I had a bit of a reputation as a hard nut, simply because I insisted on proper standards - using forms as classes, not in their native way, for example. Making sure that people understoof the difference between passing parameters by reference or by value and when to use them.
This rigour made for productive teams and there were systems in use by large organisations for many years after - systems that were well maintained and supportable.
More than that it enabled less traditionally capable people into the industry, who then learned the craft and good practice. We're all richer for their presence.
If we'd have selected C++ or Delphi for these tasks, we'd have spent a heap more money. Delphi is great, but it's programmer base was smaller. (In fact when presented with a choice in the middle nineties as to a programming language, I wanted Delphi, but lost)
In conclusion, to the VB critics - what you say, says more about you than the language.
What you're saying is all true. If the question is "Which programming language is bad in exactly the right way to be almost optimally compatible with uneducated aspiring programmers?" then the answer could be VB. (The same goes for almost all MS products and has historically been the company's main strength when the market shares were still under competition.)
But there are times when that is not the question to ask. Just saying.
At age 14, that summed up my meeting VB6 (5?) exactly. I didn't have a clue. But it was so easy that I could make real looking GUI applications by drag and drop. Stick some Ask Jeevesed code under a button and instant reward. I wonder whether I'd do this for a living now if it wasn't for VB.
The project plan on kickstarter is a trainwreck.
(Edit: The Kickstarter has failed, but I'd written part of this analysis before I'd realised).
*** What matters? ***
For a project like this, I think the essential parts, most important first, are:
1) Compiler & Runtime, for 32-bit Windows EXEs, with support for everything except database connectivity. This would be valuable, it would let people develop using the existing Microsoft Visual Basic IDE and compile and run their pre-existing code. Everything else is built on top of this!
2) Form editor. This would allow people to develop new code, or modify existing code, without having to have bought a VB6 license. OK, might be a bit kludgy moving between a text editor and a separate form editor and a separate command-prompt to use to compile, but it would be doable. Without the compiler (1) this is useless.
3) Support for other target types in the compiler - DLLs, ActiveX controls, etc. These are much less common than full Visual Basic EXEs, but are important for some people to replace VB fully. This is an improvement to the compiler (1).
4) IDE with all the basic VB6 features except the debugger and database connectivity. This would include an improved, integrated version of the form editor from (2). Without the compiler (1) this is useless.
5) Debugger. Would probably be built on the IDE (4), otherwise I'd have put this higher up the list.
6) Database connectivity. Important for a whole bunch of apps, but at least SOME apps can be written without this.
The nice-to-have features include:
6) 64-bit support in the compiler and runtime (1).
7) support for using 32-bit ActiveX controls in 64-bit code
8) anything that's an improvement over Visual Basic. While improvements are nice, what people care about most is existing code and being able to replace the Visual Basic IDE with this.
....
somewhere around number 526) the ability to change the theme in the IDE to "dark" or "light".
*** So, what do they have now? ***
Well, they have an IDE with a "form editor" that can create forms but can't load existing VB6-created forms, which means it is entirely suspect - if it was right it should be able to interoperate with the VB6 IDE. The IDE has a fancy text editor. It has support for "dark" and "light" themes!
The compiler and runtime doesn't work, you can write "hello world" but there isn't even support for most of the VB language in the compiler, things like common loops are missing. The compiler only supports .exes.
*** So, what do they promise? ***
Well, a whole bunch of things, including all of the above, plus Git and Subversion integration, automatic code generation for GUIs that wrap databases, an Active Directory library, a plugin for the legacy VB6 IDE that lets you compile with the new compiler, ...
*** How long is this going to take? ***
According to the Kickstarter page, it will take one person 9 or 10 months.
Despite the fact that Microsoft had many many programmers working on VB6 for years, this guy says he can do this project, that includes a LOT more than VB6, in just 10 months.
Reality check: He can't.
In my opinion, just getting all the "essential" parts from my list above done, will take one person perhaps 5 years. Then he's added another couple of years of extra complexity!
And he's not tackling the most important bits first, so when the project fails, everything will be half-done and useless. If he just concentrated on a 32-bit VB6-compatible .exe compiler & runtime, then a buggy version 1.0 would probably be achievable in 10 months, and a year or two of bug reports and fixes would get something reasonable, especially if it's open source and he takes patches.
*** What's the budget like? ***
Another trainwreck. He's made the classic mistake of undervaluing everything.
He's paying himself a salary for 10 months that's equivalent to £36k/year, which is low for a professional programmer with 15 years experience. There is no allowance for the fact that if/when he fails to deliver people will want refunds, so he should be pricing things higher to account for the high risk, so his risk/reward ratio is balanced. There is no allowance in case (when) the project runs long. He's selling "support" as part of the rewards, but hasn't allocated any money to pay for the time he's going to have to spend on support after the release is "done".
He's trashed his future revenue source by promising "lifetime" discounts. Just... never do that. Anything claiming to be a "lifetime" benefit won't last that long, either the seller will find some small-print way to revoke it, or they'll flat out break their promise, or they'll go bust. All of those options will make your customers hate you. And he's included an 80% lifetime discount in some tiers!!!! You can't afford to keep that discount going forever.
He's grossly undervalued the product. That's a mistake that's tricky to recover from. This is a VB6 replacement, pricing should be based off what VB pricing was. €120 for Enterprise Edition.. just no. Enterprise customers are the ones yelling "just take my money, give me the most shiny, I don't care how much it costs". €999 reduced to €499 for Kickstarter, maybe. And €95 for 5 professional licenses, that's €20 a seat for a company that's big enough to have a few developers... those developers are earning more than €95 per DAY EACH, why would you charge them so little?
I started my college IT courses learning Pascal and then Visual Basic. Loved both. Wanted to be a programmer, so I thought. But I was shit at it. Visual Basic made it easier.
Wrote a lottery number picker in Pascal then later converted it to Visual Basic but with less features than the Pascal version as didn't know how to code the extra features in Visual Basic.
Wrote a martial arts membership database for my year assignment with it as I was doing martial arts at the time.
Discovered how to do scrolling in it so did scrolling credits for the about box :)
I loved it. Shame it turned out I was shit at programming so became a desktop engineer instead (which I find easier). Shame though as more money in programming.
Recently booted up a Win 98se VM just so I could load my old projects into it as found the old CDs from 1998. Fixed a bug that was over 20 years old in my installer (don't know why I never worked it out at the time as was fairly easy to work out what the issue was). Stuck the video of the Lottery Number Picker onto my YouTube channel just so I have a record of it somewhere.
Then I took a look back at Hotdog that also used to love :)
My CompSci degree final year project was written in VB as I couldn't write C to save my life, which may explain why I'm a sys admin now. A lot of my friends used to joke about me using "Visual Painting". I also purchased a VBX to make my life easier which did lead to someone on my course making a comment that I'd "purchased my project". He was an idiot.
Like some other commenters say, VB had it's place as a quick/easy tool to create some sort of demo/prototype or just as a handy Windows front end to a database (usually Access).
VB6 was the only programming tool I had to hand many years ago, when I found, abandoned in the corner of one of out IT store rooms, a receiver to pick up the time signal transmitted from Rugby. It was unused simply because it only had a support driver for Netware, and we already had time sync on the Netware network provided from another source. I think there was a Windows driver available, but at a fairly hefty cost.
The instruction manual included details of the protocol it used, and so using VB6 I knocked together a program to read the stream from the serial port and set the system time on a Windows NT Lotus Notes admin server at regular intervals (I can't remember if it was overnight or weekly), meaning that our email system got proper synchronisation*
VB might not have been a great system, and my program was a bit of a cludge, I guess, but it worked.
* - I should say "mostly proper synchronisation", as despite the fact that there were CRC checks in order to ensure that the time signal was correct, I arrived to work one morning to find people were complaining that many of their emails he become unread, and new emails were appearing out of sequence. I assume that in some circumstances it was possible that the signal noise to occasionally flip enough bits so that the time signal and CRC value were both wrong but matching, and the server date and time had changed to something several years earlier. I fixed this by requiring the program to validate three successive time messages before making any clock changes.
I looked at a similar issue back in the day.
Safety could be ensured by adjusting the server clock only a small amount each day based on whether it was fast/ slow relative to the time signal. Over an extended period it will converge on the time signal and stay synced to it.
A single totally wrong time signal would never make the server time wrong by more than a second or two.
Worked on a commercial product where the UI was done as Visual Basic ActiveX controls, hosted in a MFC app. The idea was the VB controls would call into C++ code to do all the logic, keeping the UI layer as thin as possible. Unfortunately, over time, due to VB's ease of use etc, the UI layer got thicker and thicker until, inevitably, most of the processing was being done in VB.
Visual Basic 6 was a useful tool when it was released, but it's not suitable for new projects. Why? Everything it did well, simplicity, ease of use, etc is done better by newer systems that have better community support and better performance... Visual Basic 6's model doesn't even support multithreading.
I learnt from a book all sorts of "proper"/extreme programming you could do with VB. Passing string pointers around, direct read and writes to memory locations, multithreading, accessing the real Windows API and best of all, how to hack MTS and COM+.
Used it to great effect to help modernise an enormous and cumbersome MDI based VB application. Kept the MDI shell in place whilst rewriting the core functionality in C# using .NET 2002. Only needed a few calls to obtain the MDI child window handles and drop in the .NET forms into place and wire up the event handlers.
My biggest learning of all - just because you can do it, doesn't mean you should.
"I learnt from a book all sorts of "proper"/extreme programming you could do with VB. Passing string pointers around, direct read and writes to memory locations, multithreading, accessing the real Windows API and best of all, how to hack MTS and COM+."
Was the book "Hardcore Visual Basic" from Bruce McKinney? I learned almost all those topics from that excellent book :-)
For cross-platform, and don’t mind paying, XOJO might be worth a look (it used to be REALbasic).
Caveat: I stopped using VB at V4/5, but it was OK for prototyping screens to show to a punter. The included Crystal Reports was dreadful, and used a lot of memory - Surprisingly for simple CRUD applications with reports, MS Access was smaller and faster. We started prototyping with Access, and left a prototype with a customer (intending to move them to Oracle or whatever), until he said "Why is it just a prototype? We have tried it in production, and it is OK"; we moved him a SQL Server 4.2/6.0 backend (stored procedures, transactions, etc.) In 1996 we used the same ideas with the Access runtime, and sold them as shrink-wrap - I’m retired now, the company is still around, and they are still in use (with the current versions of Access and SQL Server). They work well for up to 50 concurrent users and 10s of millions of rows…
As a guy who was a developer for Microsoft OSs in the 80's/90's (MSDOS/Windows) I used a lot of tools from Microsoft like (Visual)C++, (Visual)FoxPro, GW-Basic, QuickBasic, and of course, VisualBasic (I even used the version 1 for MS-DOS). The language/IDE was good, but it was way behind Borland's tools like Delphi or C++ Builder. I used it in big businesses projects, but it was a pain. Having said that, one of the best programming book I've ever read, was one related to Visual Basic, "Hardcore Visual Basic" from Bruce McKinney. It was very funny, useful, and with a lot of "secrets".
I'd hit that. Yeah, I said it.
I don't know why VB gets such wide hate. It was never meant for system development or for stuff like manipulating pixels in a video stream or fiddling with hardware. It was meant to be a way around having to learn the vagaries of programming Windows in C++. I looked at Windows programming in like 1991 and decided I'd rather keep working in a yarn mill than go that direction. I got a copy of VB 3 in '94 (after 4 or 5 years of DOS programming in Pascal and Assembly), and thought it was pretty neat. Beat the hell out of learning all of the Win16 stuff, IMHO. Drag and drop, then add the needed code.
I know there was a lot of shitty code put out by non-programmers (ie - managers) who could suddenly make something that looked important, but had no discipline in how they did things. But that wasn't the fault of VB.
Oh, and it had an IDE that loaded in, eh, half a second, even on a 4-Meg machine, didn't require a Java runtime, and had actual, non-web-linked context-sensitive help when you highlighted and pressed F1. Shit, that was awesome stuff in the mid 90's.
I'm always amazed by the hate directed at VB.
I used VB6 extensively and worked on some great enterprise level applications. They were well written, maintainable and more than fit for purpose.
Some of these large scale applications are still running today.
The main downsides in VB6 I can think of are:
Int type was too small (basically a small int)
The interfaces were a bit of a fudge
Constructors were limited
Scoping was limited (but adequate)
Threading was difficult (but could be done with ActiveX for example)
I have a lot of fond memories of working in VB6 - and I would be able to do so again if the need arose.
Wow, can't believe what I'm reading here. VB6 was and still is a brilliant and most useful language & environment and many, many, many are still using it. This may be hard for you to believe, but with responsible coding - i.e. proper variable declaration, clean up of unused objects, etc. - apps written in VB6 are just as good as any other and nowadays for most purposes just as fast when compiled to native code.
VB6 has access to the Windows API, and with responsible use of that you can do most anything. I've written everything from simple concept testing apps to extremely complicated graphics and communication and control programs in VB6 and will continue to do so. Sorry guys but dot net is just WAY too bloated & managed for me. My VB6 stuff is small, fast, portable, and reliable. There are some commercial and programs and there are many enterprise-level corporate applications written in VB6 which still work well, every day.
Don't like VB6? no prob, don't use it. But PUH-LEEZ stop with the bashing of it. It really IS still a good tool alongside others.
Now we have the twinBASIC programming language.
Vb6 backwards compatible, twinBASIC can import VB6 projects (Forms and source code) and compile to 32-bit or 64-bit..
Plus loads of modern features.
With the optimising compiler twinBASIC apps approach C++ speeds.