Ask HN: Do you program in Basic?

I wrote my first complete computer program on a Vic 20 in Commodore BASIC 2, in 1986. My first paid program in 1990, using Thoroughbred BASIC on a PC. Since then I've programmed (or scripted) in Assembler, BASIC, C, C#, C++, COBOL, F#, HTML, Java, JavaScript, LOGO, Pascal, SQL, VBA and XAML. I don't mind C#. Or Java. I stopped programming for my income around 2005 when I moved into architecture and then went the CTO route. Did take on another programming contract in 2011 though, because it was Nokia. Still write a lot of my own code though, and now exclusively in VB.NET because

- VB.NET supports both static and dynamic typing.

- VB.NET is a functional language, supporting local type inference, anonymous functions, monads, and language integrated comonads.

- VB.NET does project-wide namespace imports. C# doesn't.

- I like creating native client apps, and dislike the constraints and fragility of web apps.

- I've always found the Java developer environment to be brittle in comparison.

There are also a metric ton of readability issues in JS, Java and C# that VB.NET doesn't have (braces, == and =, ! instead of Not, separate keywords for inheritance and interface implementation, and so on). I also concede that I learnt Pascal before learning C (and prefer Pascal to C). The fact that Pascal and VB.NET share syntactical similarities (type declarations follow variable and function names, the Not keyword is probably not an insignificant factor.

And to be fair none of the above matter – the rationale came long after the fact that I use BASIC simply because I like BASIC.

The amount of disapproval, verbal abuse, ridicule and actual anger I've received for this over the years (and to this day) is insane. But you learn to deal with it.

PS. Did you know that the first prototype of Nokia Maps for Windows Phone was written in VB.NET? Nokia didn't know either, because they had like zero Windows Phone skills at the time.

I might, very rarely, do some maintenance of a BASIC program these days. And that would be because the program I am using might require some minor tweaking.

But invariably, I do all my new programming in C.

The flavor of BASIC I used to use is North Star Disk BASIC, very similar to HP BASIC.

A few lines from an old project:

      1 REM*** THIS PROGRAM CONVERTS A 8080 PROGRAM INTO AN ASMB LISTING*****
     10 DIM A7(256),B7(256),A7$(512),B7$(10*256),B8(256)
     15 DIM K7$(20)
     20 A7$=""\B7$=""
     30 !\!"   FILECRAK: Disassembles 8080 opcode programs"\!
     50 FOR M=1 TO 256
     60 READ A,A$,B,B$
     70 B8(M)=LEN(B$)
     80 B$=B$+"           "
     90 A7$=A7$+A$\B7$=B7$+B$
     100 A7(M)=A\B7(M)=B
     110 NEXT M
     120 INPUT " File name of 8080 program:",V$\!
     130 CLOSE#1\ OPEN#1%1,V$,L6
     135 OPEN#5,"ASSEMBLE"
     140 L6=L6*256
     150 INPUT " 8080 op-codes begin at:",L$
     160 INPUT " Begin disassembling at:",J$
     170 !
     180 INPUT " Output to printer? ",H9$

Clasic VB, (aka VB6). Each year it is more difficult to install the IDE, but the runtime is still installed by default.

It is incredible easy to build a nice one screen application with not very a very complicated background logic. Normal people like a nice graphical interface with a few buttons, and with Classic VB you can create them very easily and iterate and customize the form.

My last big problem was that it doesn't have a build in sort function, so you can use a n^2 sort or write a good sorting function by hand :( . When the logic start to be not so easy, there begin to apear problems.

Kinda, I'm currently learning Idris and compilers by writing a CommodoreBASIC compiler that targets the HP 15-C calculator: https://gitlab.com/michaelzinn/voyc

Compiler output looks like this:

  227 IF Q>0 THEN 230......................................................90 1
                                                                           91 0
                                                                           92 8
                                                                           93 CHS
                                                                           94 STO I
                                                                           95 0
                                                                           96 RCL .1
                                                                           97 TEST 7
                                                                           98 GTO I
  228 P=INT(P/2)...........................................................99 RCL 9
                                                                           100 2
                                                                           101 /
                                                                           102 INT
                                                                           103 STO 9

I get the games to compile from the old "101 BASIC Computer Games" book: http://vintage-basic.net/games.html

I liked BASIC, but haven't done anything with it since Microsoft cut Visual Basic 6 - wish they had open sourced it back in the day. It probably would have thrived. I might have written some VB Script at times afterwards (for security testing) but not really using other than that.

So, no BASIC project since 1999 for me. VB had cool editor, amazing debugging capabilities (still not matched by anything these days, we are often even going backwards with new languages) and was great for developing and visualizing data tier apps quickly - or "rapidly" how it was called back then.

First programs I wrote were in BASIC on Amstrad CPC and Commodore computers. Fun times.

I have been using Xojo (Former REALBasic) for about 10 years to code database-driven business apps for several businesses with great success.

I also use x86 asm, Rust, Racket, NewLisp, Scheme, C, Python, JavaScript and shell script (sed, Perl etc) for other clients and uses. Xojo lets me compile for Win, Mac, Linux from the same install, the syntax is delightfully simple to use and to teach. Performance beats interpreted languages (LLVM-based), it compiles to standalone bins that do not rely on .NET, unlike Visual Studio. When I need more power I simply embed a lisp (Chicken or NewLisp) as the provided FFI works well. I’m currently writing a new IDE for NewLisp with Xojo and it’s handling UTF8 like a champ.

Xojo is very mature and most of the bugs have been squashed long ago, I just wish it treated functions as first class citizens. Apart from that, for internal business apps and retail-quality Win/Mac UI apps, I honestly haven’t found anything more effective to go from prototype to binary quickly and painlessly.

It’s our secret weapon, and clients don’t care it isn’t mainstream. Now if one could come up with a similar IDE coupled with a lisp... DrRacket + MrEd come close, but for large projects it becomes a pain. Until then I’ll write basic code for basic business apps. For everything else, there’s a lisp.

Excel also. Sometimes, in a locked-down corporate environment but where every PC comes with a pretty powerful language and IDE built-in, it's simply easier to DIY than go through a process of approval and budgets. This does raise the very good question of maintainability and legacy use after I'm gone, a medium term solution is to ensure others proficient in VBA and computer science in general are on the team, and a long term auditable solution to ensure the process being automated stays documented and not magic. I enjoy VBA, combined with Excel it can do a lot.

Such nostalgia!

My enchantment with BASIC began when I was 10, and on the bus to summer camp every morning I'd read this dog-eared book:

https://imgur.com/a/kmBfx7Y

I was such a nerd. The counselors didn't know what to make of me. Dad complained I should spend more time outside.

Then I grew up and published my first commercial software title, turning that geeky addiction into a career. It was an Outlook addin, created in VB6 around the time a prominent Microsoft MVP called Outlook the "buggiest program to ever come out of Redmond" (source: https://web.archive.org/web/20091231043608/http://www.slipst...). So in the next rewrite, I created a framework to bring Try/Catch semantics to the language along with stack-tracing error logging - after testing and discarding several equally buggy third party tools purporting to do the same.

I gained some hard-learned lessons about instrumentation, coding for readability and debugability, and the importance of good tooling. They've stuck with me to this day, and although most of my work now is in C#, the principles are the same.

Thanks mom and dad for buying me that beat up old TRS-80! And thanks Mr. Kemeny and Kurtz for bestowing this beautifully approachable language onto the world, even if your original vision was shamefully bastardized by the time I stumbled upon it.

ps. That book in all its glory: http://www.colorcomputerarchive.com/coco/Documents/Manuals/H...

The QBasic community is excellent and pretty active (peaked around 2008 or so, though). Check out http://www.petesqbsite.com/ to learn more.

I recently did a project involving the "Mint BASIC" embedded in the NextMove ESB-2 motion controllers from ABB. The BASIC was used to communicate between the embedded motion controller library and a Linux system over an RS-232 serial port. Linux was running ROS with code in C++ and Python.

The ESB-2 also had a USB port, but only worked with an Active-X control in Windows. So by using Mint BASIC we avoiding having to use Windows.

Mint BASIC is a clone of VB and I thought the syntax was pretty nice. It had some weird things like a.2=3 is the same as a[2]=3. Also a[2,3,4]=7 is the same as a[2]=7, a[3]=7, a[4]=7.

I own a bunch of retro machines and use them to teach my kids BASIC (and LOGO). Sometimes I’d do a bit of coding on there myself for a bit of fun.

Sometimes I do catch myself “thinking in BASIC” when writing coding with C-style syntax. In that rather than saying:

   For brackets I equals zero semicolon....

   For I equals zero to n

For all it’s warts, BASIC can read a little like pseudocode.

Edit: it probably comes as no surprise that even until the late 90s I still preferred writing code in Pascal than I did in C.

My longest-lived piece of code is the Excel VBA code I write for my Dad’s company over 20 years ago. I built a custom export documentation generator for his export business, with centralised price list with individual prices for customers, stock control and production tracking. It is still in use, more than 20 years on. Scary and awesome at the same time!

Submitted a simplified version of it as part of my IT coursework in college and got top marks in the class. ;)

Occasionally, I do, that is when writing Excel macros in VBA (Visual Basic for Applications, Microsoft's Visual Basic flavour for macros).

The reason why I do this is that the - for better or for worse - the world runs on Excel and some things (e.g. reporting, ad-hoc conversion of CSV data), especially one-off solutions (I know, nothing lasts as long as a prototype in production ...), are faster to implement in Excel and will also be more readily accepted by users because Excel often is what they know already.

The language is alright, the IDE within Excel, less so. I try to write VBA in a maintainable manner but especially with Excel's macro recording feature it's possible to create quite messy code. Macro recording is fantastic for bootstrapping functionality but you have to edit the resulting code if you want it to be maintainable further down the road.

Other developers often frown upon Visual Basic and don't consider writing VBA code in particular to be "proper software development" but it gets the job done and that's what counts.

My most productive time as a non-professional programmer was when I used REALBasic. That was when it was affordable shareware, before it became insanely expensive and got the totally silly name "Xojo".

REALBasic was better than any other language in terms of productivity and no language/framework combination has matched that for me so far. I used to be very active in the REALBasic community and was able to make fully working applications within a few hours. That meant that I had time to spent on details that no current applications have. For example, my application used to give visual feedback to any action, including blinking menu items, blinking selections when text was copied, and so on. Contrary to what people claimed even then, carefully-planned applications also had way less bugs than they have in any language I use nowadays. REALBasic was also way better as a language than what C++ people used to say about it, it was fully structured, had OOP, and was overall pleasant to use. It definitely gave better results faster than other frameworks, and RB's OOP was a perfect fit for end-consumer, GUI-oriented applications.

Nowadays, I do own Purebasic, but since it's not structured and has no genuine cross-platform support for rich text in edit fields, I barely use it. I currently use Go with GTK3, but the combo is way worse and not even comparable to REALBasic (no RAD). The only viable alternative seems to be Python with Qt, but the results are horribly slow and the language is just ugly. I've also been using Racket for many years and the latest version of my (very outdated, long-term maintenance) shareware application is still written in it, but there are too many GUI limitations and performance problems to recommend it.

Bottom line is that I miss the good old "an unhandled NIL object exception has occurred" days. Lazarus is not a good substitute either.

I wrote a BASIC interpreter in golang, and have amused myself programming in it. There's an example which embeds the interpreter into a HTTP-server, so you can open your browser, and enter BASIC code to draw images.

Naturally enough I call this "visual basic" ;)

I've not "seriously" programmed in BASIC for decades, but this was still enough to make me smile and feel nostalgic.

I first learned to program playing with TI-BASIC on my TI-84 calculator in high school.

I would never recommend it for a new, fully fledged software project these days. But I would consider it a great learning tool. Can't speak to other BASIC dialects, but TI-BASIC to me was perfect due to how limited the syntax was, and because of the TI-84 interface, to program directly on the calculator you had to select the keywords from a menu interface, which was great for feature discovery. Even if you weren't programming in a menu interface, you could probably have a single page keyword cheatsheet/language spec sitting alongside you to remind you of basically everything supported by the language.

To this day, I suppose I wouldn't completely scoff at someone who was using BASIC for very basic scripting or doing a quick computation. It is still kind of enjoyable due to how simple it is, and I'm guessing non-professionals probably could figure out what it's doing as long as the program is short enough.

I wrote a little bit of basic on C64, but I was around 9 years old and din't understand English well (I'm Danish).

Later, I found QBasic and spent a few hundred hours messing around in that, the built-in index and manual with examples made it extremely nice for me, as I could always try out things where I didn't understand what they did from the description (still lacking English skills at that point). I mostly wrote stuff that used the lowres graphics mode and put stuff on screen, and a tic-tac-toe game (every move was hardcoded, I didn't know of algorithms at that time).

I never did anything interesting with it, but it seeded my curiosity in programming, probably made it a lot easier for me to understand stuff like variables and calling functions when I moved to PHP, and later C.

I've worked the past 10 years as a programmer, and I think I owe a bit of that to basic.

I stopped writing Basic about 5 years ago. I started with Commodore Basic in the late eighties, wrote some tools for personal use, but my first income apps were in COBOL (really) and FoxPro. I had to write Basic again in ~ 2000 for work, a bit of VB but mostly VBA in Access and Excel and I completely gave up when I found better ways to do it. Today we have a single VB app at work that I plan to have it rewritten, but mostly because we have not enough people to support and modify it when needed. While Basic was a good tool in my childhood, it is hard these days to find good software engineers willing to use it, tools good enough to use and people willing to pay for apps written in Basic.

Classic ASP for me still, although I believe I'm reaching the sunset here with IIS 6 on a Windows 2003 server still being feasible.

Why not change? I know the language so well, and have so many things I can reuse...ok...fear of change.

You can get pretty much anything done with classic ASP still though. Here are a few of my sites both done with only classic ASP server side.

http://www.dudeiwantthat.com/ https://stockdaddy.io/

Now, Jquery has moved some things I would previously do server side to client side, but these are basically classic ASP, SQL Server driven sites.

Occasionally I still touch VB.NET, but to be fair it is more related to migrate code from old VB6 into .NET world.

As info, I used Timex 2068 Basic, 48K Basic, GW-Basic, Turbo Basic, AMOS, GFA Basic, QBasic, QuickBasic and VB as well.

And yes, with the native code compiled versions of Basic it was even possible to do system level like programming back then.

So Basic has a special place for me, even if I barely used today.

Also ignore the naysayers about VB.NET vs VB6, there are plenty of features that are comparable, usually what was left behind were GW-Basic and QuickBasic compatibility features.

Just think that even F# doesn't have the amount of platform love that VB.NET enjoys on VS tooling.

Yes, I program in my own variant in a calculator app ("Best Calculator, IOT edition") that I wrote. The calculator is programmable in BASIC; this is a surprisingly powerful combination.

Writing small programs to automate a calculation is something that should be accessible to everyone; when I created the BASIC editor and overall system the goal was to have as few steps between a user thinking "hey I want to automate this calculation" and having the program be written.

BASIC has a great sweet spot: simple commands, but still a real language. My version, of course, doesn't require line number and has real functions.

Excel. Sometimes it is easier to write a couple lines of Basic code than write a ton of formulas. Sometimes models require some complex logic.

Sometimes it is easier to keep some data in Excel and then convert to JSON with a simple macro.

I use Basic in the form of VBA to automate Excel, and VB.NET on projects that are already written in it (that I don't have time to port to C#). In other words, I use it when I'm forced to. I almost always end up resenting it, a little or a lot. I don't like the verbosity, among other things. And VBA in particular lacks a lot of what I would consider essential infrastructure.

Not to shit on my early days learning programming. Basic was my 2nd language, and even after years away, I was able to jump right back into it. But once you learn how to walk, crawling loses its appeal.

My best and biggest projects were written in GfA-BASIC. This language was both very productive, and fun to use.

I could also predict exactly how each line would be translated by the compiler, and that enabled interesting hacks and optimization techniques.

Kinda like Ruby, BASIC let you express what you want in an intuitive way rather than constantly try to work around the restrictions imposed by the language. There are many ways to do the same thing. None is good or bad.

When it comes to being fun, expressive and productive, Ruby is the only language that comes close to BASIC.

Learned BASIC on the Sinclair ZX81, then BBC model B. Did a ton of VB6 which was great and then on to VB.NET. Also a lot of Excel VBA.

The ability to knock-up great GUI’s using Visual Studio’s WinForms was extremely valuable, having to develop trading desk applications quickly. Then, Microsoft introduced WPF and that’s where I jumped ship.

VB6 was actually a powerful language, compiler which was highly optimized and rivaled C++ in terms of performance. It was a highly productive language for many.

Surprised no-one has yet mentioned AutoIT, it has a BASIC like syntax and is fairly well supported. On one level it's like a more accessible wrapper for Win32 GUI functionality.

Use it for making small programs for fun, the latest to download localised weather from the BBC and give a 1 liner summary or a longer 7 day forecast in a simple popup window.

Also use it for mouse gesture type programs, as an alternative to browser addons or native software.

About three years ago I knocked up a quick BBC Basic program (RPCemu/RISCOS) to play around with some dithering algorithms; I ended up painting the results:

https://flashasm.wordpress.com/2015/11/04/more-incredibly-sl...

VB scripting is the de-facto macro language up to MS office 2014 (I don't really know about later versions). It can instantiate COM objects within the windows environment and through those, parse xml, create json, call web services and connect to databases. It is one of the reasons why VB still exists in the industry.

Honoring the creation of BASIC:

https://www.theverge.com/2019/6/16/18680941/new-hampshire-ba...

BASIC was the first language I learned. First, TI BASIC on a TI99/4A, then AppleSoft on the Apple II, then AmigaBasic on an Amiga. There was also a bit of QuickBasic at one point on a DOS system. I also did a bit of VAX Basic on VAX/VMS! But none of these since the early 90's...

VB.NET was one of my first languages. I also used VBA, especially in Excel.

Despite BASIC's intent to be simplistic, I think that C-style syntax is more intuitive; moving to C# was a great step. Still, VB.NET felt like magic when I first used it, and VBA is still useful in working with MS-Office documents.

I still occasionally write ZX Basic and am planning to get back into Blitz Basic and AMOS later this year. I also have a project lined up using C64 Basic (but probably mostly asm).

It's a tool like anything else, when it's the right one for the job it's worth using.

I use VB.net on existing projects. I use VBA to create applications in Microsoft Office.

As for how people react, most are well informed enough to understand the reasons.

I actually enjoy the process of writing VBA because the REPL is so much better than, for instance, C# in Visual Studio.

I'm curious to hear about the people who are using the commercial Basic versions (PowerBasic, PureBasic, etc). It is interesting to me that there is still a market for paid compilers for general purpose languages.

I learnt to program with VBA for Word and Excel. I found a booklet that my father got along with another IT magazine. My brother and I started self-teaching programming this way.

I still occasionally write some VBA macros.

I really enjoyed working in BlitzBasic and later BlitzMax

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

I embedded VBSScript in one of my applications so get to use that occasionally. Not for much longer though as I’m encouraging my customers to switch to PowerShell.

visual basic .net I like the more humane/natural syntax compared to c#. There are also some very nice programmer productivity features like XML literals.

When I'm retrocomputing, sure.

On anything resembling modern hardware, Python is the new BASIC.

Python is the Basic we all wanted in the 80s.

Yes: MD-BASIC. It transpiles to AppleSoft BASIC. It's more enjoyable than AppleSoft BASIC but it's also enjoyable in its own right.

vax basic