I'm writing a history of Visual Basic, Chapter 1 is up
evilgeniuslabs.ca
evilgeniuslabs.ca
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.
Any site that needs an immediate pop-up telling me how to disable effects is tacitly admitting they have a bad design. Especially by needing multiple font choices.
(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.
Also batch. aaah, I love cmd.
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.
https://github.com/dotnet/roslyn
Now I bet what you mean is the graphical part, and yes that is only partial open source.
https://learn.microsoft.com/en-us/previous-versions/visualst...
One of the .NET design ideas was exactly to have a common runtime between VB6+, J++ and C++, using COM, but the lawsuit from Sun made them pivot to something else.
https://web.archive.org/web/20190111203733/https://blogs.msd...
This idea came back as WinRT, which they completly messed up, and for me it was how .NET 1.0 should have been in first place.
https://arstechnica.com/features/2012/10/windows-8-and-winrt...
Unfortunely that ship has sailed, given how bad UWP landed.
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.
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” ;)
I get there’s a lot of hysteria around Gen ai but as someone who’s worked in publishing I can tell you I’m not in the wrong here.
GenAI models are made by professionals. But in both our cases, it’s a different set of professionals to the ones who chose which images to use in their articles.
> memes impart some social context
The “social context” here is just regurgitating an unrelated viral joke. I’d hardly say that requires more respect of the readers than a purpose generated image that is intended specifically for context of that article.
Plus you can use GenAI to generate a meme too if you really wanted.
> Can't say either about an AI image
I literally just did ;)
> So i absolutely hold an AI image in less esteem, especially when someone clearly just used the first draft spit out by the model where all of the text is wrong and the image doesn't even resemble what it purports to illustrate.
And this is exactly why I said “The problem isn’t the use of AI. It’s the lack of editorial effort to use AI well.”
What you’re complaining about isn’t how the image came to be, it’s the shoddy workmanship. And that’s a different problem.
Lazy people will choose images lazily regardless of the tech. The problem here isn’t the use of AI, it’s the lack of editorial care.
Or to put it another way, if the author used a bad stock photo or offensive meme, then we wouldnt be blaming the tech. But when they use GenAI to produce the same shoddy output we do blame the tech. That screams like our own biases affecting who we blame the for crappy image rather than an inherent problem with the technology.
And if we then acknowledge that the problem isn’t inherent in the tech, then we are back to agreeing with my original point.
Surely that depends on how bad the stock photo is? I’ve seen plenty of people comment on bad stock photos in the past. And plenty more moan about the use of memes in articles.
> and if it were an offensive meme it would have been chosen with intent.
…which is better why? It’s still offensive. Except now you saying the author being a dick is better than an author failing to use a decent image generation model?
Personally I’d rather scroll past a crappy image than an offensive one.
> A bad AI image is so bad to be worth noticing and serves no other purpose than to fill up space hoping nobody notices how bad it is
Exactly. Bad images. BAD!!
You’re comparing good stock photos with bad AI images and arguing that AI is the problem. And thus we are right back to my original point where I said it’s the editorial process that failed by allowing a bad image, regardless of the source.
> Doctors and mechanics are both professionals so you'll get Dialysis from a Jiffy Lube?)
Doctors don’t build dialysis machines so your analogy is wrong.
Your whole argument here ignores the fact that gen ai has been used in reporting for a while now; and used well.
This image in this specific article is crappy. But it’s also not representative of all AI images in all articles. Its crappiness is an outlier rather than an example that proves your argument about the ethics of AI generated images.
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.
The "Oomerd" button is probably the debugger by the sound of it?
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.
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.
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.
It's also worth mentioning Sharpdevelop.net which also gave you the choice of VB.Net or C# and another language, can't recall what it was.
There were so many options available. So many books were written, sold and then became obsolete. I know because I bought tons of them at the now defunct Fry's Electronics and later donated them to the local public library.
But with AI advancing, focusing on programming and earning a CS degree as a future investment does not hold the same appeal that it once did. Of course, this is just my opinion.
Sol Roth: The Downvoted Man :)
(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...
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.
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
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.
It's $4, the reviews are good, just buy it.
> It's $4, the reviews are good, just buy it.
Yeah, $4 isn't relevant. What is relevant is the time investment, which your response ignores.
My suspicion is, however, that BASIC became the 8-bit lingua franca not only because of Gates, Allen & Davidoff's work on the Altair but because of Wang and Pittman's work on Tiny BASIC. The TRS-80 initially shipped with a modified version of Wang's Tiny BASIC. The Apple ][ shipped initially with a Tiny BASIC like interpreter (Integer BASIC) written by Steve Wozniak.
By 1980, all the popular micros had licensed BASIC from MSFT and it's important to understand why. But before understanding why homegrown Tandy, TI, Atari and Apple BASICs fizzled, you have to know they existed first.
#OldManYellsAtClouds
Citation needed. Wikipedia doesn’t mention this influence, for example (https://en.wikipedia.org/wiki/Integer_BASIC), and Woz didn’t mention it as an influence in 2014 (https://gizmodo.com/how-steve-wozniak-wrote-basic-for-the-or...).
> ascribed to Woz.
I think it’s accepted that Woz wrote that basic interpreter. “Ascribed” makes it look as if there is some doubt about that.
Modified the text to be clearer.
As for your interpretation of the word "ascribed," I can't help you there. I could go "attributed" or "alleged," but neither really helps. "Credited" is probably better, but it sounds like you're reacting with incredulity to the idea there are people who don't know Woz wrote Game BASIC. The use of "ascribed" here is to point out there were people other than Gates/Allen/Davidoff who wrote BASIC interpreters in the 70s.
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.
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/
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.
We were being a well-behaved MS shop at this point. The new generation of our website was designed with a distributed component architecture being called from ASP (Active Server Pages) using DCOM. We implemented it in C++ using ATL (iirc) to facilitate the COM interfaces. The thing was, even with that help, our actual business logic was absolutely overwhelmed by all the annoying casting back-and-forth between those IUnknown values and C++ native types. It was really annoying.
This was around the timeframe of VB 5, I think, and we discovered that we could write the same logic in VB without all the annoyance. Putting aside our "serious developer" C++ elitism, we were actually productive in doing it all in VB instead of C++, and that generation of the system lasted for a bunch of years. We eventually replaced that with an ASP.Net design in C#, which was a whole lot more manageable.
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.