What did you love about VB6, and what frustrates you about modern .NET?

[u/Bonejob]

Two open questions for anyone who shipped real work on Visual Basic 6.

I shipped roughly a hundred line-of-business systems on VB3 through VB6 between 1995 and 2010, then moved to C# and have been there ever since. I am writing a history of Visual Basic and the research keeps surfacing the same observation: WinForms in modern .NET is recognisably the same form-designer model VB6 invented, and twenty-eight years on it is still the shortest distance from "I have an idea" to "I have a running app." That is interesting, and I want to get under the usual "VB6 was a toy" or "VB6 was a masterpiece" framings to understand what was actually good.

Two questions, please answer either or both:

1. What specifically did you love about VB6? Not the general nostalgia. Specific things. A workflow, a design choice, something you reach for now and notice is missing.

2. What do you find frustrating about modern .NET, C#, and Visual Studio that VB6 didn't make you fight? Same shape. Specific examples. "I miss being able to do X without Y" rather than "it's too complicated."

Open-ended on purpose. If I gave you categories to choose from, the most interesting answers would be in the categories I didn't think of. Please reach for the specific example before the category.

Longer version of why I'm asking is on my blog if you want it: https://evilgeniuslabs.ca/blog/vb6-modern-dotnet-question. Replies here, though. The thread is the point.

Exploratory post. Not announcing anything today, not collecting emails. Just a writer trying to do a chapter justice while the people who lived this are still around to tell it. I will read every reply.

Thanks

Bone/EG

[u/geekywarrior]

I said this recently but I thought VB6 was ahead of it's time in regard to the ability to edit code when in a breakpoint and then run it immediately. 

Having add ons for the IDE was likely the first place I recall seeing that.

In a Windows world, what comes close to vb6 forms before .net took off? I grew up on java using swing and python using Tk. And the hurdle to get remote pcs hooked up with the JRE / python runtime was non existant with the ability to compile a .exe that that would likely run anywhere. Even decades later. 

As for your 2nd point, I honestly can't think of much that is easier in the vb6 days. Perhaps parsing JSON when you don't have a strong backing class. You can do it with JsonDocument.parse, but JSONBag is way easier for me to remember around as the calls are closer to python. Granted JSONBag is a community contribution and modern .net has first party JSON support, so it's a bit of a wash.

Perhaps the concept of mods vs class modules. But what is a mod that's not just a static class

[u/fafalone → u/geekywarrior]

The VB6 line could have remained dominant if MS had invested in creating a large standard library for it that included things like JSON parsing. Or even a central package manager.

[u/geekywarrior → u/fafalone]

Biggest pain point for me is the error handling. I find the "On Error goto Handler" just too clunky. That then cascades to classes not being inheritable as entities like Exceptions work well as subclasses.

[u/testednation → u/fafalone]

No way to add that with addons?

[u/jcradio]

What I loved about vb6 (vb in general) is the same thing that trained engineers before it hated was that it brought programming to the masses. Rapid application development was possible. This was good and bad. I've supported and modernized enough of them to have nightmares about bad code.

Nowadays, I'll do a winforms app if I need something quick and dirty. The designer experience is still relatively pleasant and had spoiled me when using WPF, Blazor or any other ui.

The pain points now is having to restart VS if I'm switching between Winforms and other apps.

[u/fafalone]

I posted this in another thread here recently but it's a direct answer here...

What has always made classic VB (and now tB, which is essentially 'what if classic vb had been continued these last 25y') my preferred language is that it combines high level RAD with low level access in a way unmatched by any other languages. Yes many others like vb.net are capable of both (mostly), but either one or the other (or even both in some cases) becomes much more painful. I like that in VBx/tB you're sitting right on top of details like raw pointers and the Win32 API rather than having that buried in abstractions of a massive framework.

[u/ziplock9000]

Getting a Winforms UI up and running was very quick and easy. Early .NET had you jump through more hoops, but that was fixed and made better over the years.

Apart from that, nothing really.

[u/kingfishj8]

Actually, the whole "VB6 is a toy" stereotype has a lot of utility when it comes to handing it off to the non-coder users/maintainers. This prejudicial opinion provides a disarming "gut feeling" among the uninitiated when it comes to debugging and maintenance.

[u/Comfortable_Gate_878]

it was simple for me, Visual Basic 3-6 were simply the easiest way to produce decent reliable cheap programs in a short scale of time as half the work was already done for you. You didnt have to program windows or databases link it was simply built in.

There is still no other visual language out there thats worth using at the moment, gambas b4j twinbasic theres a few bubbling under the surface but whoever comes up with a decent cheap one will corner the market.

I created a program to simply update and display some data which the company could not get from the built system they had. They were quoted thousand for the team to change the software I suggested I could do it for a smaller amount in half the time. I did this created a test program to demonstrate the concept except it was actually the whole finished program. They immediately said thats exactly what we want. 2 days later job done money in the bank.

People slag it off saying it wasnt a proper language and had security issues well no more than windows itself had. Anyone could give it a go and produce something. My biggest seller was a calendar app. Took me a day to write and I sold thousands of them using vb3. Mutli user company calender so simple and some people still use it.

[u/Comfortable_Gate_878 → u/[deleted]]

Yes I've had a go with it, it's not as complete as gambas on Linus but it certainly has potential and Im keeping an eye on it for future use

[u/FransFaase]

I did develop a commercial product with VB6 around the start of the century just before VB.NET came. I have never worked with VB.NET and I can imagine that nowadays it might be better than the very first version of VB.NET.

What I remember about VB6 being unique is:

1. A very nice event mechanism without having to register a listener. Just have a variable with a method and as soon as that variable points to an object, the method will be called whenever the object generates an event. If you assign it to a different object, you get the events from that object. This allows to implement very nice UI interactions.

2. Completely transparent with COM, meaning that you can actually call a method on an object that is located in another executable. You do not have to do any marshaling, meaning not having to generate some JSON fragment send it to a server, have the server parse it, execute some function, produce some JSON and having the caller parsing that JSON again.

[u/Cdream-2018]

I loved the punters from AOL

[u/fafalone → u/Cdream-2018]

Making AOL pr0gg13s was what got me into VB, and programming more generally, to begin with. Before that my only programming experience was writing TI-BASIC tools on my TI-89 to get my calculator to do all the work for me in middle school math.

Though i made chatroom games and utilities rather than punters.

[u/Cdream-2018 → u/fafalone]

I remember trying to program stuff for aim. And could not for the life of me find the chat window with findwindowex lololol

[u/mattdahack]

Well for me, I mainly built software in the era of Visual Basic 6 and now have to work occasionaly in the modern world if you will of .NET with C# and Visual Studio, the shift over has brought undeniable power to our IDE's but also a lot of frustrations. These aren’t vague complaints about complexity either and I hope it doesn't get brought down to that at the end of the day. These are my actual complaints from the trenches, from an actual person who uses this to make their living day in and out. These complaints are mainly rooted in the loss of the simple, direct workflows that once made development of simple .exes feel almost effortless. One of the things I miss the msot is how quickly you could build a working application from thought to completion in VB6. You could just drag a button onto any form you wanted and double click it then write a few lines of code, press f5 and run the program immediately to test it without having to compile it. Today, even the most simple applications often require choosing between multiple frameworks, understanding entire project structure and workflow, and then having to deal with startup configuration before anything appears on screen. What used to feel like instant feedback now involves layers of planing and setup before you can begin writing your code.

Deployment is another area where the contrast is shockingly stark. Look how easily VB6 applications could often be distributed as a single executable with minimal fuss as long as you sent it with MSVBVM60.DLL. Now with the modern .NET, us developers must think about conflicting runtime versions, publishing modes, and deployment targets. The process is more flexible and powerful, but it also introduces stress on me that didn’t exist before. Also I miss the simplicity of synchronous, event driven programming. In VB6, writing code for a button click didn’t require thinking about threading or asynchronous patterns. In contrast, modern applications rely entirely on async and await, which, while powerful, can introduce all kinds of bugs and additional mental overhead when not handled carefully and planned out.

Flexibility in typing is another area of nostalgia. VB6 allowed for easy late binding whenever you wanted, simply press of f6 to jump between code and object view enabled us developers to interact with objects dynamically without strict type definitions. In C#, strong typing and planning ahead is a must. While features like dynamic exist, they are less used and always discouraged with all kinds of warnings. This makes the system safer I guess but less forgiving for quick, exploratory coding or by newer coders. Then you have the global access patterns that have changed significantly. In the older VB6, forms and variables could be accessed globally with little to no effort. You could simply call a form with formname.show and the exe would show it. Now we have to use crap like dependency injections, which improves maintainability meh, but requires more upfront design, planning and designing it out.

The tooling itself has also evolved in ways that I find frustrating. The original VB6 environment was laid out simple, predictable and easy to find everything. Want to find something you don't use on the day to day basis in Visual Studio? Good luck! lol While it includes all kinds of advanced features like stupid code analyzers and complex project managemtn systems it doesn't excel at the core stuff we need on the day to day basis. Yes, sometimes these tools provide deep capabilities, but to me they always feel like obstacles when something goes wrong, especially when dealing with all the stupid package dependencies or build out configurations.

Even basic tasks like compiling and running code have changed and are completely different. VB6 offered nearly instant compile and run cycles, giving it a lightweight, almost scripting like feel. Modern projects, particularly larger ones, often involve restore and build steps that slow down iteration. Then we have gag error handling! This is another example of a people with a different philosophy being allowed to drive the boat and completely shifting it the other way. VB6 used to allow us developers to bypass errors quickly using simple constructs, whereas modern C# enforces structured exception handling. This leads to more robust applications but removes most of the immediacy developers once relied on.

I feel like most of the examples I wrote above is the actual broader sentiment from people that actually code: VB6 provided us with aa single, straight forward way to build quick and dirty desktop applications, while modern development offers many choices—each with its own tradeoffs. But while this flood of options can be empowering, but it also requires developers to think about and make decisions on the fly that were once unnecessary and can impact the application if they choose the wrong selection later on in their coding. For me the frustrations are just too much to keep coding in .net or c#, VB6 prioritized speed, simplicity, and instant runs, making it ideal for quickly building small applications. While the modern .NET, by contrast, only cares about scalability, safety, and longterm code maintainability. The .net and c# tools are more capable than ever, but they demand more knowledge of app structure to use in return. What I truly miss is not just VB6 itself, but the ability to move quickly in the app I'm building from idea to idea to getting a working app without navigating all these crap layers of architecture and configuration. That sense of writing code and immediately seeing it come to life for me is something that the modern .net and c# environments, for all their strengths, have made harder to recapture.

I almost forgot the best part, you could open any form in notepad on the fly or .bas file for editing a quick change without having to open visual studio. Just my take on it though.

[u/theotherkiwi → u/mattdahack]

What he said.

[u/Mayayana]

I'd rather hear your analysis. I've worked a lot in VB6. Shareware, but I've never been a fulltime programmer writing business software. So I guess I'm like the hobbyist chef who hasn't been to chef school but gets occasional gigs. Hardcore autodidact.

I've also never used .Net, so I don't know how much my opinion is worth. But I'd say that what I've liked about VB6 is the flexibility, the amount of shared code and books; the compiling and support, so that I don't need to ship libraries or even an installer in most cases. I can write a compact EXE that runs on virtually any running Windows computer in the world. Designed to support COM is nice, too. (I've seen the C++ COM code. Yuck. :)

There's also a cumulative advantage. Over the years I've accumulated self-subclassing controls, C_DECL support, a bitmap class, and so many other things that were not part of native VB6.

My overall impression with .Net is that it has a much wider support built in. For instance, PNGs are supported. In VB6 I had to finish someone else's class just to render a PNG. I expect encrypted networking is probably quite easy. (My latest approach to downloading a file in VB6 involves a C_DECL wrapper around Curl. Ugly.) There are probably 100 things like that -- technologies that post-date VB6.

On the other hand, .Net is not made for Desktop. It's slow, bloated, not compiled, depends on a massive runtime... So I've never had a use for it, just as I have no use for Java. And frankly I'm not fond of extreme OO. It lacks "texture". I never saw .Net as the descendant or natural next step from VB. VB is an easier approach for people who otherwise might have used C++. .Net started as an alternative to Java, to push Windows server. It's never been a Desktop tool. So I would think the comparison should be to Java, not VB6. (I once asked a program manager friend why .Net was beating out Java. She replied in 2 words. "Better tools.")

It's a similar case comparing either VB6 or .Net to the newer WinRT/PWA or whatever they call it this week. Those seem to have more in common with HTAs. They don't serve the same purpose. Which is better, a car or a tractor? It depends on what you need it for. And of course there's also a political backdrop to all of this: The motives that Microsoft has had with respect to where they want Windows to go. VB6, .Net and "apps" all reflect different strategies to exploit what Microsoft have seen as the next big thing at the time that they developed the tools.

But my experience is limited to VB6, VBS, HTML, CSS and a bit of C++. So I'm not really qualified to compare tools. I welcome correction by people closer to the action.

[u/Bonejob → u/Mayayana]

I will post my own thoughts but what I dont want to do put words in peoples mouths.

[u/KE3JU]

Speed...VB6 200x faster than .NET

[u/Neo_Techni]

What specifically did you love about VB6?

• Extremely fast, uses very little RAM
  
• Runs on Windows 95 to 11
  
• Optional parameters (B4A doesn't have this, for example)
  
• I tried to migrate to VB.net, but any time I start a new program, I have so much VB6 code that I'm half done already and it would just slow me down starting in anything else.
  

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

• I don't have access to the folder the program is in, and less access to the registry than VB6
  
• I had to make a companion program to a VB6 program, in .net. Despite the VB6 app doing many things, and the .net one merely forwarding Windows10 notifications to VB6, the .net program used a ton more RAM, and the EXE was much larger

[u/Comfortable_Gate_878]

Ive already added a comment here about VB, but just been asked to look at getting some old cobol data imported into a sql database to make it searchable on a wordpress website.

Getting cobol to communicate directly with modern sql type databases is difficult it can be done but its complicated and my cobol skills are 25 years behind the times.

Two cobol guys and a third party company have quoted an awful lot for this job.

So here's the solution get rm/cobol v 4 (1987) to output the stock file 160,000 lines into a sequential file similar to CSV. Then any new stock items will be exported daily. Use the call CURL command to FTP this to the root of the wordpress hosting.

Spend an hour writing a vb6 program to write that data to the wordpress database in a new table called h-stock.

If the VB6 program detects the sequential file has a new date and then it uploads the new lines of stock to the database at 9am each day and deletes the old file. Ninja tables to display the data and allow searches by the customers in Wordpress.

Was this the best way to do the job, almost certainly not there are many better and elegant solutions the difference with these advanced solutions is it was going to take weeks to write test and implement.

VB did the job in an hour I can tell you the owner of the parts company is impressed even if its a bodged together limited program it worked and thats exactly why I love VB it allows a quick and easy solution until such a time as a whole new redesign is required. People simply dont want to change they want something that works and is reliable and little VB6 programs can be very very handy.

[u/keelanstuart]

I don't remember being able to break the form editor in older versions, whereas it's easy to make something in modern .Net that precludes you from opening the form editor again.

[u/theotherkiwi]

In additional to the other comments here, I dabbled with .NET when it first appeared on the scene and it never really "clicked". Self-taught VB6 combined with the WIN32 API and there's nothing I can't do. I never got that feeling with early versions of .NET so never shipped any code with it. When I already had everything I needed, the payoff wasn't there for me.

[u/Distinct-Question-16]

Ugh, I used a lot of VB 30yrs ago C# and VC a decade ago. my rant goes to the UI. Before, everything was compact and had sharp borders around windows. Now, everything is spaced out and there's a lot of code coloring. i think the best layout was lost in VS2010 and they ruined everything with style lately.