I was 17 when VB6 came out, working at a local computer store, and getting into programming but couldn't afford $500 to by the pro edition.

One day, I happened to read an article that said they were given a free copy of VB6 to review for the magazine.

My 17yo mind was blown! Hundreds of dollars worth of software given away for free? Just for writing an article?! I could do that!

Having nothing to lose, I called Microsoft's PR department and requested a copy. Told them I published a newsletter about computers and was based in Queens, NY. Their only question? Where should they send the software lol

It was literally that easy. A single phone call with zero verification about me, my newsletter, and my so-called publishing company.

And it was Enterprise edition which retailed for over $1,000. For little 17yo me!

Naturally, I kept calling for more software. Office, Windows 98/NT, Encarta... you name it.

I even started calling other companies and published a single edition of the newsletter, in case anyone asked for a copy but no one ever did. All they wanted to know was where they should send the software.

One of my favorite free items was course on VB which came on 6 VHS cassettes. The lessons I learned from those tapes built the foundation of my programming carrier.

Of course, older me understands the economics of sending people a few bits of plastic & paper in exchange for press coverage but the joy I felt getting that software in the mail still hasn't left my mind.

Good times =D

The debugger. Still the best debugger I have ever used.

You could grab the program counter/execution pointer and drag it literally anywhere, rewrite the code and keep on stepping.

I would get into a loop, realize I made a mistake, drag the PC back up above it, make a change and step back into the loop without breaking flow to compile or some other such nonsense.

Alien technology compared to most development environments even today.

Code-behind was the bee’s knees.

You open up the GUI editor, drag a button onto the screen from the toolbox, give it a name/id, and double click on it which takes you to the source code file where a “buttonId_click” handler is auto created for you. Super easy to create simple GUIs without much work while still wiring together the bits that need code.

There was certainly some rough edges and I don’t know how well the workflow would have adapted to responsive design but line of business apps in controlled environments it was so powerful. VB6 and Delphi were like nothing else we have today (at least that I’ve seen).

> What specifically did you love about VB6?

I taught my daughter to program using VB6 -- long after it was already obsolete. It's very easy to get started and build a GUI application with very little ceremony. You can develop your entire UI without a single line of code and run it. Only then did you need to double-click on components and start adding functionality with code.

But actually using it for "real" development was not as enjoyable and I did it for years. If you only wanted to make a static fix-sized application then it's ideal. But if you wanted your application to adjust to the size of the window (and therefore the resolution of a monitor) you had to wire all that up yourself. Painting controls to specific pixel sizes is an obsolete concept.

> What do you find frustrating about modern .NET, C#, and Visual Studio that VB6 didn't make you fight?

C# is superior language to VB6 and WinForms is a superior way to do an equivalent style of UI development. While the VB6 designer was a smoother experience than the Visual Studio designer it was a much more limiting experience.

But if were to put my nostalgia glasses on, I think what is frustrating about .NET GUI development that never seemed frustrating in VB6 was just the ease of getting it do what you want. At the core, WPF/XAML/whatever is a better way to do a GUI layout -- Instead of pixels you place things in stacks, grids, and panels. You have margins and padding. But styling your GUI is so much more complicated and it descends into this overly complex impossible to understand system that makes HTML and CSS look good. This was not a problem in VB6. The GUI interaction with code is also more complicated with magic static property incantations that would never exist in VB6.

Building the UI was superfast. Wiring the logic was somewhat painful but manageable. But you did not really need more than that to build CRUD apps. For everything else, you had C/C++ and the Win32 API.

I am a huge fan of keyboard-only navigation and you could achieve a large part of the extremely rapid data entry methodology of DOS UIs of the 80s and early 90s with considered key-handing. You never even had to look at the screen for the most part; only at the document in front of you.

Microsoft killed it with the move to DOTNET. VB.NET was a different beast, and C# was a superior language. But it was never the same. I moved to web-uis in the late 2000s. Painfully slow way of writing business apps, but the complexity can be managed if you can reuse templates/components.

Making real, complex components, and drag dropping them into other components. Designing a UI with all your components and zero layout code, just positioning them visually. To anyone who grew up with VB6, web development feels like a serious regression.

I could type ~four lines and an alert box response from a visual form.

For years I have lamented the amount of paperwork necessary in most of modern programming to get things done. I don't know how important that is now that I have a machine fill out the paperwork. It would still be better if there was less fuss.

Indirectly introduced me to programming as my dad was obsessed with it growing up. He was a hobbyist with zero formal training, working a completely unrelated job, and still made a ton of money selling tailor made admin software to all kinds of small businesses. Really a testament to how good VB6 was.

It was amazingly easy to interact with other apps via OLE Automation (aka, COM Automation).

About 25 years ago I wrote a program that would look for requests (in the form of XML files) from the custom software on our Solaris system, then based on the contents of the request it would fire up Word, load up the appropriate letterhead and body template, fill in the required information (e.g., client name/address, caseworker name, etc), print two copies (one for the file, one with an envelope to send out), and store the completed document in the client's folder on the fileserver.

This program saved an incredible amount of time and let the office typing pool concentrate on typing dictated letters instead of filling out templates.

Without the magic of OLE Automation letting me use Word programmatically from my application, creating this would have been basically impossible.

In the windows of ecosystem for basic business apps, it was so way to build things. I know Microsoft made it, so it has an unfair advantage vs languages like Delphi, but compared to C++ it was so easy and fast to build basic working apps.

My favorite thing was to watch a guy who was in tech support and frustrated with our overly complicated process build something on his own that solved a major problem we had. This was by himself. It was amazing. Low barrier to entry, and he taught himself enough to fix his issue. The vp called me in to look at it and make sure it was ok, and I was like “a couple things here or there but it was more than good enough to function day to day.” Never would have happened with lower level languages.

My first job was VB6 and I really enjoyed working on it. It was pretty late in it's life - .NET had just come out when I started. The existing program I was working on was pretty complex though. I spent a year rewriting the database layer (well, it wasn't a layer when I started but it was by the end) from an old cursor / file based system to use SQL server. That extended the lifetime of the product by quite a margin as it had been struggling with bigger customers.

It was really stretching the VB6 runtime by the time I left - plenty of direct win32 calls to do various things - foggy on the details now but VB6 was single threaded and some of that was around keeping the interface going while it did more intensive tasks, drawing some complex controls around scheduling etc. I recall it got a bit unstable in development.

Website for the software is still there too not sure if its still used, I left in 2007. https://www.redrabbit.uk.com/oli/oli_overview.htm I drew those little pinball people in inkscape.

VB6 was what sparked my interest in programming. My final project in my programming class was a menu based dungeon crawling game with turn based combat. I was obsessed with Diablo on PC at the time and I just wanted to make anything that remotely resembled it. So you had a town where you could buy equipment and magic spells and then you would go into the “dungeon” and you would fight a selection of random monsters until you got to the boss.

I’m sure I would recoil in terror at the code I wrote but I owe a lot to VB6.

When you want a thing to move to the right, you just move it to the right. Why we'd need some sophisticated abstraction for such simple task these days ?

the original visual basic (probably VB1.0) demonstrated and organized event-driven programming in my mind. I just "got" it. The first version wasn't that deep, but it had a noticeable impact on me.

In comparison, I remember using one of the not-so-early apple xcode versions, and it sucked. it was a disorganized mess and I don't think it has ever gotten much better.

Note - I might be comparing a "sort-of-pure" first version of something to a watered-down-corporate 5th version.

It might also be like memorable 80's movies, where if I go back and actually watch it decades later, my glowing memories might be ruined by the reality check of slow pacing, overacting and bad hair. lol.

Its the first programming language that I use. I was a junior high school student at that time, and my first app was an app to solve trigonometry homework. Maybe back then it wasn't as beautiful as I thought it is now. Or maybe now I am weighted with responsibilites. So when I look back, the memories of looking at me smiling as my app compiles correctly and solved the homework, feels so beautiful without any weight. Just a kid discovering something.

So even when the world forgets about it. My heart would always find it dear.

The quality was generally crap. The code near unmaintainable. It usually wasn't written by experienced programmers. But it got the job done. I actually felt the push away from VB6 was not a customer based decision but one that came about to personal taste of various people working at MS. VB6 was left behind much to the dismay of everyone who built some bespoke business flow using it.

Fwiw though i wouldn't want anyone to try to recreate VB6 or any low/no code style environment at this point. That ships sailed and i'm seeing non-programmers do much more impressive automations with agents at this point.

It was my first IDE and provided simplified abstractions that made me (somewhat) understand what software developers actually do. And then curiosity took over and I caught the bug... So it will forever hold a special place.

The thriving ecosystem of dynamic libraries that you could just link and create a Windows Vista-esque UI (AKA Aero) in an IDE built in 1998, thanks to Win32 API.

i loved making AOL 'hacking' tools as a kid in VB3/5/6. faders, stuff to scroll ascii art to chat rooms, etc.

Nostalgia, not an answer: my proudest moment from high school was coding a very primitive raycasting "engine" in VB6 (that's what we had in our programming class). I had no idea what I was doing and I used some sort of layout object to draw vertical columns.

1. It wasn’t the web

2. Visual designer

3. Encapsulated components, code on event driven

4. Common points of interaction, composition and extension.

5. It wasn’t the web

I never shipped an app in VB6 (only dabbled extensively) but I did work professionally with a huge range of UI technologies, including vanilla HTML/JS, ColdFusion, Java Applets, AWT/Swing, C++/QT, Flex/ActionScript, Objective-C/iOS/Cocoa, React/React Native... but with each of them I would pine for the ease of doing things in VB6.

I mean, I understood technically why each framework had its complexities, especially when it came to dynamically scaling to various displays. But there were so many times, especially for very simple use-cases, I'd be like "LET ME JUST CLICK AND DRAG YOU TO THE CONFIGURATION I WANT YOU TO BE GODDAMMIT."

That was my first love. Just so easy to get something working with a visual interface. Nothing has ever come close.

I can’t believe they ruined it.

VB6 was the original vibe coding! Drag a few GUI controls on a window panel, double click to write some basic code, boom

building a UI was so easy.

Getting paid to write code in it.

Obligatory: if using Linux and want the open source equivalent:

https://gambaswiki.org/website/

GAMBAS is a free development environment and a full powerful object-oriented language and development platform based on a Basic interpreter with optional just-in-time compilation, as easy as Visual Basic™ was.

VBPJ, Wrox books, and VBA.

That it made it so easy to whip up UIs and access Windows APIs, having never done it before as a 10-11 year old playing with VB6...

...which I think promptly used as a younger teen to write a custom keylogger for a friend to try and steal RuneScape accounts. Good news is I didn't know how to send emails from it, so even though it worked, it couldn't hurt anyone in the end!

It taught me what "double buffering" was, because I was (ab)using it to try and build games, but didn't understand why I was getting this horrible white flash when I cleared everything!

I learned so much with VB6 haha

I loved how you can 'paint' controls, and it generates functions for you to fill in based on events. I also liked the Wizard for creating apps.

They did a Java BASIC language Jabaco to work like VB6 and compile to Java files. https://www.jabaco.org/ I think someone should take it over and remove the technical debt.

drag-and-drop gui builder sean greasley's video tutorials

I never used it. VB1.0 was buggy and incomplete, which soured me on Visual Basic and Microsoft. Then they had the gall to charge $60 for the update to VB1.1 despite VB1.0 being completely unusable. Switched to Linux and open source languages and haven't looked back.

Of course these days I would never trust a 1.0, but at the time I was young and naive.

I did a lot of VBA, and the integration of the whole experience was unmatched.

From TFA: > Microsoft has launched seven UI frameworks since VB6. Why? Pick a horse and ride it.

Wrote a time keeping/billing system in Foxbase. Converted to FoxPro when windows arrived. Eventually ported to VB.

That it was easy to use, and that I was able to get it for cheap when I was in school, as compared to today. Same with VB5 & VB4. I may have a VB4 CD still lying around, somewhere. Unfortunately, things changed drastically, complexity became the norm. Honestly, I've only found Rebol to be easier to use and learn, but that is dead too.

[dead]

[dead]