The End of Visual Basic

I spent almost 6 years as CTO of an online education company. We helped teach thousands of students the craft of programming that allowed them to go from complete newbie to employed software developers. As such, I feel qualified to say that the current state of beginner programming languages is much worse than it was when I learned.

The end of VB represents a big opportunity.

My first programming language was QBasic (unless you count DOS batch files as “programming”). It was trivial to get started – all I had to do was type a single command and I would be presented with an editor. I would hit a single button (F9 if memory serves?) and the interpreter would run my code. This is what it looked like:

Here is a list of things I didn’t need to learn:

  1. Types
  2. Closures
  3. Return values
  4. Objects, classes, encapsulation, polymorphism, etc.
  5. Databases, SQL, etc.
  6. HTML
  7. CSS
  8. Command line tools
  9. Version control
  10. Visual Studio Code / Vim / Emacs / whatever
  11. Regular expressions

You get the point. There are definitely lots of other things missing from this list that you need to know in order to be productive software engineer or web developer in the modern world.

QBasic even came with a couple example programs! There was the infamous gorilla.bas:

And there was even a snake game called nibbles.bas:

Of course I eventually moved on from QBasic to “real” languages. (VB, Java, C, Python, etc). I firmly believe it was significantly easier to learn those languages once I had spent enough time with the QBasic training wheels. The different syntax wasn’t so intimidating, and learning new concepts was easier because I wasn’t also learning the basics at the same time.

In the modern world, there is nothing quite like QBasic out there that I am aware of. And I believe the number of people that get turned off software development because of the steep learning curve can be mitigated by a great first programming experience.

When I bring up this topic, the following are usually mentioned:

  • Python / Ruby (still too complex IMO and require too much CLI understanding, no integrated editor)
  • Swift playground (integrated editor is good but the language is too complex)
  • Forth (high potential but the experience is unpolished and feels like it was built in the 90s, which it was)
  • Smalltalk (same as Forth)

There’s too much knowledge required to get started, and too much of our modern development stack influences our thinking when we teach newbies. The curve is far steeper than it needs to be.

You should be able to open an editor, run your code with zero configuration required. And the language you write should be close enough to english that you can learn it by reading code. We don’t need anything else for this task. No syntax highlighting, autocompletion, type checking, and so on. It doesn’t even need to be (gasp) a web application. In fact, it probably shouldn’t assume you’re building an “application” at all. Most newbies don’t even really understand what that means or entails anyway.

Of course we could revive QBasic. It’s still around but requires an emulator (which I think you’ll agree is too much of a learning curve already). There is also QB64 which looks promising.

But what we need isn’t an emulated version of QBasic. We need a modern QBasic, with a modern editor and a modern look and feel. Nobody wants to feel like they’re running code on an old pentium machine when they first get started. They want to feel like they’re getting to peek behind the curtain of the software they use. They want to be productive almost immediately, with a fast feedback loop.

If you have thoughts or opinions on this topic and would be interested in collaborating, please email me.

Video conferencing box

Video conferencing box:

  • contains a super sensitive, omni-directional condenser microphone and a loud speaker, you can select them in google hangouts
  • plug it in and solve your video conferencing problems


Mic -> compressor -> usb interface -> hub

speaker -> usb interface -> hub

A better kind of app store

A Better kind of app store

The browser is a distribution channel. Writing apps in JavaScript, HTML, and CSS is like being told by your distributor that you can only build your products in a certain way. That’s ridiculous!

Build a better distribution mechanism that allows you to build apps the right way: either binaries or interpreted code, bundled with the right executable, so that the client has to do basically nothing.

A browser with a different emphasis.

It would:

  • Automatically know the system architecture and download the appropriate binaries (if available)
  • If the app is source code + interpreter, automatically select the correct interpreter / runtime for my architecture
  • Automatically check for updates, and install them

Now you can write your apps in any language you like, as long as you can provide either a binary or bundle the interpreter with the code.

Sort of related ideas:

  • Heroku slugs (and build packs)
  • JAR files
  • homebrew
  • mac app store
  • ruby gems / python eggs
  • build systems
  • makefiles
  • apt-get / aptitude (and other package managers)
  • docker? probably not, since it’s linux-only

What the developer would have to supply (via upload or git push):

  • either an executable, or source code
  • a manifest, which has:
    • version number
    • for each supported platform:
      • which version of a runtime is required, if any
      • instructions on how to satisfy dependencies
      • launch information (how to run this app)
        • run the binary, or
        • run the included source code with the specified runtime

The service would take the following steps, upon receiving your app:

  1. read the manifest
  2. for each platform, build a slug:
    • obtain runtime
    • satisfy dependencies

When the user downloads the slug, it’s 100% ready to launch. The client software would take care of converting the slug into a desktop shortcut, start menu item, dock item, whatever.

Attack vectors

  • automatically integrate with homebrew somehow (to immediately have access to a ton of applications)
  • automatic manifest generation — detect ruby apps (gem files), python apps (requirements.txt), java apps (ant.xml), etc.

Take a 70/30 cut, payments with stripe.

Totally free to upload, no curation at all.

Ability to upload simple pages (like github does).

Deploy hooks, so that whenever you push your repository to github, your app is built on this service and ready to go automatically – if you want (or if the version number has changed).

Need a name.

Login with github, and automatically just pull from a repository.

Integrate into spotlight + windows search