Why did Visual Basic die?

There's still Visual Basic .NET, is it much different productivity wise? I assume the language has changed enough from classic VB.

Does VBA for Excel count? Because if it does then VBA for Excel has reached the"nuclear resistant cockroach" level in finance.

You wouldn't believe what sort of processes in very big banks/financial institutions are built using 10 year old VBA macros. In fact, VBA consulting for finance is a very juicy cottage industry at least in Europe to this very day.

VB didn't die. It got reborn as VB.NET. Still supported, still used.

https://learn.microsoft.com/en-us/dotnet/visual-basic/gettin...

The classic VB you probably remember got end-of-lifed in 2008, but MS still supports classic VB apps.

IMO, it didn't really make a smooth transition to the web. Webforms was the attempt but it was a leaky abstraction (iirc, it kept state for UI components but not variables so things got... weird) and kind of worked against the paradigms at the time (everything was a POST).

I used VB all the way from 1.0 to 6.0.

And when VB.NET came out came out in 2002, that was exactly when all the types of GUI-database projects VB6 was used for, started being built in PHP/MySQL/HTML/CSS instead. The switch would have happened anyways, but the fact that VB.NET wasn't backwards-compatible made it really easy to switch since you were going to have to learn something new anyway.

And then on the hobbyist/personal side, that's also basically when casual developers switched from building fun Windows apps to building fun websites.

So I'd mark it up entirely to web programming replacing it on both sides.

Microsoft accidentally killed it moving to .NET and the increasingly stupid GUI libraries they offered up. Silverlight, 32 bit native, winforms etc and etc.

Web development meanwhile went bonkers and VB was a poor cousin to C# very suddenly.

Its a shame, VB was not for purists but it was very productive.

Visual Basic 6 was very productive - yes. But it was considered by many to be a toy language (it didn't support class inheritance for one).

VB.NET - at least initial versions - was about productive as C#, thus there was no incentive to use VB.

The thing that made VB6 super productive was it's form designer. The .NET successor - WinForms designer - wasn't nearly as fast and capable (to this day, really).

Are you talking about VB the language, or Visual Studio the IDE with its awesome GUI builder for WinForms (and not so awesome ones for the subsequent Windows GUI layers, forget what they're called).

VB is still around but desktop apps in general (and thus VS's GUI builder) largely gave way to web technologies invented outside Microsoft. The dev experience is definitely worse though. Visual Studio was sooooo nice and integrated.

I don't think this is really VB or NET's fault, Microsoft just kinda missed (or failed the fight against) the web transition. They were busy trying to make it coexist with Windows with seamless downloads like ClickOnce but ultimately simple web pages won out for their reach and ease of use, then mobile app stores came along, and now desktop apps are petty much dead except for niches.

I think for a lot of purposes, the internet kind of took over.

VB was great if you needed to do something limited to a single machine.

These days, we want data to be available across machines which requires using a network, and the default network is the internet.

If I'm going to be using the internet anyway, I can knock up something in HTML + JS + firebase/whatever data store, and have an application that works on any platform, and is accessible from anywhere in the world. You might need slightly more technical knowledge, but not so much that you can't have a simple CRUD app running in a day or so of work.

VB died because of .NET and VB.NET. The syntaxes were similar, but VB.NET was much closer to a "real programming language" in feeling and complexity than VB was, and that's not what anyone who used VB actually wanted.

Microsoft was more interested in developing .NET and C# to battle Java, and less interested in developing and promoting VB, their own successful and original product.

>> I have yet to find a tool that can allow me to be as productive in so short a time as Visual Basic.

For me: Delphi or Lazarus

I wonder the same thing about Apple's HyperCard. I used HyperCard a ton at school and side-projects. Visual Basic was a firmer and better step-up from that imho, less so as VBScript when it came to browsers.

As per other comments VBA is alive and well and I did many consulting gigs using that in Ireland in the late 1990s. I hope, in the name of all that is holy, that code isn't running still.

It’s simple: Corporate internal app development (mostly CRUD stuff, as you’d expect) was the bread-and-butter of VB, and it moved wholesale to HTML & JavaScript.

There's still no better GUI toolkit out there than VB6 that I have used. It was amazing.

Problem is a lot of apps that would have been traditional LOB apps written in VB/C# have moved to the web so demand isn't there's clear advantages to C# as a language over VB.

If Microsoft had put more effort into Internet Explorer and VBScript (https://en.wikipedia.org/wiki/VBScript), today's web could look very different, and in some ways better.

My personal reason, which is probably unique:

VB 1.0 was extremely buggy, making it unusable for my use cases.

VB 1.1, which fixed the bugs I was encountering, was a paid upgrade.

I switched to Linux and never looked back.

I got the feeling that a lot of the corp/small business apps that used to be developed in VB and deployed to PCs have been replaced by Web-based apps.

VB6 morphed into VB.Net but then the web took over and anything that could be accomplished as a desktop app was replaced by a web page.

Not sure how accurate this is, but: https://www.youtube.com/watch?v=YqxeLodyyqA

Visual Basic's popularity peaks in late 2001. Exactly when VB .NET was launched. Then it drops like a rock. In my memory, .NET overcomplicated VB and yet still felt like a kids toy.

vb didn't die, it evolved into vb.net, but the market place has shifted to C# for the most part.

What has died, is the maturity of microsofts tool set, they keep changing their concept/design/platform.

silverlight/wpf/uwp/winui2|3/etc..

vb was around for nearly 2 decades and had a very mature tool set, everything since then hasn't gotten nearly that sort of life span or dedication to tool sets.

Developing in visual studio now, is more like web dev in the 2000s, I can't tell you how often you have to go to the xaml and make correction or adjustments that the UI just can't get right, or just goes bonkers and can't render the UI at all until something is fixed.

It is really sad, because the power of those old drag and drop builders that just worked meant that prototyping and mocking up applications was much much faster.

now standing up a UI based project takes ages, I'll usually do a console application now, and are dumping results to a API or console.

VB (and BASIC in general) has a legacy of being a procedural language. In the late 90’s and early 2000’s, there was a massive push to leverage object oriented programming and design. The births of Java in the 90’s and then C# in the 2000’s were clear catalysts to abandon procedural programming.

Of course in .NET VB has nearly all of the OO capabilities that C# has, but I think most developers just decided to go “all-in” on object oriented programming and learn C# and graduate from their procedural past.

A lot of colleges taught Java and moving to it or C# in the workplace was a much more natural process.

There are BASIC alternatives and they are fairly strong offerings, but I think OO and functional programming are the standard today.

That means python, Rust, Golang, Ruby, C#, and Java are the mainstream languages.

Take a look at this article and chonkthread from a few months ago

https://news.ycombinator.com/item?id=35192913

We had plenty of amazing paradigms/development environments/holistic experiences which we've regressed from:

- LISP environments

- Smalltalk environments

- Symbolics genera

- Mesa and Cedar

- Apple's Newton

Besides things like Oberon...

DotNet is meant to be the replacement. The big problem though is that MS keeps failing to make a GUI framework that is quick-and-easy as VB forms were. Winforms still exists, and it's only a bit clumsier than VB forms, but it's very old and not modern. The more modern .NET gui-frameworks are much less user-friendly.

Linguistically, I think the successor to VB is Powershell. It's the same mashup of inconsistent flags that let you swap between "this is a serious language" and "I'm smashing crap together" with tons of unexpected weird behavior, but instead of being a quick-and-dirty GUI app maker, it's a Shell. Hardcore focus on being easy and productive but unforgivably warty.

As for VB itself, VB.Net just didn't offer much value distinct from C#, so most people who were coding in VB switched to C#.

So if you're an old longbearded MS LOB programmer who started before .NET, and you're still working in Microsoft LOB shops, you're probably doing similar stuff but with C#. But realistically, you've probably also switched to Web.

And the lack of the VB-level ease-of-use in web technologies is a whole other story. All the hoary mess of using a document-engine for a cross-platform application server makes it pretty untameable.

I think the answer is: because Microsoft let it. I'm a big fan of modern .NET, but my biggest complaint is that Microsoft views, and always has, the CLR as the C# Language Runtime and not the Common Language Runtime.

For example, see the relationship between F# and C#. The CLR is constantly getting features that are only to support features in C#, leaving F# in a position where they either don't get the feature, can't add the feature, or begrudgingly add the feature to keep up compatibility with C#, which is something it does take seriously. But this has the effect of "dirtying up" the F# language by either adding features that don't really belong in the language or keeping features out.

The other thing is that C# consistently adds features to itself that are inspired by F#, since F# already implements these features on the CLR, thus showing their viability. So what happens is that C# continually approaches a more bloated language with a subset of it being a poor copy of F#. But then F# gets dragged along towards having a small subset of C# in it for compatibility purposes. So it's simultaneously making both languages worse.

Even the iron languages project that lead to IronPython, IronRuby, etc. was a bit of a Trojan horse to test out and exercise the CLR and .NET with no intention of every providing long-term support for those projects. The DLR, which was implemented to support those, appears to be just maintained by a skeleton crew of people invested in it, probably by those interested in keeping IronPython up and running.

I do not understand why Microsoft takes this approach. It is myopic, shows a misunderstanding of their own technology in the CLR, and ultimately turns C# into another C++, leave dead languages and projects in the wake.

I started my career with VB/VBA/Access, but got burned by one of their non-backward compatible upgrades (I don't remember which versions) that derailed an important project. This was around the time that Java was what the cool kids were using, and I was very amenable to trying open source after that experience, and I never looked back.

It was a great experience though, especially for a self-taught beginner long before code academies and YouTube.

>nothing I have found compares to that development experience today. I would go so far as to say we've gone backwards in a big way.

I did Visual Basic 3.0 through VB 6.0 corporate development for a few years back in the 1990s. The closest equivalent today for desktop apps that still has Microsoft's focus on future innovation is C# with Windows Forms. (I downplay the "obvious" comparison of VB.NET to VB 6.0 because Microsoft already said they will "stop evolving" Visual Basic .NET -- so that's a technology dead end and will fall further and further behind the latest C# as the years go by.)

I personally don't experience that C#/Winforms has gone backwards from VB 6.0. Workflow feels much the same as VB6: Drag some GUI components like text boxes and buttons onto a form, code the controls' event handlers, build the exe.

Related. Others?

Something Pretty Right: The History and Legacy of Visual Basic - https://news.ycombinator.com/item?id=35192913 - March 2023 (259 comments)

RAD Basic – Compatible with Visual Basic 6 projects - https://news.ycombinator.com/item?id=31282195 - May 2022 (208 comments)

Ask HN: Modern, easy-to-start with alternatives to Visual Basic - https://news.ycombinator.com/item?id=30606244 - March 2022 (11 comments)

Microsoft plots the end of Visual Basic - https://news.ycombinator.com/item?id=22570684 - March 2020 (280 comments)

Ask HN: What is the modern equivalent of Visual Basic? - https://news.ycombinator.com/item?id=20548849 - July 2019 (10 comments)

The Rise and Fall of Visual Basic - https://news.ycombinator.com/item?id=20255140 - June 2019 (149 comments)

Visual Basic Turns 25 - https://news.ycombinator.com/item?id=11755041 - May 2016 (145 comments)

Why I am called "the Father of Visual Basic" (1996) - https://news.ycombinator.com/item?id=9229434 - March 2015 (80 comments)

The Birth of Visual Basic (2006) - https://news.ycombinator.com/item?id=8438845 - Oct 2014 (59 comments)

Linus Torvalds, Visual Basic Fan (2006) - https://news.ycombinator.com/item?id=6005587 - July 2013 (48 comments)

The Silent Majority: Why Visual Basic 6 Still Thrives - https://news.ycombinator.com/item?id=4085372 - June 2012 (91 comments)

The web is cross-platform and easier to deploy. The (non-?)existence of RAD tools for it vs VB pales in comparison to that advantage.

While I was never a big fan of VB, I agree that the developer experience has been getting worse for most languages since the early 1990s.

Do you have a top 3 list of things you miss?

Same reason as Borland Pascal.

I feel as if I remember using a VB compiler back in the late 80s. Am a hallucinating?

as a VB replacement https://www.lazarus-ide.org/ seems quite solid

Visual Basic (both of them) still exist, but their use has dropped dramatically through some big changes:

* "Visual .NET" (aka "Visual Fred" http://catb.org/jargon/html/V/Visual-Fred.html ) was released by Microsoft. This was an incompatible language confusingly also called Visual Basic. I don't think Microsoft realized how angry this made developers and businesses, who were being asked to spend hundreds of billions of dollars (USD) to rewrite code just to keep the same functionality. Before that time, many thought that Visual Basic's wide use gave it a kind of "herd immunity". I don't have numbers with me, but I remember that years later that a study found that some were sticking to the original Visual Basic (even though it was no longer supported), a few had moved to Visual .NET, and many other had abandoned Visual Basic entirely (some to C#, others beyond). In short, the Visual Basic community was split into multiple communities, and anyone using Visual Basic would have to worry about either lack of support or yet another harmful change.

* The rise of the web and of platforms other than Windows (including Android, iOS, MacOS, Linux). Visual Basic is fine when you send files via sneakernet to another Windows user. Now people want to access through their web browser, smartphone, etc. If you have a website, anything can access it (as long as they have the permissions), and you don't have to worry about synchronizing data changes the way you do if people make changes on their local device. Most of the simple "fill in a form" kinds of applications that Visual Basic was used for are more sensibly web applications (server side or client side).

Visual Basic is still used. And yes, I think there could be better tools for developing software. But as best as I recall, that's how we ended up here.

Maybe it didn't. What I mean is, maybe the purpose for VB died and thus the language just kinda went away.

With VB.NET, VB basically turned into C# with different syntax. I think a lot of people in that space might as well have been writing C#, so a lot of them switched. Then separately, perhaps almost simultaneously, the Microsoft ecosystem lost relevance.

The web happened. VB was great for builing stand alone desktop applications, possibly with database integration. But they never managed to deliver a similar slick and self-contained solution for building web-based solutions. It didn’t help that the migration from vb6 to vb.net was too painful, but the root cause was the demand for business desktop apps disappeared.

How about some love for Quick BASIC? That was my big Christmas present once upon a time when the dinosaurs still roamed the earth.

People want more these days. With VB you could write a CRUD application that saved data to a database and ran some reports. But now people want the database to pull in multiple feeds from other businesses via API, people want it to be available on the web, it needs to have a self service component so the customer can also log in, at the back end the database is connected to several other systems with daily feeds coming in and out. Shit is just much more complicated these days.

You're probably speaking to VB plus Visual Studio RAD (Rapid Application Development aka "drag and drop" GUI programming) and you more or less still have that today with VB.NET and Windows Forms, with minor differences.

What killed the older VB6 and it's APIs, whose name I can't recall even though I developed for it in the 1990s, was .net coming along.

Be warned, it might just be easier to learn C# as it's more well-supported/documented, and VB.net seems like effectively a language dialect of C#.

IMO the OOP trend of the 90s (Java, C++, Objective-C) made VB look bad.

You might want to check out Lazarus if you can stomach Pascal

New version of VB was VB.net.

People still used VB.net primarily as they were familiar with VB.

But the new projects gradually took over C#.net, as it sounded more cool.

VB.net died after a while.

You really couldn’t beat that GUI creation system. I don’t know if we’ve ever come close.

I used VB 3.0 thru VB 6.0 and I echo the sentiment: those were fun and productive times. Really solid integrated development environment centered around the desktop UI / form design / UI controls like buttons, textboxes, combo boxes, etc.

I also agree that the web changed everything and that is the major reason for the shift away.

Steve Ballmer is the answer you are looking for I think.

I recently wondered:

Why is there no VB-Like tool for building Electron - Apps using eg. React-Widgets & Javascript as the scripting - language?

I'm not married to Electron vs. another similar, possibly more modern / less ressource hungry alternative; or another Frontend Framework.

But it seems to be it should be possible to do a VB-Style thing using these kinds of tools, Drag+Drop, and Javascript, most of the components should be available already...

And it could be a fun environment for prototyping, having fun, creating really bad games & greeting card apps again like in the 90s/2000s etc etc.

It could be a fun learning environment for newbies while a powerful GUI builder for multiple platforms for experts..

Why isn't there such a thing? Would somebody please build this? :D

Honestly it's because Microsoft sucked at marketing. There were so many confusing name choices and unclear development guidelines that people simply stopped using it. Even now developing for windows is a pain and that's because there is like 5 different ways to build an app there.

From my perspective, Microsoft killed it. It did not die on its own. The upgrade path from VB6 to VB.NET was basically unusable. You either stayed on VB6 or you rewrote the application.

> despite all the advances in technology since then, nothing I have found compares to that development experience today

You are going to have to qualify this a lot more, because it is absolutely not true. Coding VB was...fine. Language features were primitive, even compared to what was available in the mainstream back then. The tooling was fully proprietary and expensive. Languages and IDEs today are 1000x better in every way.

>"nothing I have found compares to that development experience today. I would go so far as to say we've gone backwards in a big way"

>"I have yet to find a tool that can allow me to be as productive in so short a time as Visual Basic"

I have and do program in many languages. From my perspective - for type the of applications usually done in VB Delphi / Lazarus would run circles around it. Both productivity and performance wise. It is also possible to do things one simply can not accomplish in VB.

I started my career with FoxPro for DOS, dabbled a bit with Visual FoxPro and then I found Visual Basic. Spent a lot of fun years with it before moving to ASP and web development in general. Not exactly sure what was the reason for its demise. I guess .NET killed it.

they did linq badly after linq2xml and linq2sql

Python is the new VB

The reason is even bigger than just VB.

MS at the time just decide to fully kill the "enthusiast" developer and the "single/truly small" team developer. This is mostly covered under the "RAD" umbrella.

It kills VB, FoxPro, and now more evidently, Access (more like let it slowly die).

.NET + Visual Studio + Sql Server are not a substitute in this market. Them are for "professional developer"/"a small cog in a big machine". The worst part is that this move somehow kill the other tools in this space (because somehow others follow suit or whatever) and without somebody leading the charge to see how adapt this tool for the web. MS not getting the Web, Borland doing Hara-kiri and others getting annihilated by "free" open source and all that not helps.

Ironically, this market have rebound in the myriad of tools like "low code, notebooks, etc" that fill (badly!) the gap.

Popularity of a language is like a popularity of a soda - it's never about the inherent quality or features, but always about the company that stands behind it.

What made VB6 super-productive and quick to get up and running also made it terrible for long-term maintenance, because it hid too much of the details.

Then there were language warts like set versus let (strong vs weak pointers), for example, which was way above the paygrade of the average VB6 coders; and having to rely on the Win32 API anyway in order to start doing actual work and work around all of its limitaitons.

One thing VB6 did do right was forcing interface-based inheritance: Composition over class inheritance was seen as a weakness back then but it was proven as the right concept.

This is just my opinion!

The FOSS community could do SO much better if they wanted to, with reactive web tech, typescript instead of basic, a project file format that's easy to work with in Git, Android support, etc.

Despite all this talk about no-code, it seems like all we have now is like, a CMS that lets you embed Google maps, but if you want to do anything more you have to use code.

Maybe it's just that end users usually don't need to build anything anymore, there's almost always an professionally made app for everything.

I've tried many times to "Build the app you want to see in the world" and almost every time the result is I decide that living with and working around the imperfections of what's out there is more practical than building and maintaining anything by myself in hopes of the the very small chance people notice and it becomes A Thing.

Perhaps better dev tools like VB aimed at one off software like that could change the equation, and if the tools existed we'd all find uses for them?

On Linux, Gambas is a great replacement.

https://en.wikipedia.org/wiki/Gambas

https://gambas.sourceforge.net

I just recently wanted to spin up a simple CRUD UI over a simple DB schema and also thought of Visual Basic for the first time. It seems so well suited to something like building operational tooling for the endless parade of internal APIs.

Because you could only use it if you paid for it. If they had released it for free, as in beer, lots of people would have made wi does apps with it.

The development paradigm was great. I wish three were something similar for Python, having to switch to TCL/TK for UI stuff is extremely annoying.

I was a VB6 developer in the 1990s, and I actually wrote a pretty well known product with it (I bet most people didn't know it was VB6 underneath!).

When I got my first job in software engineering, it was when .Net was in beta. Since I only knew VB, I chose to go with VB.Net and Windows Forms.

Well, that was quite a jarring introduction to actual object oriented programming!

This is the point when a lot of people surrendered. The change was too much, there was no path forward for VB, and Microsoft wanted everyone on .Net.

I eventually switched to C# and we had a hybrid application for a while before it was all ported to C#. It actually went on to become industry leading software in its space.

20+ years later, that doesn't seem to have been a bad choice. Windows Forms is very simple, with a powerful drag-and-drop designer, double-click to hook up events, it's all very similar. Yes, you have to understand object oriented programming much more than you would have under VB, but that's as close as you are going to get from Microsoft on the desktop. They try to hide it as best they can.

I still use Windows Forms if I need to put together something that "just works" on Windows as a desktop app quickly. It's unmatched for that.

There are newer technologies, such as WPF, WinUI3, Avalonia and others for .Net but they come with a complexity that would be above your typical use-case for VB6 back in the day. The VB6 user who just wanted to get stuff done probably doesn't want to have to understand how to implement the MVVM pattern just to get a UI.

Visual Basic was mostly used for LOB applications. That stuff mostly migrated to the web. When businesses decided to move those applications to the web, they had a choice between C# and VB.NET (if they stuck to the MS stack). C# ultimately won. Most of the old VB developers that are still around have converted over to being C# developers now.

When everything was a desktop app then the choice was C++ or VB and there were a lot of situations where VB "won". Today C# does everything VB used to do but better on the desktop and non-performance sensitive applications are increasingly using Electron anyway.

Performance sensitive desktop app = C++ Windows focused non-performace sensitive desktop app = C# Cross platform non-performace sensitive desktop app = JS/TS in Electron Web app = anything but VB

Not just VB, but also things like Borland Delphi.

25 years ago, you could visually compose a UI using standardized components, including advanced concepts like a layout manager. You could do data-binding visually by navigating a linked database. You can write logic/events just by double-clicking a button and the event is created. Here you'd write your code which would typically be pretty easy because all contextual objects are readily available.

Sure enough, I understand that the above development model also has its limitations and doesn't serve all common modern needs. But still, it's pretty pathetic what we ended up with. Our tool chains are much more complicated and we program at a lower abstraction level whilst requiring a laundry list of skills.

Microsoft effectively killed VB because they decided everyone should be using .NET. While they created VB .NET in an attempt to make the transition palatable to VB programmers, this was a second-class citizen of the CLR, and more importantly too different from VB, more akin to an inferior C# with VB-like syntax than actual VB. It was widely decried by VB developers [0], and nick-named "Visual Fred" due to really being a different language than VB. Microsoft ignored that, and also didn't bring a VB-like experience to .NET (maybe with the exception of WinForms, I'm not too familiar). It didn't help that mainstream software development started drifting to the web, and later to mobile apps.

[0] https://classicvb.net/vfred/breaks.asp

Yet I can't help wondering what problems it had that caused them to abandon it?

Tech comes and goes, there’s nothing to vb specifically. As a language it’s pretty limited, tedious and quirky.

Moreover, why hasn't someone come out with a solid replacement?

Because webdev at its core is a community of stubborn smart guys who love the complexity and hate dull business code. They will present absurd arguments like I can do this and that, as if it couldn’t be packed into a vb component and drag-dropped onto a form from a palette without accompanying 1kloc boilerplate and pages of configuration documentation with no sane defaults. VB GUI model may be obsolete, gray and non-responsive, but no one prevents from building responsive interfaces wysiwyg way. My peer web designer does it without bothering with html/css much and it works for her for decades. All the tech is there, it’s just nobody’s collective interest to combine it into a business RAD instead of an intermediate haskell-level mindfuck starter kit. You can’t burn hundreds of millions doing actual work on a platform that everyone could start using solo in just a few days and deliver a working solution next week, even if raw and clumsy as it usually goes with non-pros.

I’d like to get a better and less bitter explanation, but there is none.

Related but off-topic: Nothing I see today compares to the productivity that I saw with Lotus Notes, Dbase 3 and 4, Paradox, Microsoft Access, and a few other things from that era. There are some really good SAAS offerings that target this space, but none of them seem as dominant as I would expect. There was a time that if you wanted a simple application that could be covered with 3-4 tables and 5-6 views, any of the things I mentioned above could handle it. You could explain the business problem and hand a developer a book on any of the above technologies and expect to have a working product a month later. Today, this isn't really true. It does seem we've gone backwards a bit...

I am actually trying to make an open source successor, but using Javascript instead of Basic, at https://github.com/yazz/yazz and a demo at yazz.com

Windows only desktop applications died.

VB died because Microsoft killed it off (through other products).

I actually wrote a long article on this [1]—and had a chance to interview some of the team that built the original version of VB that was sold to Microsoft. (Alan Cooper and Michael Geary; Michael actually frequents HN pretty regularly!)

My opinion is that it was a confluence of a few factors:

- Microsoft was very worried about the threat of Java/Sun, and rotated hard into .NET and the common language runtime as a response.

- The most vocal, but minority of VB users wanted more advanced functionality (as is often the case). Couple with the shift to .NET, Microsoft listened to them: VB got a full rewrite into an object-oriented language and the IDE moved further away from the VB6 visual building paradigm. That left the silent majority who high and dry.

- The web emerged. Working with the Win32 API was suddenly less relevant, and younger devs adopted PHP en masse, rather than adopting VB. (Unforced error on Microsoft's part, since IE had 96% browser marketshare in 2001)

[1] https://retool.com/visual-basic/

The productivity wasn't really that good. Rose tinted glasses. All the VB apps I've seen (and still get paid to maintain/rewrite to this day in the finance world) are an order of magnitude simpler than even a simple modern website. They often only have a few users, no devops automation, no deployment automation, terrible logging, terrible instrumentation, no tests, unacceptable access control, tons of failure edge cases, and poor performance.

Most don't even have central databases, they just sit on Access and get copy pasted around like spreadsheets.

While the UI part of Visual Basic was fast and easy, so is writing a React frontend that just stores data in browser LocalStorage, has no authentication, no logging, no monitoring, no tests, and deployment is emailing an updated js file to customers.

The complexity of modern development enables 10-100x better productivity across all aspects of: safety, security, monitoring, error handling, maintenance, and new feature development.

I can whip together a modern website that ticks all these boxes. To achieve the same in VB+Access would be monumental.

Just partly on topic: the code name for the first version of Visual Basic (or its predecessor) was Ruby, IIRC, as recounted by Alan Cooper (the "Father of Visual Basic) in an article I read some years ago.

Because C# as a contender to Java had to succeed (and the CLR)

VB lives on as Visual Basic for Applications, but you have to have MS Office to get that.

What is lacking is a compiler to make a stand-alone file. MS Access has the most robust Application object, in my experience.

Basic as such has, e.g. https://www.freebasic.net/

> What problems it had that caused them to abandon it?

My understanding is that the ActiveX goodness that makes VBA quite handy for your stand-alone needs is also a security nightmare.

From a security angle...

.net webapps written in asp.net behave similar to PHP in that any file with a .aspx extension that is within the web root will execute by default. This means that asp (and php) webservers are particularly vulnerable to RCE attacks because the default configuration of the server turns an "arbitrary file upload" into a remote code execution instead.

Where an asp.net server would handle front-end and api and they would be tightly coupled, we've moved on to where the most common configuration is a separate API and frontend. I believe you lose a lot of the benefit of using asp.net to try and decouple them.

On a totally personal note, as a penetration tester I've proxied requests from a LOT of different APIs on a lot of different technologies and asp.net is hands down one of the worst to test, the way it handles requests under the hood is unruly and ugly. Some might say that's a positive in terms of security, but IMO it makes it harder to identify vulnerabilities in your system.

Back in the WinForms era of .Net, I got the impression that anything you could write in VB you could write in nearly-identical-line-for-line C# (minus the language syntax differences).

Once it became just a subset of C# with different syntax, I suppose it had little reason to exist because nothing made it special anymore.

We built some pretty big applications with VB6 (heavily optimized by using WinAPI-Calls and C++-libs where necessary). Nothing what came later matched development speed (although some langs using REPLs may come close). Whoever designed VB.NET didn‘t know anything about the things VB6-developers like my loved. So VB died because what came next simply wasn‘t VB.

It didn't die, it was murdered.

The DAO and OLE Automation was a paradigm that saturated the market with similar applications, and the move to mobile/cloud platforms essentially made the computational overhead a liability. Yet in a way Microsoft VB helped standardize the look of event driven GUI workflows (also why windows 11 design sucks).

VB "made simple things easy, and difficult things impossible" in a developer environment. Its funny that the ecosystem of OCX still haunts many projects.

It could be Python took over the role of an introductory language. =)

I was working in C++ on OS/2 at the time when a resource editor was hard to find and that chasm from the command line to the GUI was what made the jump to commercial software development feel like the Khumbu Icefall.

I worked in a small software development sub at a big bank and they needed a rolodex. I agreed to do it in my spare time if they'd buy me a legal copy of VB 1.0. I did the prototype in what feels like a glacial week today, but they followed through with lunch and a shrink wrap copy.

If there's a death of GUI or IDE development tools it's the same for all of them with the possible exception of the outer edge of Jet Brains and VSCode. Put simply, they don't scale like command line tools since you're dragging a 200 ton freight train of GUI bloat behind you where it doesn't deliver the impact gravity that the train does.

HCI or GUI should scale like APIs do, but they don't, particularly now that resource editors are everywhere, and we're about to replace highly paid drag and drop mouse typists with nearly autonomous agents.

Humans benefit from visual affordances like VB because VB lowers the bar, or the barrier to entry. GUI development would still be stuck in the late 80's if Cooper hadn't made it possible for the inmates to overtake the asylum with their drag and drop tools.

I do wonder if there’s an alternate universe where MS did a better job of modernising VB (VB.NET hardly counts), and where Borland was less doggedly intent on murdering their golden Delphi goose, and where frontend development is now quite easy.

First of all, desktop software just isn't as popular as it used to be. Everyone wants to develop a webapp or a packaged app.

Second, Microsoft consolidated all of their languages into .NET right around the time you're describing, and they all get translated into the same middle language before being compiled. Maybe except C++? Not sure. Either way there's really no reason to choose VB when you can have C# and they all get converted to the same thing.

Lastly, Basic was always seen a "hobby" language, a reputation which was carried over to Visual Basic. So once again, serious programmers will look at the Visual Studio suite and go with C# or C++.

> I'm no fan of Microsoft products but, I have yet to find a tool that can allow me to be as productive in so short a time as Visual Basic.

I don't like Twinkies, but I eat them anyway because, sugar.

VB was a godsend for me. Despite being a very capable DOS and embedded/RTOS developer, the learning curve for the ugly tools and API's for Win3.1 development was more than I wanted to handle.

It was magical how easy it was to build little tools and line-of-business apps in VB. And after eventually learning MSVC and MFC/ATL, I was even more impressed with how easy VB was compared to that.

But .Net killed VB because C# was enough for both noobs and for real programmers.

Easy answer: the index of arrays doesn't start at 0

It's similar to Microsoft Access. Not for everyone, but still did some things few other tools do out of the box.

VB was a form of relatively low code, relatively speaking to other ways of building applications.

There was a swing from the desktop to the web, but it wouldn't be unrealistic to say building web apps that render the same html/js/css became at least a few orders of magnitude more complex during that time too.

There remain personalities, belief systems and practices that believe things should be difficult and not easy to become a beginner in for it to have value for a few instead of the many.

Speaking of nostalgia and Microsoft deprecating great low-code development tools…

I miss Access Data Projects.

These had the Access front end and VB rapid app development experience, but was backed (only) by SQL Server. It wasn’t the classic ODBC external table connector. If you added a table in Access, it would create a table in SQL. If you created columns, foreign keys, or views, the changes would be made directly to the database schema.

This also eliminated the data corruption issues that plagued file-based databases.

It truly was one of the fastest and best ways to write an internal-use business app.

So of course, Microsoft took it out to the back and quietly drowned it in a tub.

Despite being dead, I suspect there are a large number of very high value Excel workbooks with significant lines of VB(A) in them.

I've experienced 9 digit ventures which fully depended on large (hundreds of MB) Excel workbooks which talked to dbs, remote APIs, and network files to make complex calculations. It's invisible to most of the world, but it's definitely there and alive.

No fault of its own. We simply stopped building windows apps and started building for the web instead. The best web apps still pale in comparison.

The broader question is, why did "Visual Programming" die, or rather, why is it always rather niche.

Visual type coding / low tech coding, drag and drop of computing blocks and other GUI based programming approaches is a perennial promise and brilliant examples light the sky every once in while like fireworks (Scratch, Web "Mashups" [1] come to mind as other examples).

The outline of the answer must be that the capabilities enabled with such GUI oriented programming styles don't hit a sweet spot with large numbers of less technical knowledge workers. Compare e.g., with the spreadsheet paradigm that is a resounding success despite Microsoft. But why that is is not clear.

[1] https://en.wikipedia.org/wiki/Mashup_(web_application_hybrid...

Visual Basic died for the same reason that Win 7 & Win 8.1 died.

..

I've mentioned here in other occasions, but worth doing it again: GAMBAS (https://gambas.sourceforge.net/en/main.html) is a cool, modern and powerful alternative to the old good VB RAPID stuff. I haven't personally used it in ages but I recommend to give it a shot.

A few thoughts - loved VB and made my first money as a high schooler by programming in it.

As far as I can recall it was the only programming language that let you begin by laying out the UI and then wire up the code later. Like your project started up with a blank Windows window. You drag a button or a text area and you hit Run and your app right away has a window, a button and a text area.

To write code for the button click, you click the button in the editor and write it.

A few years later jBuilder (I think) allowed you to do something like with Java, that though not as simply. I am not aware of any dev tooling that offers that today.

I suspect a few things happened that made VB go away. I think VB was aimed at one-man dev, not sure how it would work with revision control and team development (eg when u think of your project as a window you drag stuff onto, how do you deal with merge diffs etc.) I also think the world migrated to more client server / web stuff around this time, while VB was very married to a standalone windows app. And then on the flip side, probably coding became stronger in excel so some of the stuff moved there.

VB was amazing, such a pleasure to create in.

I learned Visual Basic (6) a few months before I learned C#.

Hands-down, C# was a much better language. Visual Basic (the language) always left me feeling dirty compared to C#. Both languages have similar learning curves for a novice; but C# includes industrial strength features that allow code written by a novice to be refactored instead of rewritten when the need comes along.

Both languages have a similar way for designing a Windows Forms UI, and the API for working with the UI from code was generally similar. Once C# came around, there really wasn't a reason for using Visual Basic 6 for a quick-and-dirty UI because you could do the same thing in C# in the same amount of time. (So why waste your time with Visual Basic at that point?)

I personally think the "VB.Net" situation is what really killed Visual Basic. There really was no reason to force everyone to rewrite their projects, because VB.Net didn't "add" anything. Instead, VB.Net turned into a smell that someone wasn't savvy enough to use "real" C#.

I personally don't know when I'd pick Visual Basic 6 over C# for a Windows application; but I have a pretty serious development background. I also noticed that novice developers tended to come up to speed with C# rather quickly, so I'm not sure if the more casual nature of Visual Basic 6 really helped anyone.

Visual Basic died because of the Web.

VS, and Delphi, are the masters of creating desktop applications. However, both failed to port to the web, and them to mobile.

There are a lot of reasons why they failed -

* missing graphical expression capabilities for customer facing websites

* using languages that are not native JS, preventing them from utilizing the JS eco-system

* Vendors (Google, Apple) who for their own reasons kept mobile development native on their language and tools. And many more reasons.

Last, both have paved the way for low code application builders for enterprises, which are mostly aimed at internal systems (not customer facing).

Worth noting that we, at Wix, have built the Wix dev platform learning from VB and Delphi, creating a website builder platform with similar concepts (I am the creator of Velo by Wix, the Wix dev platform, and having 10 years experience programming VB and Delphi).

To be clear, Visual Basic isn’t dead. I work in the govtech space. I can assure you that there are VB6 applications still running into production in this space, even places you would not expect. VB6 doesn’t support threading, but I’ve seen Computer Aided Dispatch applications that use C++ to multi-thread VB6 server code for emergency 911 dispatch.

VB6 still runs on Windows, and will even work just fine in AWS.

"On Error Resume Next"

I like a lot about the language, but let's not let nostalgia run away with some of the bad points. And that's not even getting into COM/OLE registry mess, or difficulty of handling c type/vb type mappings when interacting with the api. A lot of what I liked, I now like about powershell or python.

This seems like an asshole move when there already is Librivox for decades.

Many of the readers of Librivox are not great, but I'd rather have the worst of them over AI.

Even a future better AI that knows more about when to pause and how to pronounce things the right way from context, will still be lifeless because it can't actually understand the full context, only the surrounding words. The actual full context of a given word or phrase requires not only pattern-matching the surrounding words, but having a sense of self and inserting that self into the described situation, and applying that selfs response to that, which will be not only more lifelike and realistic and meaningful, but also be a bit different for every different human reader. Good readers aren't simply doing it more correctly, their own unavoidable interpretation of the text is in their reading, even if they are trying to be a robotic neutral newscaster.

Sometimes I'm actually annoyed by how a reader reads a given sentence differently than I would have. Like they failed to realize what the thrust of the thing was and focussed on some other part. But even those are better than an AI that will either always apply the same algorithm, or worse, maybe varies it but only randomly, not as a result of having a personality that colors everything.

I guess at some point they will be able to make AI's that can fake the quasi-random-consistency of a personality. If someone can describe the problem like I just did, then someone else can code up a response to it. And then it will be good enough to essentially fool most not-very-perceptive people, and that will suck because it means we won't have a choice to avoid that crap any more. Much content will simply only be produced this way, because it will be cheaper to make and good enough for most people, and so will sell. Once it's good enough to sell, that's it, that's what happens almost exclusively after that. Like bluetooth headphones.

It was killed by VB .NET, a different language that looks similar to VB6/VBA on the surface but has nothing at all to do with it.

I learned VB when I was 8 and built a few games with it. I wish I kept coding :'(

For anyone looking for a modern alternative to Visual Basic, you might want to take a look at Xojo.

Xojo's a rapid application development platform (both a language and an IDE) that you can use to develop desktop apps (for macOS, Windows, Linux), Web apps, mobile apps (for iOS and Android), as well as console apps. It's been around for more than 20 years, and some of you might remember it from back when it was called REALbasic.

I'm a solo custom software developer that specializes in NetSuite, and I'm using Xojo to develop all kinds of apps that integrate with NetSuite - from desktop apps to mobile apps to Web APIs.

There's a blog post on Xojo's site that provides a good summary of how Xojo is both similar to and different from VB. It's an older post (from 2013), and Xojo's come a long way since then.

https://xojo.com

http://blog.xojo.com/2013/06/19/a-modern-alternative-to-visu...

C#/WinForms is the spiritual successor to VB. Even better than VB6.

Another fun story:

A strip club was asking for a camera system and pos system in 2006. I already had a nice PCI based capture solution for the CCTV system but the POS software was still an unknown.

When I learned that the average cost per terminal was going to run me $700/ea., I decided to write my own POS in VB6 (Along with Receipt printer stuff, USB Card Swipe Stuff, Authorize.net Etc). This was completed in about 1 month while still living in my moms basement.

We had a lot of fun sitting in the security room popping the cash drawers as a prank and having the girls complain over the radio about them being possessed. Long live VB6!

VB6 allowed me to write apps "On Site". I'm talking crazy stuff like a customer asked for a personal phone call when the apartment building maintenance room door was opened:

1 Google VB6 LPT READ (Run a wire from alarm panel to LPT port pins) 2 Google VB6 Modem Dial (Hardcode customers cell phone and add exe to startup folder) 3 Bill the customer for 30 minutes of "software development".

I've never been more productive than with VB6 and sample code of the web. I do not write software for a living and the lack of tools like it are a real bummer.

[flagged]

I was typing "visual programming fails because of collaboration", as in testing, code reviewing etc, but then graphic designers can collaborate on projects so I don't exactly know.

I think the path from VB.Net to C# was too easy and C# offered too many advantages.

Microsoft stopped supporting it. VB 6 was the last "true" Visual Basic. The .Net Visual Basic was not backwards compatible with the very large code base projects everyone had created over the years and ones on forums and websites like planet-source-code (before GitHub existed) and the many, many beginner-friendly books.

They had a conversion wizard to migrate VB 6 projects to VB.Net but it was very half hearted and never worked on anything except the very trivial code bases. Anything that used OCX and you were out of luck, except OCXs were very very common in classic VB development.

People kept writing VB6 as long as it was practical (Windows 7) and then either moved on to greener pastures or left coding altogether as it was becoming impossible to use modern libraries anymore and the overall learning paradigm have shifted from books/forums into video tutorials and "modern" languages.

I'm curious if I should have been more kind to Visual Basic because I went with C# and I'm still in love with Ruby. There doesn't need to be a barrier to more powerful and efficient coding, as far as I can see. Even when the technology allows expression, the human element is usually the barrier.

VB was mostly for IT departments to create small custom apps without having the full software engineering skill set. This was the time when software development started to be outsourced to the 3rd world. Most of the low level apps that were maintained in a companies IT department would have been outsourced easily. But the companies taking on these projects in the 3rd world would have used more complex development tools just to look and feel like they are doing complex work.

I do not mean to suggest there are no complex software coming out from the 3rd world. But most of the outsourced projects are simple CRUD applications

in one word - CSS.

CSS has killed VB.

How? when you need to build any application with custom graphics or UX, in VB you are gonna writes tons of lines of code, while using CSS you just write 2-3 declarations.

I remember it as the push to C#. Microsoft had basically shat themselves about Java, and were pushing C# as its rival. VB.Net was a bit broken, there was lots of "you'll have to use the C# interface for that because the VB one isn't ready yet". Generally as developers we were pushed to C# and the writing was clearly on the wall that VB wasn't going to continue as is. The whole Microsoft stack was converging on C# and moving away from VB.

And the replacement of COM with .Net has an impact. We had a whole ecosystem of COM (and DCOM) objects that worked well. .Net broke all of that, and didn't replace them for years.

I don't think it was the move to OOP. VB4 introduced classes way back in '96 (iirc), and by VB6 everything was objects. It was a little more complicated for newbies (I remember training junior devs in OOP in the early '00s), but once they got the hang of classes and instances it was plain sailing.

On Error Resume Next

It never dies

VB is just C# with a syntax that would extremely unfamiliar to most programmers. Basic itself is no longer commonly used to teach coding so I can see why there would be little demand for such a language.

Microsoft killed VB for one very simple reason:

They were terrified of Java and the JVM that went along with it, as it would make their cash cow - Windows possibly redundant. They basically switched everything to .Net and the CLR.

Also, you are looking at VB through rose tinted glasses. VB was a terrible system to build products on: - Poor language. BASIC is not, as implemented by VB, a production level language. I am sure folks will argue that point, but I will stand by it. - The component model was terrible - you had to drop in to C and use OLE/DCOM to create components for it. A VB dev couldn't create components directly in VB. - DLL HELL. Shipping VB code was a nightmare.

Delphi was an answer to all of this - but Microsoft killed that too by stealing Anders Hejlsberg, whow went on to create the .Net frameworks, implementing many of the Delphi innovations in a Microsoft ecosystem.

I'm the co-founder of Budibase and we've spent the last 5 years building what we believe is a better, faster, open source replacement for VB.

Check it out:

[1] https://budibase.com

Thankfully VB's "Unix philosophy" counterpart -- Tcl/Tk -- lives on. I have always found it faster to go from zero to GUI by laying it out declaratively in Tcl/Tk than by rat wrestling in VB -- and the results look better. With the Snit object system (part of the popular Tcllib), building components out of the basic widgets becomes a breeze.

The problem with VB and with other "business languages" going back to COBOL is that the skill ceiling is low. Not as low as this decade's no-code craze, but tools like that make the easy bits easier and the hard bits asymptotically approach impossible -- and as projects mature, hard bits dominate the lifecycle. Tcl has an absurdly high skill ceiling but it has problems of its own. You can do crazy Lisp-style metaprogramming, but the semantics are as if designed by a Lovecraftian madman who'd been exposed to dread Cthulhu.

So nothing is perfect but there are ways to feel as productive as VB, even today.

The language died because of Microsoft tried to woo java developers into using the .net ecosystem. So whenever the CLR got more features, C# started supporting them more readily.

VB originally wasn't thought of as an OOP language. But through vb.net when that paradigm was "imported" the language lost its charm.

Further more, web development took flight. No one was interested to build desktop applications anymore.

Also I wouldn't say the influx of java developers into the .net ecosystem was that considerable. (Or for that matter other platform developers like python, delphi). It was definitely slow during the 2002s. Because the java ecosystem had achieved code-once-and-run-any-where paradigm. You could write desktop applications developed on windows, on, linux machines. From a business POV why would application developers "want" a different ecosystem to achieve this?

All this sort of eventually killed classic VB.

No stickers.

I'm only half way thru one good post after another. But I don't see many posts about: can VB be extended, expanded, developed? Truly, I am far behind most, and currently I am working on an app, in Excel, that helps the voiceless (like me), speak. I worked w/ Access VB for a short while, but, it, at the very least, needs Sql Server. Also, there are issues with threading, but is that the end of it? Since VB is a high level environment, speed is an issue. I have not yet heard that Excel is really headed toward .net or any other framework, but I keep checking. If anyone at MS wants to appologize for the Ribbon, don't bother. I will never accept! But can VB, in some way, be fixed or rehabilitated or improved, or whatever? I do hope so, but I can be persuaded otherwise.

if you need to fill a RAD niche in your workflow. Pascal is still around with a nice IDE https://www.lazarus-ide.org/

"why hasn't someone come out with a solid replacement?"

There are some companies/people keeping the torch burning but they're not as widely known, one such is Mercury which targets a whole host of platforms and is actually quite good - https://www.remobjects.com/elements/mercury/

The problem is it feels a bit of a niche language now because MS basically forced people on to C# by not actively maintaining VB.NET which was the first hop for people coming from VB. Early in my career I did various conversion projects for corps from VB to VB.NET then eventually as that atrophied to C#.

> I would go so far as to say we've gone backwards in a big way.

I would say you probably just don't remember how bad VB was. As a language its extremely simple and misses most of the modern niceties we take for granted, no iterators, no maps, no anonymous functions, no multidimensional arrays, no objects, the list goes on.

I remember when I moved from Basic to VB the single most impressive thing was that it AUTOMATICALLY KNEW THE LINE NUMBERS! YOU DON'T EVEN HAVE TO WRITE THEM ON EVERY LINE! If you made a mistake IT COULD JUST TELL YOU THE ERROR, no more looking up codes on a table in the back of a book.

Basic was never supposed to be good to use it was only ever supposed to be easy to learn.

It's not only related to Visual Basic. It's an ecosystem. Some animals die, some animals born.