This sounds great but I’m genuinely unable to figure out how to get to part one.
Not the thumbnail. Not the pink text “A History of Visusl Basic”. Not the number one on the list of chapters. Not the chapter ousted at the very bottom.
The next button is for a different article.
How am I supposed to navigate to the thing the article is advertising to me? It’s a very strange decision not to make it really easy with a strong call to action or obvious link.
What an awful site. I suggest you read about prefers - reduced - motion [0]. People who set this preference have a good reason for doing so, you should respect your users a bit.
(I set this preference because motion while I'm trying to read makes me nauseated.)
My very first purchase on eBay was to buy a used copy of Visual Basic 6 Enterprise Edition sometime while I was in school.
Then for a period of time I lost the physical CD it came with, and couldn’t install it anymore on a new system. Some time later I remember finding the CD at the bottom of some box of random stuff and being so happy - it was scratched up and didn’t reliably install, but I think I managed to burn a copy of it onto a new disk complete with inkjet printed sticky disk label that resembled the original disk.
Any time VB comes up I repeat my same wishlist item. I would love for Microsoft to open source it, in any way, shape or form. I would love for the community to take a crack at adding things to VB6 like bugfixes, any missing features (my understanding is they don't own everything about VB6) and just overall general improvements, imagine VB6 with threading. I know its ancient, but it can still produce a native GUI application effortlessly.
I’d want this if only because I’m stuck maintaining old industrial software written in VB6 (it is omnipresent in manufacturing) and I’d like to have a development experience that is actually somewhat usable.
(No, TwinBasic isn’t adequate. No, a VB.NET migration isn’t feasible.)
I mean, for a “clean room implementation” you could offload the work to Claude and GPT, you have one model describe the assembly into a spec file, you pull down open source programs from Planet Source Code that SHOULD compile, and then you have it ensure it compiles 1:1. Then you watch and let it run through the process in a few weeks.
If you dont care about clean room then you plainly disassemble it and translate it. I live in the US where the second option might not be legal.
You might want to mention the comedy series Microsoft used to run on MSDN. I think it was called “The .NET Show” or “VBTV”. It featured characters like the “VB Rapper” and “Head in a Box” (Ari and Chris). It was genuinely funny and they made at least a few episodes. I loved Microsoft back in those days. Unfortunately, I haven’t been able to find any trace of it online now. This was really long ago - around 2002, I believe.
Why on earth would you use an AI-generated image [1] (let me be clear: POOR AI IMAGE) for the banner of this project?
If you're going to use genai, you need to make sure it actually looks acceptable. Do at least one careful pass over it before publishing. Just look at the details:
- The text on the book spines doesn’t even spell “Microsoft” correctly.
- Dartmouth is spelled "Darmouth". SIGH.
- The screenshot on the CRT monitor doesn't remotely resemble any version of Visual Basic I’ve ever used and I’ve been using it since Visual Basic for DOS.
Using an image like this sets the tone and impression for the entire book going forward. Right now, that first impression isn’t good.
It won't be long before people realize that having poor AI images looks worse than having no images, in the same way that having a reaction GIF every other paragraph of a blog post fell out of style or deeply generic and unillustrative clip art or stock photos of puzzle pieces or featureless-white-3D-figure-with-hard-hat-holding-question-mark.
I sympathize with the motivations behind it, but it does look cruddy and cheapens the end result.
Haha wow you weren’t kidding. That image is so bad that it looks like it was generated using 3 year old models.
The computer screen I can forgive, but if they author genuinely doesn’t have access to modern image generation tools then they could have at least loaded that image up in GIMP, Paint.NET or even just MS Paint, and added the text themselves.
Not that the author needs my defense, but that image says to me, 'hey, I'm just a guy who wrote a book and there's no budget for art' -- which fits a DIY aesthetic in 2026
Not to me it doesn't, to me it says, "Hey I couldn't be bothered to put in the bare minimum of effort to look over an image that is going to be the LITERAL face of my upcoming book".
Took me 10 minutes to do this with an equal "budget" and the freeware graphics program Krita. Still has problematic issues (the curvature on that CRT looks like its suffering from bloody glaucoma), but it's vastly better than the original.
My first impression was that the text style is dismayingly like either an AI wrote most of it or (to be charitable) the author’s writing has been heavily influenced by the current generation of LLM output. So the image style goes perfectly with it.
That computer (and chonky-boy floppy disk) look so unlike any real computer from back in the day that it honestly makes me question if the author knows anything about what that era was like.
These AI images are an absolute plague these days. I’m glad more people think they’re genuinely awful. To me they’re absolutely disgusting. I think I’d honestly prefer Macromedia Flash ads over this.
Get used to it. This is the future we've created for ourselves. It's only going to get worse as people everywhere try to use AI to distinguish themselves. Expect everyone to be an artist, everyone to be an author, everyone to be a programmer. Slop. It's what's for dinner.
The problem isn’t the use of AI. It’s the lack of editorial effort to use AI well.
Modern image generation models can handle text fine. Or the author could have left those artefacts blank and added the text themselves in “post production”
The problem is the use of AI. It’s a reliable indicator that the author doesn’t actually care about the quality of the work, so I shouldn’t bother to read the text.
This is just lazy AI use as a replacement for lazy stock image use. The details of exactly how it sucks at its job while providing something that fills a checkbox for someone who has no concern for quality are somewhat different, but the basic failure is the same.
I couldn't open the chapter, but in case anyone else is trying to make a nicely formatted ebook, take a look at EPublish: https://frequal.com/epublish/
It's a software-engineer-friendly tool for converting HTML to EPUB. It handles all the annoying little details. Binaries coming later today.
Same. My first paid programming job while I was in college was for writing VB 5 software for local businesses. The GUI builder was the obvious star, but you could also write sophisticated programs.
I remember the form designer was a standout feature. Microsoft added a complete UI framework into VB for DOS based on the standard ASCII character set.
VB for DOS really needed a version 2.0, but it never got it.
Much appreciated. VB6 was my first attempt at learning Win32 programming. I’ve written so many tools and games with it; it even helped me land my first job. A true golden age.
I've seen that, but always assumed it would be a more accessible account, and not tickle the technical developer itch.
I recently read Jordan Mechner's The Making of Prince of Persia, and while it was interesting, it wasn't what I'd hoped for. It was a biography covering his life during the creation of the game, and very little about the internals and technology of it. That's fine, but for my tastes, the book that it really was, was less captivating than it could have been.
My default is to expect the same from the FoxTales book.
Or just plain FoxPro. I was writing dBase programs to put myself through undergrad in the late 1980s/early 1990s and I really liked the early DOS versions of FoxPro with their extensive mouse-driven TUI -- even more elaborate than the ones Borland had for their "Turbo" languages.
VB was practical and useful at the time, especially as a learning tool in school. I enjoyed testing the competitors that arose to emulate its abilities, including RapidQ Basic, Envelope Basic (a.k.a Phoenix Object Basic), some of which are documented here: https://en.wikipedia.org/wiki/BASIC
I think it would be cool to see a Documentary on programming languages, e.g. their history, rivalries, successes and downfalls, of the 80s, 90s and 2000s. If it is made correctly, with humor, it could be entertaining, perhaps even profitable.
There is definitely a story to be told in GUI based development environments, from VisualWorks / Digitalk smalltalk to VB to Delphi. Along with the also rans (PowerBuilder, the death of Clipper and dBase systems).
GUI interfaces were going to be a massive productivity goldmine compared to green screens and TUI interfaces. Now here we are back to those again in various forms and web browsers won in the end anyway.
Was a wild ride in the 1990s when it was happening in earnest.
I recall an internal (never released) project at IBM in the late 1980s. It was a tool for creating client-server GUI apps, programming them with the REXX language. You may remember that client-server was all the rage at the time, and REXX was IBM's favorite scripting language. IIRC, the internal name of the project was "Red October", but I can't find any reference to this online.
The tools lacked the visual GUI builder of VB, but really, that's just a detail. The rest of the framework was really quite powerful, and a GUI builder could have been added. But in true IBM fashion, they had no idea how to market something that wasn't mainframe targeted, and they killed the project. There was a fair amount of acrimony on internal forums about this at the time.
You are correct. The only reference I could find to Red October is a dead link which was never archived (or has since been removed from) @ Wayback Machine Internet Archive: https://www.ibm.com/history/innovation/red-october
Otherwise, the other links point to the game, the movie and the cyberespionage malware attack.
What I find fascinating (and have posted about in the past) is the story of how 16-bit Visual Basic VBX's became a success disaster, growing out of Microsoft's ongoing programming language wars, during the migration from Win16=>Win32, leading to the wildly successful yet disastrous COM/OLE/MFC/OCX/DCOM/ActiveX/ATL ecosystem, with its influence on COM-clones like mTropolis plug-ins, Macromedia MOA, Qt KParts, OpenOffice UNO, and Mozilla/XulRunner XP/COM, and how Visual Basic Script, MSJVM, ActiveX, and ActiveX Behavior Controls, AJAX, SOAP, etc played out during the browser wars, and how they currently inspire and forewarn WASM development.
>Wow, a blast from the past! 1996, what a year that was.
>Sun was freaking out about Microsoft, and announced Java Beans as their vaporware "alternative" to ActiveX. JavaScript had just come onto the scene, then Netscape announced they were going to reimplement Navigator in Java, so they dove into the deep end and came up with IFC, which designed by NeXTStep programmers. A bunch of the original Java team left Sun and formed Marima, and developed the Castanet network push distribution system, and the Bongo user interface editor (like HyperCard for Java, calling the Java compiler incrementally to support dynamic script editing).
>That's because Java used the old piece-of-shit NPAPI (Netscape Plugin Application Programming Interface) from 1995, first released in the NetScape 2.0b3 Plug-in SDK: [...]
>More about Netscape's fleeting obsession with Java and Javagator in the pre-LiveConnect/XPConnect/NPRuntime/ActiveX/DHTML/XPCOM/XUL days: [...]
>Yes, I think you've captured the difference: An "extension" is written in an extension language like JavaScript, in a browser that's intended to be extended in that language. A "plugin" is a more independent piece of code written in a compiled language, plugged into a host that doesn't necessarily have its own extension language like JavaScript or Visual Basic.
>It was funny when Sun proudly and unilaterally proclaimed that Sun put the "dot" into "dot com", leaving it wide open for Microsoft to slyly counter that oh yeah, well Microsoft put the "COM" into "dot com" -- i.e. ActiveX, IE, MSJVM, IIS, OLE, Visual Basic, Excel, Word, etc!
>And then IBM mocked "When they put the dot into dot-com, they forgot how they were going to connect the dots," after sassily rolling out Eclipse just to cast a dark shadow on Java. Badoom psssh!
Glad you asked! One of my favorite topics. ;)
COM is essentially a formal way of using C++ vtables [1] from C and other languages, so you can create and consume components in any language, and call back and forth between them. It's a way of expressing a rational subset of how C++ classes work and format in memory, in a way that can be implemented in other languages.
It was the outcome of the C / C++ / Visual Basic language wars at Microsoft.
The original 16 bit version of Visual Basic version 1 through 3 had a plug-in extension mechanism called VBX -- Visual Basic Extensions [2].
They were extremely popular and became a victim of their own success, after a whole industry grew up around them, and people started using them for all kinds of things they weren't intended for, and wanted to use them from other languages and frameworks like Borland. Microsoft had to do something about that to mitigate the success disaster of VBX, so they invented COM.
At the time, Microsoft was transitioning from Win16 to Win32, so they came up with the 32 bit COM definition, also known as OCX's, or OLE Controls, which they later called ActiveX, because COM was so hard to search for, and they wanted to take the spotlight away from Java with a new buzzword.
So they brewed up a bunch of ugly C macrology that enabled C programmers (or Visual Studio wizards) to define COM interfaces in header and implementation files that just happened to lay out memory in the exact same way as vtables of C++ pure virtual classes.
While C++ programs would use other ugly macros to declare actual honest-for-god C++ classes to implement COM interfaces.
And Visual Basic programmers would ... do whatever it was that Visual Basic programmers did.
COM's IUnknown::QueryInterface [4] method is essentially like C++'s dynamic_cast [5]. But it also adds some object aggregation features [6] that let you compose multiple sub-objects together by aggregation instead of using monolithic inheritance. You could implement "tear off interfaces" [7] that lazily create aggregated sub-objects on demand, useful for implementing callback interfaces.
MFC (Microsoft Foundation Classes) is a set of C++ wrappers around the lower level Win32 interfaces, plus a huge framework for implementing GUI widgets and dialogs on top of Win32, and for wrapping rube-goldbergesque OLE Automation interfaces around C++ classes. For some time MFC was the primary way of implementing COM interfaces in C++, but it was infamous for being horribly complex, with all its ugly macros, Hungarian notation, and bizarre programming conventions.
Later on Microsoft came out with the C++-only ActiveX Template Library (ATL) [8], which, although it was still necessarily quite ugly, was a more elegant and powerful way of implementing COM components in C++, didn't have the baggage of supporting C, and let you implement COM/OLE/ActiveX components without the hideous MFC framework. ATL was popular for implementing all kinds of Internet Explorer plug-ins.
OLE was actually a layer of COM interfaces and MIDL (Microsoft Interface Definition Language) on top of COM, which adds the IDispatch interface for dynamically querying and invoking methods and properties at runtime, and variant types [9]: tagged unions for representing polymorphic data (i.e. VB data types) and passing parameters to OLE IDispatch functions.
OLE was the glue necessary for integrating COM components into the Visual Basic runtime, so it directly supported Visual Basic data types, calling conventions and semantics like indexed properties.
OLE also provided an interface definition language (ILD) you could compile into binary type libraries, use to generate boilerplate C and C++ interfaces, and OLE also had COM interfaces and structures for providing those type libraries at runtime. It also had a lot of persistence, runtime reflection, and user-interface related stuff for plugging components and dialogs together in windows, providing property sheets, editing and configuring controls, etc.
MIDL supported defining components with "dual interfaces" [10]: both an OLE IDispatch interfaces taking variant type parameters, and also more efficient lower level COM interface taking primitive types. Runtimes like Visual Basic knew how to integrate dual interfaces and could bind to the more efficient underlying COM interfaces, instead of going through the slower generic dynamic IDispatch interfaces.
IDL also described the intricacies of DCOM [11] interfaces (for in-process and networked remote procedure calls), parameter marshalling [12], and all kinds of other bizarre stuff. DCOM is where COM went off the deep end.
At its core, COM was essentially a very simple and ingenious idea that elegantly solved some real world problems, but it eventually evolved into something extremely complex that attempted to solve many other unrelated problems, and which required a massive amount of tooling, and that depended on Microsoft's Visual Studio and Win32 environment.
Microsoft actually ported ActiveX to the Mac using ATL and Metrowerks Code Warrior, in order to implement Microsoft Internet Explorer for Mac [13] (which was actually the best web browser on the Mac at the time, by far). But not a lot of third parties (except for me and a few other crazy people) ever used ActiveX on the Mac.
However it did become quite fashionable for other organizations to create portable COM knock-offs to solve some (hopefully fewer) of the same problems, but which were incompatible with Microsoft's tooling and COM itself (which kind of missed the main points of COM, but hey).
For example, Macromedia came up with MOA (Macromedia Open Architecture) [13], their COM-like plug-in extension mechanism for Director and other products.
And Mozilla came up with XP/COM [14], for implementing components in Mozilla/Firefox/XULRunner/etc, enabling programmers to implement and consume XP/COM components in C++ or JavaScript. Of course it has its own IDL and tooling, and suffers from many of the same problems that COM did.
Mozilla didn't go nearly as far down the rabbit hole as Microsoft did, and later backtracked in their valiant "deCOMification" aka "deCOMtamination" and "outparamdelling" efforts [15].
At this point in history, I think it's best to skip the "component technology" middleman and integrate extensions directly into the JavaScript engine itself. Which brings us back to the sub-topic of VSCode!
Unironically, yes, this, Ifsuѧl Bacti1on|, and weird computer shape (extra-thick 3.5"-looking floppy and... what that slot is even supposed to be?) makes it look worse than it should. I get that the value is in other content, and this is just a basic illustration for the sake of having some picture (for aesthetics, I guess?). So it was made with minimum effort possible just to have something, that's cool, effort matters elsewhere.
But it doesn't only look sloppy or hastily made, it also looks inaccurate - and that really makes a bad impression. "Inaccurate" or "careless" are not the words any author should want their reader to think about.
A screenshot from an emulator, showing the same message but formatted as a BASIC program (just a bunch of PRINTs or REMs) - or something similarly simple to make, lacking glaring inauthenticity - would make a drastically better impression.
What's insufferably low effort banal human slop is your post, in stark contrast to the other posts written by actual human beings who cared enough to conscientiously put in the work to precisely and humorously criticize exactly what was lazy and careless and telling about that horrible illustration.
Next time you feel the urge to post "AI slop", why don't you take the trivial time and minuscule effort of actually copying and pasting the AI generated text and pictures into another LLM, and have it slop out a more interesting comment about HOW and WHY it's AI slop, instead of just posting your human slop that's not even good enough to be a prompt.
When you can't write anything more interesting than an LLM easily could, you have not earned the right to create a throw-away account just to complain "AI slop", and you should just sit on your hands (however many fingers they have) and not post anything.
Not the thumbnail. Not the pink text “A History of Visusl Basic”. Not the number one on the list of chapters. Not the chapter ousted at the very bottom.
The next button is for a different article.
How am I supposed to navigate to the thing the article is advertising to me? It’s a very strange decision not to make it really easy with a strong call to action or obvious link.
(I set this preference because motion while I'm trying to read makes me nauseated.)
[0] https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/A...
Then for a period of time I lost the physical CD it came with, and couldn’t install it anymore on a new system. Some time later I remember finding the CD at the bottom of some box of random stuff and being so happy - it was scratched up and didn’t reliably install, but I think I managed to burn a copy of it onto a new disk complete with inkjet printed sticky disk label that resembled the original disk.
Must had been mid/late 90s I think.
Had so much fun making stuff in VB back then.
(No, TwinBasic isn’t adequate. No, a VB.NET migration isn’t feasible.)
Already enterprise approved on the MS stack.
I know HN is all startups with macbooks on local admin, but in bigger companies even devs cannot just install whatever they want.
Windows did include other BASIC-related stuff, like GW-BASIC, QBasic, and VBScript.
https://gambaswiki.org/website/en/main.html
If you dont care about clean room then you plainly disassemble it and translate it. I live in the US where the second option might not be legal.
If you're going to use genai, you need to make sure it actually looks acceptable. Do at least one careful pass over it before publishing. Just look at the details:
- The text on the book spines doesn’t even spell “Microsoft” correctly.
- Dartmouth is spelled "Darmouth". SIGH.
- The screenshot on the CRT monitor doesn't remotely resemble any version of Visual Basic I’ve ever used and I’ve been using it since Visual Basic for DOS.
Using an image like this sets the tone and impression for the entire book going forward. Right now, that first impression isn’t good.
[1] - https://evilgeniuslabs.ca/uploads/content/2026/05/6fd5a7b327...
I sympathize with the motivations behind it, but it does look cruddy and cheapens the end result.
The computer screen I can forgive, but if they author genuinely doesn’t have access to modern image generation tools then they could have at least loaded that image up in GIMP, Paint.NET or even just MS Paint, and added the text themselves.
Took me 10 minutes to do this with an equal "budget" and the freeware graphics program Krita. Still has problematic issues (the curvature on that CRT looks like its suffering from bloody glaucoma), but it's vastly better than the original.
https://mordenstar.com/share/vb-history-book
https://en.wikipedia.org/wiki/Microsoft_Bob
The "Oomerd" button is probably the debugger by the sound of it?
Modern image generation models can handle text fine. Or the author could have left those artefacts blank and added the text themselves in “post production”
Plus the image isn’t even part of the article content. It’s ostensibly just a front cover to it.
I’m sure you’ve heard the saying “don’t judge a book by its cover” ;)
Because as someone who’s worked in publishing I can tell you I’m not in the wrong here.
It's a software-engineer-friendly tool for converting HTML to EPUB. It handles all the annoying little details. Binaries coming later today.
A book created with EPublish: https://www.amazon.com/dp/B0GYCZJVGX
https://www.youtube.com/watch?v=FqtwGuGRjJM
I remember saving up for it at high school with my student discount. From memory it was about $120.
VB for DOS really needed a version 2.0, but it never got it.
https://www.folklore.org/MacBasic.html
and how other competing products such as RealBasic (somewhere I have a book on it) factored in.
https://www.amazon.com/dp/B005KUH4GI
I recently read Jordan Mechner's The Making of Prince of Persia, and while it was interesting, it wasn't what I'd hoped for. It was a biography covering his life during the creation of the game, and very little about the internals and technology of it. That's fine, but for my tastes, the book that it really was, was less captivating than it could have been.
My default is to expect the same from the FoxTales book.
VB was practical and useful at the time, especially as a learning tool in school. I enjoyed testing the competitors that arose to emulate its abilities, including RapidQ Basic, Envelope Basic (a.k.a Phoenix Object Basic), some of which are documented here: https://en.wikipedia.org/wiki/BASIC
I think it would be cool to see a Documentary on programming languages, e.g. their history, rivalries, successes and downfalls, of the 80s, 90s and 2000s. If it is made correctly, with humor, it could be entertaining, perhaps even profitable.
GUI interfaces were going to be a massive productivity goldmine compared to green screens and TUI interfaces. Now here we are back to those again in various forms and web browsers won in the end anyway.
Was a wild ride in the 1990s when it was happening in earnest.
The tools lacked the visual GUI builder of VB, but really, that's just a detail. The rest of the framework was really quite powerful, and a GUI builder could have been added. But in true IBM fashion, they had no idea how to market something that wasn't mainframe targeted, and they killed the project. There was a fair amount of acrimony on internal forums about this at the time.
Otherwise, the other links point to the game, the movie and the cyberespionage malware attack.
https://news.ycombinator.com/item?id=19837817
>Wow, a blast from the past! 1996, what a year that was.
>Sun was freaking out about Microsoft, and announced Java Beans as their vaporware "alternative" to ActiveX. JavaScript had just come onto the scene, then Netscape announced they were going to reimplement Navigator in Java, so they dove into the deep end and came up with IFC, which designed by NeXTStep programmers. A bunch of the original Java team left Sun and formed Marima, and developed the Castanet network push distribution system, and the Bongo user interface editor (like HyperCard for Java, calling the Java compiler incrementally to support dynamic script editing).
https://news.ycombinator.com/item?id=44661955
>That's because Java used the old piece-of-shit NPAPI (Netscape Plugin Application Programming Interface) from 1995, first released in the NetScape 2.0b3 Plug-in SDK: [...]
>More about Netscape's fleeting obsession with Java and Javagator in the pre-LiveConnect/XPConnect/NPRuntime/ActiveX/DHTML/XPCOM/XUL days: [...]
https://news.ycombinator.com/item?id=27405137
>Yes, I think you've captured the difference: An "extension" is written in an extension language like JavaScript, in a browser that's intended to be extended in that language. A "plugin" is a more independent piece of code written in a compiled language, plugged into a host that doesn't necessarily have its own extension language like JavaScript or Visual Basic.
https://news.ycombinator.com/item?id=31042291
>It was funny when Sun proudly and unilaterally proclaimed that Sun put the "dot" into "dot com", leaving it wide open for Microsoft to slyly counter that oh yeah, well Microsoft put the "COM" into "dot com" -- i.e. ActiveX, IE, MSJVM, IIS, OLE, Visual Basic, Excel, Word, etc!
>And then IBM mocked "When they put the dot into dot-com, they forgot how they were going to connect the dots," after sassily rolling out Eclipse just to cast a dark shadow on Java. Badoom psssh!
https://news.ycombinator.com/item?id=20266627
>This article comparing SOM and COM was written by Don Box. (first archived in January 1999, but doesn't say when published):
>The Component Object Model and Some Other Model: A comparison of technologies revisited yet again: [...]
https://news.ycombinator.com/item?id=12975257
Glad you asked! One of my favorite topics. ;) COM is essentially a formal way of using C++ vtables [1] from C and other languages, so you can create and consume components in any language, and call back and forth between them. It's a way of expressing a rational subset of how C++ classes work and format in memory, in a way that can be implemented in other languages.
It was the outcome of the C / C++ / Visual Basic language wars at Microsoft.
The original 16 bit version of Visual Basic version 1 through 3 had a plug-in extension mechanism called VBX -- Visual Basic Extensions [2].
They were extremely popular and became a victim of their own success, after a whole industry grew up around them, and people started using them for all kinds of things they weren't intended for, and wanted to use them from other languages and frameworks like Borland. Microsoft had to do something about that to mitigate the success disaster of VBX, so they invented COM.
At the time, Microsoft was transitioning from Win16 to Win32, so they came up with the 32 bit COM definition, also known as OCX's, or OLE Controls, which they later called ActiveX, because COM was so hard to search for, and they wanted to take the spotlight away from Java with a new buzzword.
So they brewed up a bunch of ugly C macrology that enabled C programmers (or Visual Studio wizards) to define COM interfaces in header and implementation files that just happened to lay out memory in the exact same way as vtables of C++ pure virtual classes.
While C++ programs would use other ugly macros to declare actual honest-for-god C++ classes to implement COM interfaces.
And Visual Basic programmers would ... do whatever it was that Visual Basic programmers did.
COM's IUnknown::QueryInterface [4] method is essentially like C++'s dynamic_cast [5]. But it also adds some object aggregation features [6] that let you compose multiple sub-objects together by aggregation instead of using monolithic inheritance. You could implement "tear off interfaces" [7] that lazily create aggregated sub-objects on demand, useful for implementing callback interfaces.
MFC (Microsoft Foundation Classes) is a set of C++ wrappers around the lower level Win32 interfaces, plus a huge framework for implementing GUI widgets and dialogs on top of Win32, and for wrapping rube-goldbergesque OLE Automation interfaces around C++ classes. For some time MFC was the primary way of implementing COM interfaces in C++, but it was infamous for being horribly complex, with all its ugly macros, Hungarian notation, and bizarre programming conventions.
Later on Microsoft came out with the C++-only ActiveX Template Library (ATL) [8], which, although it was still necessarily quite ugly, was a more elegant and powerful way of implementing COM components in C++, didn't have the baggage of supporting C, and let you implement COM/OLE/ActiveX components without the hideous MFC framework. ATL was popular for implementing all kinds of Internet Explorer plug-ins.
OLE was actually a layer of COM interfaces and MIDL (Microsoft Interface Definition Language) on top of COM, which adds the IDispatch interface for dynamically querying and invoking methods and properties at runtime, and variant types [9]: tagged unions for representing polymorphic data (i.e. VB data types) and passing parameters to OLE IDispatch functions.
OLE was the glue necessary for integrating COM components into the Visual Basic runtime, so it directly supported Visual Basic data types, calling conventions and semantics like indexed properties.
OLE also provided an interface definition language (ILD) you could compile into binary type libraries, use to generate boilerplate C and C++ interfaces, and OLE also had COM interfaces and structures for providing those type libraries at runtime. It also had a lot of persistence, runtime reflection, and user-interface related stuff for plugging components and dialogs together in windows, providing property sheets, editing and configuring controls, etc.
MIDL supported defining components with "dual interfaces" [10]: both an OLE IDispatch interfaces taking variant type parameters, and also more efficient lower level COM interface taking primitive types. Runtimes like Visual Basic knew how to integrate dual interfaces and could bind to the more efficient underlying COM interfaces, instead of going through the slower generic dynamic IDispatch interfaces.
IDL also described the intricacies of DCOM [11] interfaces (for in-process and networked remote procedure calls), parameter marshalling [12], and all kinds of other bizarre stuff. DCOM is where COM went off the deep end.
At its core, COM was essentially a very simple and ingenious idea that elegantly solved some real world problems, but it eventually evolved into something extremely complex that attempted to solve many other unrelated problems, and which required a massive amount of tooling, and that depended on Microsoft's Visual Studio and Win32 environment.
Microsoft actually ported ActiveX to the Mac using ATL and Metrowerks Code Warrior, in order to implement Microsoft Internet Explorer for Mac [13] (which was actually the best web browser on the Mac at the time, by far). But not a lot of third parties (except for me and a few other crazy people) ever used ActiveX on the Mac.
However it did become quite fashionable for other organizations to create portable COM knock-offs to solve some (hopefully fewer) of the same problems, but which were incompatible with Microsoft's tooling and COM itself (which kind of missed the main points of COM, but hey).
For example, Macromedia came up with MOA (Macromedia Open Architecture) [13], their COM-like plug-in extension mechanism for Director and other products.
And Mozilla came up with XP/COM [14], for implementing components in Mozilla/Firefox/XULRunner/etc, enabling programmers to implement and consume XP/COM components in C++ or JavaScript. Of course it has its own IDL and tooling, and suffers from many of the same problems that COM did.
Mozilla didn't go nearly as far down the rabbit hole as Microsoft did, and later backtracked in their valiant "deCOMification" aka "deCOMtamination" and "outparamdelling" efforts [15].
At this point in history, I think it's best to skip the "component technology" middleman and integrate extensions directly into the JavaScript engine itself. Which brings us back to the sub-topic of VSCode!
[1] Virtual Method Table: https://en.wikipedia.org/wiki/Virtual_method_table
[2] VBX: https://en.wikipedia.org/wiki/Visual_Basic_Extension
[3] Variant Type: https://en.wikipedia.org/wiki/Variant_type
[4] IUnknown::QueryInterface: https://msdn.microsoft.com/en-us/library/windows/desktop/ms6...
[5] dynamic_cast: https://msdn.microsoft.com/en-us/library/windows/desktop/ff4...
[6] Aggregation: https://msdn.microsoft.com/en-us/library/windows/desktop/ms6...
[7] Tear Off Interface: http://www.codeguru.com/cpp/com-tech/atl/performance/article...
[8] ActiveX Template Library: http://www.drdobbs.com/windows/the-activex-template-library/...
[9] Variant Types: https://en.wikipedia.org/wiki/Variant_type
[11] Distributed COM: https://en.wikipedia.org/wiki/Distributed_Component_Object_M...
[12] Marshalling: https://en.wikipedia.org/wiki/Marshalling_(computer_science)
[13] Macromedia Open Architecture (MOA): https://www.adobe.com/support/xtras/info/moa.html
[14] XP/COM: https://developer.mozilla.org/en-US/docs/Mozilla/Tech/XPCOM
[15] deCOMtamination: https://wiki.mozilla.org/Gecko:DeCOMtamination http://taras.glek.net/blog/categories/decomtamination/ https://blog.mozilla.org/tglek/category/decomtamination/
But it doesn't only look sloppy or hastily made, it also looks inaccurate - and that really makes a bad impression. "Inaccurate" or "careless" are not the words any author should want their reader to think about.
A screenshot from an emulator, showing the same message but formatted as a BASIC program (just a bunch of PRINTs or REMs) - or something similarly simple to make, lacking glaring inauthenticity - would make a drastically better impression.
Next time you feel the urge to post "AI slop", why don't you take the trivial time and minuscule effort of actually copying and pasting the AI generated text and pictures into another LLM, and have it slop out a more interesting comment about HOW and WHY it's AI slop, instead of just posting your human slop that's not even good enough to be a prompt.
When you can't write anything more interesting than an LLM easily could, you have not earned the right to create a throw-away account just to complain "AI slop", and you should just sit on your hands (however many fingers they have) and not post anything.