Why I am called "the Father of Visual Basic" (1996) | Hacker News Reader

Why I am called "the Father of Visual Basic" (1996)

cooper.com

116 pointsadamnemecek80 comments

Kids today probably don't realize, but for its purpose, VB pre dot net 2001 was really really good. Especially compared to the c plus plus alternative available at the time, atl, and so forth. I know the criticisms of basic as a language, technical snobbery, etc.. But for building stuff quickly, it worked. And for an ide, was really snappy and fast. That deteriorated when the VM was introduced, dot net.

You start a project, a form appears. You drop controls on it. You set their properties. You code their event procedures. Press the play button. Compile. Exe. Done. It was a great product in that it abstracted the messy stuff well, and presented a programming environment that was intuitive and powerful.

Not only that. Compilation was super fast, the debugger was pretty damn good, creating OLE objects was a breeze (every class had the full machinery to become an OLE object just by flipping a flag in the properties editor), writing networking code was super simple (VB's built in events would take care of the asynchronous nature of receiving data), installation builder... I could go on. It was light years ahead of the closest competitors (Visual C++ and Delphi.) People love to hate Visual Basic, but for its time it was revolutionary.

I agree with most of what you've said, except for it being light years ahead of Delphi. I used both tools extensively in both a hobbyist and professional capacity from 1997 onward (VB 5, Delphi 3) and I couldn't say that one tool was significantly ahead of the other. They were both hugely similar and fantastic for rapid development. In fact I'd go so far as to say I preferred Delphi as its database capabilities were better (at least, in my experience) and I liked not having to package my software with a set of run-times. Although the latter was more important to the hobbyist side of me. Commercially, demanding a client had the required VB run-time files was no problem.

Delphi was a great tool! The database support was way ahead of VB, specially support of MySQL and other third party databases. I guess I always preferred C/C++ over Pascal for low-level stuff though, so even though I played around with it for quite a bit, I never became too proficient.

I hoped C++ Builder would close that gap with Delphi, but then .NET took over and the rest is (kind of) history.

What's fascinating to me is that some countries (Brazil, for one) still have a very active Delphi community, while in a lot of places it was more or less forgotten.

That's right, Brazil, Russia and China still have huge amounts of Delphi developers. To a lesser extent so do South Africa and Australia.

Would you believe me if I told you I currently work in a software house whose main suite of desktop products is still in Delphi? We've been using .NET since the mid-2000s (before I started here) for a few of our products, and all new development for desktop products in the past few years has been .NET, but the company's bread and butter and highly successful products are Delphi applications through and through.

It's still a capable development tool but the language is showing its age. I very rarely have to touch it any more but when I do I always get mixed emotions of "argh, Delphi sucks ass, I wish it had <insert any .NET language feature here>", and "oh man I forgot how awesome Delphi was, I wish it was this straightforward in .NET!" Comments such as the latter are few and far between, these days.

That's not surprising! Some really good enterprise and POS software got developed in Delphi (and other desktop frameworks/IDEs) back in the day. In Brazil a lot of businesses were starting to adopt POS, and having someone building a billing program for you was all the rage. There's little incentive to update such systems as long as they work. Not everything needs to be a website! (shakes walking stick and shouts to kids to get off his lawn)

I remember hating .NET in the beginning. Performance was abysmal and anything mildly low-level took a lot of work. I made some good money as a freelancer writing COM libraries or C++ libraries with a thin C# wrapper so that they could be used by companies that had bought into the whole .NET thing.

Then C# introduced generics, and it started breaking away from the similarities to Java. Things improved and in time .NET became a very capable runtime/framework. I'm actually excited to see Microsoft finally opening it up. As much as I love Python, the cloud and all the fancy new stuff we have nowadays, I occasionally long for the good old days when desktop software reigned supreme.

OK, better go to sleep now. I'm starting to sound like an old fogy :)

My day job is at a software shop that still has ~90% (millions of LOC) of its application suite in VB6!

Interesting bit aside: The current Delphi versions are becoming better again, to the point of actually being usable. Now it's just that its reputation was ruined when Borland decided to f*ck it up. I'm using it at work to build an Android app, and despite the slow buggy IDE, I'm more productive with it than with IntelliJ (for Android dev) or Visual Studio (for Windows apps)...

That is an impressive statement. Can you share some link about Delphi new Android capabilities, I was not aware it could handle mobile. I think I am stuck in the 90s Delphi.

Well, great info on the Embarcadero's website about Delphi + Android: https://www.embarcadero.com/products/delphi/android-app-deve...

And here are examples of using it (with source): https://www.embarcadero.com/products/rad-studio/android-ios-...

thanks!

Turbo Pascal and later Delphi were great!

If Borland hadn't mismanaged everything the way they did in the mid-90's, maybe C and C++ wouldn't have the spotlight they enjoy nowadays.

I don't think Borland's mismanagement was a strong factor in C/C++ gaining mindshare.

The native OS interfaces on popular platforms (Win32, Posix) were in C, so it would have always been a 2nd class citizen.

I believe that Delphi was already on a decline when Borland decided to self destruct.

On Win32, they had a tough time competing after VisualBasic v5.0, where Microsoft had a larger mind-share.

On Linux, I had hopes with the Kylix port, but it was abandoned by Borland.

https://en.wikipedia.org/wiki/Kylix_(software)

On Windows, Borland was always late with SDK support so we were forced to write our own wrappers. I gave up by Delphi 1.0, after being mainly focused on Turbo Pascal since the 5.5 version.

Regarding Kylix, I would say it was badly managed from the start.

So yeah, eventually the way out for better Windows support was C++/MFC, as even Borland's C++ compilers had their own set of issues.

But, this is a big but, if Borland managed to push Delphi the same way Sun pushed Java, then I think the mindshare story would be quite different.

A memory safe programming language, with RAD tooling support, capable of system programming tasks with native executables.

VB 6.0 was what got me into coding when I was thirteen. I am infinitely grateful to it. So many memories working with WinSockets, OCX, and pressing that play button.

On Error Resume Next anyone?

I remember having very heated debates about using Option Explicit and the use of Variant in assorted AIM programming chat rooms.

Fun times.

VB (and developers like me) always took a fair amount of heat for a "toy" development tool. Likewise HyperCard, which I used before VB. Yet the productivity achievable with those tools, for the right kind of project of course, was game changing for those of us who otherwise found UI development to be either onerous or forbidding.

I had simply assumed that VB was Microsoft's attempt to one-up HyperCard, and it's very interesting to learn about VB's real origins.

I developed industrial process controllers using VB. A stripped down Win3 or Win95 system running VB was actually virtually crash proof. Of course this didn't prevent me from incorporating redundancy into the hardware, to take the machine into a safe state if the PC stopped working for any reason.

What the dot net version seemed to do, was to make VB the equal of the other Microsoft languages, feature by feature. The result was that they lost the reason why VB developers loved VB. I continued using version 6 (pre dot net) for several more years after that.

I agree with you, but there are some interesting gotcha's in this. Windows 3 accumulated cruft and needed to be cleaned or rebooted regularly. The company I worked for in the late 90's had a public safety customer that ran our code on a Windows 3.0 box, I can't remember the time interval, but periodically one of our developers would go on site and (in NuMega SoftIce - which we habitually ran everywhere) would reset the windows tick counter, and flush crap out of various OS handles tables.

Having done low-level messing about on 16-bit windows, when I moved to Redmond and started working for MS it was hard to drive past BurgerMaster without buying something in homage.

That's a good point, and I may have done inadvertent cruft cleaning just by updating my program periodically, since it was so easy to just reboot the system.

VB did a lot of things right:

* interfaces

* delegation instead of inheritance

* binary contracts (sometimes attributed to dependency hell)

It was shunned back then because of C++ and MFC/ATL. My favorite VB books were by Dan Appleman. I started to dislike VB after VB5 though.

VB.NET is all of that except even easier to work with and more sensible, plus interop with any other .NET language. VS for VB.NET is not slow at all. I used VB.NET throughout a high school class and recently had to modify some VB.NET I found in an open source project to adapt it to my project. It was a very smooth procedure even after not having used the language in years. But with having C# now, I don't think there's much reason to write VB.NET instead of it unless you're working on existing VB.NET code, even though it does have a few nicer spots like the convenient Sub ... Handles myEvent where in C# there has to be an explicit += somewhere, and a few other small things; however, overall C# is more powerful.

C# is not really more powerful. Functionally, there aren't really anything you can do in one you can't in the other.

I personally got used to the convenience of a case insensitive language and I usually write throw away scripts/analysis more than systems, where having a language you can type fast with few bugs is important. For that purpose VB.net is fantastic.

No, no, no! I work in both on a daily basis, and have done since 2006/2007. Around 2006 I started migrating Delphi code to .Net for an employer (they had a lot of VB.Net already through acquisitions). Then circa 2007, I started at a company that used a VB.Net 1.1 codebase, upgraded it through to 4.0 adding in a lot of C# assemblies and extensions along the way - culminating with a complete refactor of all key components in to C#.) Now I work with a codebase that is mainly VB.Net but all new code is in C#.

VB.Net is a horrible language that lets developers get away with some really awful practices. The fact that the various Options are still present, and not on by default, is a recipe for disaster. That this is legal:

Sub Main dim x as boolean = false ''or true... dim y as integer = 0

select case y case x Console.Write("What does this even equate to???") end select End Sub

end case

or that this is legal:

    Class SomeArgs
        Inherits EventArgs
		
		public Property Message as String
    End Class

    Class HorribleCode
        Public Event Blah(ByVal sender As Object, ByVal e As Someargs)

        Public Sub Doit()
            RaiseEvent Blah(Me, new SomeArgs with { .Message = "Wow... YUCK!!!!"})
        End Sub
    End Class

    Public WithEvents ThisSucks As HorribleCode

    Public Sub ThisReallyWorks(ByVal sender As Object, ByVal e As Someargs) Handles ThisSucks.Blah
        System.Console.WriteLine(e.Message)
    End Sub


    Sub Main()
        Dim h As New HorribleCode

        ThisSucks = h

        ThisSucks.Doit()

    End Sub

Yes, I dealt with code that had both of those "techniques" in it... ugh.

The second example was mainly because the off shore coders didn't realise AddHandler/RemoveHandler existed... le sigh

Not sure I follow your point. You can write really bad C#. And you can write even worse c++. The quality of a language isn't about how bad you can twist it if you decide to be reckless.

In fact I must say one of the things that I appreciate the most about VB, beside case insensitivity is the IDE. I think c# is catching up now but the VB IDE is incredible in term of how much help you get, immediate feedback on what went wrong, rich auto-completion of code.

The code completion is just as good or better for c# from my experience

That's not how I saw VB's reputation at that time period.

It definitely depended on whom you talked to. Folks in the "business" world generally respected the productivity of VB, as it was used for a lot of the little custom apps that people depended on.

But there were also a lot of developers who thought that VB programmers were the script kiddies of the day.

Most business folk loved it, because thats what they used.

I got my start into programming with VB6 (or maybe it was 5). After reading through a Windows programming book for C++, which I understood nothing from, I almost gave up. Until my father got me a wonderful tutorial Visual Basic 5/6 for Kids (http://www.kidwaresoftware.com/vbkids.htm).

First day in, I had a form with a button. Clicking the button would change the form background colour to blue. I had to restart the app to get the form background back to the default one so I could demo it again, but I still remember how excited I got over that one simple thing. I would show it to everyone in my family.

If it hadn't been for that, I'm not sure I'd be a programmer today. Just an amazing product for it's time.

I loved VB6. Programming games in it using DirectX, in my cracked copy of VB6 when I was 13 was one of the first forays into real programming. I still remember being super confused about double-buffering way back when; my initial game programming in VB started with picking up key events and moving an image around, but it was blurry and laggy, afterimages galore and impossibly to composite correctly. That's when I found DirectX. Not long after I moved into working with web technologies, and the rest is (my) history.

Take a computer user who hasn't written a single line of code ever. Fire up VB6-, drop a button, double click, write MessageBox "Hello Word" and press the play button. I have often got looks with amazement "Wow! Is creating applications that easy? I can do that!". I know of no other development tool or languages that demands same response from complete non-programmers. The minute people see angle/curly/curvy brackets, there is just too much explaining to do that would eventually end up in talking about how stack works.

Many of us thrive on complexities and are wired to handle large hierarchies of concepts that is required to make sense of things, but large majority apparently wants things to be simple and VB of an excellent way for them to experience the joy of programming. Professionally VB6- was however too limiting and its purpose seemed to be mostly churning out CRUD data entry screens faster than ever. So it's best used as introduction/launchpad in to programming with clear plan to weaning off after you had enough fun.

Professionally it wasn't even that limiting. It handled COM calls OK so you could off load to other libraries if you wanted. I was still developing professionally in VB6 as recently as this time last year (exactly 1 year ago in fact).

While I am extremely glad I got away from VB6, the old dog still had life in her. The main limitation was having to develop in a windows XP virtual machine for better IDE compatability.

By the end we did much of the newer development was in .NET libraries we called from the VB6 front-end, but the front end was still handling most of the data.

Borland Delphi was capable of the same feat.

(and the resulting executable is smaller and WAY FASTER then VB).

I've gotten the same reactions by showing alert boxes and changing background / font colors using JavaScript.

I agree! That was actually my first introduction to programming - copying snippets of JS that popped alert boxes to impress my friends in elementary school.

More recently, I've explained the whole idea of web programming to non-developers by showing them the developer tools/JavaScript console in the browser, and how you can use it to edit CSS styles and run random bits of JS that do cool things to the current page. It cool to see people "get it" -- the reaction is generally something like "wow...is that it??"

> Professionally VB6- was however too limiting and its purpose seemed to be mostly churning out CRUD data entry screens faster than ever

I beg to differ. I worked on a lot of VB5/6 code between 1997 and 2002, during that time we did some fairly sophisticated things.

At one banking/finance gig I wrote a large amount of code that ran inside Microsoft Transaction Server and COM+, support for this was rather impressive. At another gig I wrote front ends for a document scanning server written in Java - we had a COM/CORBA bridge etc. We did image scanning and manipulation in VB 6 without a lot of fuss.

There was also a rich and diverse market for third party controls, widgets and libraries. Hell, if you knew what you were doing you could hook directly into the windows message pump, subclass and create your own windows.

Take a look at Matt Curland's "Advanced Visual Basic 6" which was published in 2000, VB6 was no toy:

http://powervb.com/

This is so true. I was blown away by VB6, especially after working with Visual C++ (and MFC).

Shortly after I got into VB6 I was turned onto Delphi 7...and never looked back. For me, Delphi is a superior alternative to VB6 and Visual C++...and I say that as someone that really learned a lot from, and enjoyed using VB6

I still use Delphi to this day and am using a modern release of Delphi (XE7, the latest version). They've added a 64-bit compiler and support creating native OSX, iOS, and even Android applications now too.

If you value high performance, easy to develop GUI's, small EXE's with no dependencies, native generics, and awesome DB support, I highly recommend using Delphi.

However, to each their own. I know Delphi is not as popular these days, but it really offers programmers huge productivity gains.

If you prefer an open-source alternative to Delphi, have a look at the Lazarus IDE which uses FreePascal.

The Lazarus IDE is very reminiscent of Delphi 7 and runs on Linux, OSX, and Windows. You can also create native GUI's on all of those platforms as well: http://www.lazarus-ide.org/

We were all a lot younger when that photo was taken 25 years ago! :-)

Happy to answer any questions about the early days of VB. Gary and Frank and Mark and I built most of the "visual" side of VB based on Alan's Tripod prototype. It was called Ruby at the time (no relation to the programming language) and was originally going to be a programmable shell for Windows 3.0 but turned into VB instead.

If you want something specific to blame me for, that would be the VBX interface...

Here's an article with more of the story of how Microsoft turned Ruby into VB:

http://www.forestmoon.com/birthofvb/birthofvb.html

Hi! I'll bite. Two questions for you.

VB and Hypercard get a lot of nostalgic love these days, and a lot of people (including ITT) maintain there aren't any real successors to them.

What would you consider to be the standout merits to Ruby/VB that ought to be reproduced now?

Second question, since plugins and dynamic extension are never out of style: in the VBX interface, what did you think worked well, and what did you think was a tremendous disaster?

Thanks!

Ah, if you're looking for insights, I may not have too many of those. It was a long time ago! But let me see what I can remember.

The big thing about VB is the obvious one: it was really easy to get started using it, and despite the flaws in the visual environment and the language itself, it was good enough to get things done.

In fact, Basic was a lot better than the language we were originally going to put in, which was barely more than a glorified batch language (and not even as powerful as .bat).

The idea we had at the beginning was that you'd drag an arrow on the screen from one component to another, signifying that an event triggered on the first component would make an action happen on the other. This is where the phrase "fire an event" came from: I was looking for a verb for this, and "trigger" didn't sound right. I was frustrated and had a bunch of rubber bands on the table, so I started firing them at the screen. That didn't help. So I fired up a doobie, and between flicking the lighter and firing the rubber bands, "fire an event" seemed like the phrase to use.

What worked well in VBX? Well again it was fairly simple to use and easy for people to make extensions with. The big disaster was that it was pretty much tied into the Win16 programming model, so when Windows moved to 32 bits, VBX wasn't going to cut it and Microsoft developed OCX to replace it.

So I fired up a doobie, and between flicking the lighter and firing the rubber bands, "fire an event" seemed like the phrase to use.

There's something strangely surreal and downright awesome about reading this comment from you, over 25 years later. Huge amounts of respect for what you and the team achieved.

Thank you! We always tried to have fun with the names.

Alas, my other favorite name didn't make it into the final product. VB Controls were called Gizmos in Ruby, and VBX was the Gizmo Interface.

I don't know what happened there - I think Gizmo was just not a serious enough name for the Microsoft of the day. But really, Control instead of Gizmo? Boring!

There is a successor for HyperCard these days. It has a similar language, it can import HyperCard stacks, it is crossplatform (windows, mac, linux, android and iOS) and it is open source. Its called LiveCode and is available at http://livecode.com

StackOverflow's VBX tag only has three questions. I guess that means it must be near to perfect...

Indeed! After all, who has any problems with VBX these days?

As I understand it, VB 1.0 was effectively QB 8.0, as the last shipment of QB was the QB PDS 7.1. How much did the VB 1.0 codebase borrow from the existing QB implementations? Were they entirely independent projects?

I'm afraid I have no idea on that, sorry! Our team was just involved in VB before it became VB: we did the visual forms editor, VBX interface, and stuff like that. Microsoft then took it in-house and added Basic to it and updated a lot of other things. This article tells about that and may have some insights about the Basic code used:

http://www.forestmoon.com/birthofvb/birthofvb.html

Back in the mid 90s, in my early- mid twenties, I built a software business on vb. Clients included financial services, government, and others. I even had a customer who connected my cv software to custom hardware. It was such a good product (I'm talking about vb). There definitely was snobbery compared to vc++, especially around the fact that it compiled into pcode. And the fact that I couldn't do my own dll's / ocx/ vbx. But the versatility and utility was amazing and I was able to create a nice bit of side income. If was my second business but my first software eating the world one. Wanted to use this opportunity to say thanks to you guys for such an awesome product!

Well thank you. It has to be one of the most gratifying things for a software developer to hear when people have used your code and built great things with it!

I just want to say thank you. VB was my first introduction to programming. I was in fourth grade and I asked my parents for VB6, and they thoughtfully also bought me "Visual Basic for Dummies." I was quickly hooked - I especially remember writing side scroller games with it and making the image sprites with Photoshop in my school's computer lab. I don't think I've written a line of VB since middle school, but I will always have fond memories of it.

I also want to thank you. VB was the first language I learnt back in school days here in Pakistan. I later used it for almost a decade to make personal projects and some freelance before I finally went for CS degree and was taught more complicated concepts of CS.

I did my final year project at Uni in VB 1.0. I think my years on a Dragon 32 (TRS-80) gave me an advantage as it was all MS Basic.

Any plans to bring VB back? i.e. something as simple as the original was?

- A programming language with rudimentary OO

- A complete IDE

- A relational database with multi-user access and transactions

- A visual form editor

- Drag-and-droppable Components

- A debugger that lets you mutate code and even the instruction pointer, while running.

- A compiler that generates distributable EXEs in a single click

- All of this inside 2mb.

vb3.exe, released in 1993, 22 whole years ago. We're still playing catch up.

Also:

- asynchronous/event-based programming

- importing C/native code from a DLL is trivial

- fantastic documentation (so good you don't need the Internet)

If you want a button that does something, you literally draw the button on your form, double click it, and write the code for that event. I agree - one day we'll catch up.

Also VB6 autocomplete rocked.

Depends on where you are. We on the the native side don't need to catch up.

Quite true. I'm coming from the web world, and we have a lot of accidental complexity.

However some of it is inevitable, owing to what it lets you do: run the same site across platforms and devices, built from the ground-up to enable communication and collaboration, seamless updates, infrastructure support for caching etc.

And all of this existed in 1988 with NeXT Project Builder/Interface Builder. Which was used to write the first web browser.

Yes. When Visual Basic first came out, I assumed it was very much inspired by Interface Builder on the NeXT. Kind of weird to not even see it mentioned.

Sure, but you needed several thousand dollars ($10k?) own a NeXT box or by a stroke of luck your college or university might have such a machine.

I'm sure there are many other great things that existed to do the same thing but VB was the tool that brought this type of capability to the masses on plain old PC hardware.

I've got icons bigger than 2mb these days...

vb3 and then 4 were, for me, sort of the real 'sweet spot' for productivity stuff back in those days. By the time vb5 came about, it started to get rather complicated from a UI standpoint, and VB6 even moreso to the point where I found myself getting lost a lot (had somewhat moved on in to web work at that point too, so I wasn't doing VB projects every day then).

If you want to make the 'next big thing' then make a VB like environment for the web. It's going to make you rich, famous and hated in pretty much equal measures.

See Stamplay: https://stamplay.com/ which is taking steps toward this.

There are about a zillion drag & drop web designer tools out there, all with varying angles and subtly different markets. The ones I know of are:

https://divshot.com/features

http://www.appgyver.com/composer

https://polymer-designer.appspot.com/

http://www.weebly.com/

https://webflow.com/

http://froont.com/

http://www.google.com/webdesigner/

http://sparkle.cx/

There's also a bunch of desktop software that does this too - remember FrontPage and DreamWeaver?

I thought about getting into this market but it is so crowded that it's unlikely there'll be one clear winner. Instead, every designer seems to have their favorite tool.

All of the products you listed just help with design. None of them let you add functionality using drag and drop.

They do, actually - all of the Polymer-based ones (the first three) let you drop full web components onto the page and wire up bindings. It very much is analogous to Visual Basic + COM.

Fair enough.

And PHP is the logical choice for the role of QuickBASIC in this analogy.

Why?

Adding an XHP-based form design environment to PHP would produce the same increase in value that the form design environment of VB produced over QB. Both PHP and BASIC are seen as having low barriers to entry, and are/were already widely used in their respective problem domains. It just seems like a natural choice to me.

I'm not sure there's the potential for that kind of gateway any more. One of the big advantages of VB was just showing up. It was more available...in a box on a shelf at the office supply store...than many alternatives. The retail channel could be dominated in a way that Github can't.

To be clear, Microsoft's domination of retail was due to its distribution efforts not some evil plan...Borland was plenty around too in those days.

There's an interesting interview with Alan Cooper about the subject up on Channel 9 (and a lot of other stuff, Alan pulls no punches :).

I did find it odd that "Ruby" (what became VB) was suppose to be the "shell for windows " and allow user to "design their os". Maybe I misunderstood that part because it sounds like a recipe for disaster :)

http://channel9.msdn.com/Series/VisualStudioDocumentary/The-...

I give great kudos to Alan Cooper, his book "The Inmates are running the asylum" was a paradigm shift for me. Once you've read it you have a little Alan inside your head for the rest of your life, telling you how stupid, impolite and lazy most software is. It's annoying but highly effective.

Really recommend it for anyone who hasn't read it. He's a bit rabid in his aversion to developers designing, but if you can look past that it contains many gems

I've been working with somebody else's .NET web application recently, written entirely in VB.NET. It works just fine and VB hardly seems like a toy. An interesting quirk I discovered, however, was that, with a VB.NET application, you can add individual classes as namespaces in web.config

This basically allows you to import classes from App_Code globally--something which my predecessor on the project had made significant use of. And it all worked, despite the fact that it's not technically "allowed" and C# naturally prevents you from doing it. I only noticed something was amiss when I tried creating a simple Web Service and the app kept falling over.

I came across Visual Basic when Access 1.0 hit Office Depot for $99. Of course in the preWeb trying to learn VB on top of Database design in my spare time wasn't all that successful. But I still remember my wonderment at the ease with which the pieces went together. The drag and drop design paradigm for interfaces is near ubiquitous.

Reading an article like this and hitting the comment link and anticipating meeting one of the developers is, for me, what makes HN so amazing.

Access 1.0 was the first piece of software I paid for out of my own pocket. I'd been doing BASIC, VB, Pascal and Assembly for a few years then, so getting into JET and Access was easy. And the ease blew my mind. Before Access there was Borland Paradox, which was (if memory serves) the only database engine you could call from VB. It was really brittle though, which made the ease of using the JET engine all the more amazing.

Access's 1.0 code name was Cirrus, in the About box's easter egg you can see a bolt of thunder coming from a cloud striking two ducks in a pond. A pair of ducks...

There is a project called Gambas (http://gambas.sourceforge.net) that has tried to replicate what VB was. The project has been well maintained over the years and the latest release was 14.03.2015.

It support designing GUI applications visually just like VB, but the implementation of the runtime component exists for both Gtk and Qt. Same with database access (MySQL, Postgres, Sqlite). There are other components too like SDL.

The language is not 100% the VB language, but similar (with some modern features).

Not very different to the Delphi side. The Lazarus project is active and last update was also on March, 2015: http://www.lazarus-ide.org

"Last updated April 22, 1996."

I think Delphi most like Visual Basic.

Reply on news.ycombinator.com