Hacker News new | past | comments | ask | show | jobs | submit login
Ask HN: Do you program in Basic?
67 points by vanilla-almond 38 days ago | hide | past | web | favorite | 85 comments
If so, what flavour of Basic? (PowerBasic, PureBasic, VB.NET, or some custom flavour)

What are your reasons for using Basic? Do you enjoy it? How do other developers react when you tell them 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'm guessing we are about the same age, my first BASIC program was on a speccy in 1986, once we got a family PC I moved to Pascal and other than some VB6 at college in the late 90's haven't touched basic since, I still have a soft spot for Object Pascal (Delphi) though.

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:

     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.

I completely agree. VB6 was the thing that got me into Windows application programming.So easy to create good looking and functional programs. I ended up building several "real" applications, some commercial and some free, which I still maintain. It's a wonder that it still works as good as it does.

I cut my teeth writing VB programs for enterprises in the 90's.

I still think it's the most productive programming environment I've ever worked in, in terms of actually getting something built.

Since then, I've learned a lot more about programming, and I'm not sure I'd accept the compromises that VB makes any more.

VB6 gets a lot of stick but it’s easily the best environment for rapidly prototyping and development ever created.

Some of Borlands IDEs had the same power for prototyping by C++ and Delphi weren’t as great for rapid development (though I have nothing against those languages themselves).

The closest thing we have these days is Electron but I don’t think that even comes close to ease of development once you factor in the clusterfuck of a mess modern web development is.

I did one project in Delphi, and didn't get on with it too well, but I think I was hampered by my familiarity with VB.

Now, I think I'd be much more comfortable with the compromises that Delphi makes.

Have a look at Lazarus (https://www.lazarus-ide.org/), an open source clone of what Delphi used to be. Active development, can compile to single executables for Windows, Linux and Mac OS. And the language is way more powerful than Basic.

I would say Basic is/was liked for the same reason as JS; low barrier to entry, no predefined/enforced structure, no strong typing. Easy to just get going and see where you end up. Object Pascal is not that and so it will possibly not appeal to the same crowd although the similarities are obvious.

Visual Basic was actually strongly typed (unlike JavaScript).

What it did differently to Pascal was that it allowed for lazy / inferred typing along with some transparent type conversation in places where the intention was obvious. However in VB once a variable is defined a type (either when defined or when assigned a value - depending on how the variable was defined) you couldn’t change it. Eg you cannot overwrite an integer with a string

Weirdly, despite being branded a toy language, this meant VB actually had one of the more sophisticated type systems out of the languages of that era because you had the laziness of languages like JS and PHP but without having the === et al kludge that some loosely typed languages need.

Perl is another language that frequently gets mocked but it’s eq vs == solution for differentiating between strings and numeric types is genius and again solves the whole type comparison problem that JavaScript has.

Where does VB infer types? If you don't specify types (which is usually enforced with "Option Explicit"), everything ends up with a Variant type, i.e. a union type that can contain a value of (almost) any actual type and will be implicitly converted on use.

Ahh yes, I’d forgotten about the variant type.

I loved “Option Explicit”. To the extent that it was almost always the first line I’d write for any new project, module and class.

Thanks for that enlightenment; underestimated vb there I guess. I did work in vb and vba, but very minimal and very long ago. Now that you mentioned the example of not being able to change a type once set, that seems to ring a bell. I did a lot of code in Delphi. (And also in Perl actually which I liked and P6 looks good to me: many interesting concepts.)

I have a XP virtual machine I use for maintaining an old software wrote in VB6 (less and less often). With an old Visual Studio on it.

Problem solved :-)

What do you use it for? Just personal apps or professionally?

Why not just use VB.Net/Winforms?

Microsoft made fundamental changes to the Visual Basic language in order to make it run on the CLR, to the point that it feels more like an alternative syntax for C# than the successor of VB6– the superficial similarity between 6 and .Net caused lots of false-friend problems during he transition and most projects would have been better served by being rewritten in C#.

What were the biggest benefits that people got from switching? Where does VB6 most show it’s age? No modern looking controls? Harder to use Unicode?

A lot of VB programming was connecting together 3rd-party COM components, which had to be written in C/C++. After the CLR came along, those vendors slowly stopped supporting VB6 with their new releases as they moved their codebases and workflow to the new system.

That was only true for early VB versions.

VB6 had full support for native AOT compilation and creation of OCXs in pure VB code.

Being able to get a job and not being a “VB developer” for 15 years, the company lays you off, you look for another job and find that no one wants to hire “VB developers”.

Then post on HN and Reddit and scream “ageism is rampant on our industry”.

Disclaimer: I’m 45.

Originally: Not a fast enough computer and IIRC the first form editor of VB.Net was not as smooth as the one of VB6. Also it was a language change, let's call it VB#.Net

Now: 50% laziness and 50% don't want to migrate a few big projects that only need a tweak per year. If it ain't broke, don't fix it.

I haven’t tried to install VB6, but you said yourself that it is getting harder every year to install the IDE. What happens when you can no longer install the IDE?

> What happens when you can no longer install the IDE?

I guess a virtual machine with Windows 2000 and with VB6 is still smaller than the modern programming environments.

Depending in what you need to do; when I last tried, for a legacy system, to run under Wine it was flawless. So by the time it becomes impossible to install I would say Wine will be advanced enough to run all you need. All Windows stuff I need these days works perfectly under Wine. I work a lot with software from almost a decade ago and that mostly just works. Maybe at that time (few years) Wine will run on Windows as well (it has been a long term roadmap feature) to offer just this compatibility layer for old software support without having to install a Windows xp virtualbox.

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
So far, I can compile Hammurabi, but I actually haven't written any BASIC programs myself yet (except some simple QBasic stuff in the last millennium).

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 agree. VB6 was limited (in some parts in pretty idiotic ways), but for prototyping and simple GUIs it was far ahead of anything else. While I do think modern IDEs do have more powerful debugging features it was really good for its time, and the IDE was super snappy. Even on some slow P133 you'd type an object's name and as soon as you hit '.' you got the list of methods, no perceivable delay.

The move to .NET made the language more involved, imo to a point where there was no reason not to just use C#.

...but for prototyping and simple GUIs it was far ahead of anything else...

Better than Delphi? This is out of genuine curiosity because I have basically zero experience with both.

Yes, but only just. Delphi was a saner language and IIRC faster, too. Both of them blew the modern web front end tools into the weeds. Twenty five years ago.

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.

>I just wish it treated functions as first class citizens.

So you cannot store a function in a variable (scalar, list, dict)?

And does it have dicts (Python term) or equivalent (associative arrays)?

If not, a lot of things would be more clunky to program, although possible.

Can you link to one of the applications you built using xojo?

Here's a link to some apps built in Xojo.


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.

I had to do a mockup of a gui recently for traders, and excel did the job. Not a nice programming language, but fast to get something working. It won't be used in prod, thank god!

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:


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...

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.

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

Pete's QB Site is what got me into programming and Vic's game design tutorials is what got everything to "click" for me. I left ages ago, but the QBasic community was a wonderful place, and I owe a lot to them.

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....
Instead I’ll say

   For I equals zero to n
(Similarly for function blocks / “End Function” too).

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. ;)

An alternate meaning of code reuse. Recycle as coursework!

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.

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.

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 agree. I used to do VB6 and always wanted to give RB a serious try but I was a kid and the price was too much to ask my parents for (though growing up I realize I coulda probably convinced them to buy it for me). Plus back then I was experimenting with code but not building anything special just modifying and refactoring other projects to do the same with less code.

I wish Lazarus didnt have such an annoying UI and its sometimes buggy. If it were much more cleaned up out of the box I might give it a serious try. But also theres not many learning resources from what I can see. I would love to make GUIs again that are fast and snappy.

I wish D had some RAD capabilities. I would even pay money for a RAD IDE in D to be honest.

If python & Qt is an option, then why not (modern) C++ & Qt?

Genuine question. QBasic was my first programming language, and I learned C++ only during university. Looking at older code at my job I think I'm lucky to have missed a lot of language-uglyness (we have some legacy code samples that are basically some compiler-specific dialect of C89; feels totally different than C++11).

Modern C++ is a big jump in the right direction, but you still have to compile and link it.

Still it is not so bad on Windows with either C++ Builder or Visual C++, with all incremental options turned on.

Other platforms never invested that much in C++ build performance.

In any case, hopefully modules will make it better.

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 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.

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.

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.

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.

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.

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:


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.

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.

There is a Basic-language IDE called Xojo that has a pretty dedicated user base. https://www.xojo.com/

I used to use it extensively (back when it was called REALbasic) and still occasionally dabble (i.e., tweaking apps I made awhile ago), but it's gotten much too expensive for hobbyist or "scratching my own itch" kinds of projects, which is a shame because I still love the language.

What kinds of projects did you use REALBasic for?

Dozens. Database front ends. Small utility apps. Graphical interfaces to manage workflows where the actual work was done with scripting languages.

Almost every app I did was for either the Mac or Windows, but perhaps the main value prop of REALbasic/Xojo was how easy it was to write one app and have it run on both Mac & Windows. For small applications, it really did Just Work, which seemed kind of magical.

Wow! The memories - I wrote an OpenGL game in Realbasic for the Mac 15 years ago... the trouble with Real Software was that they changed the language and broke backwards compatibility... that turned me off big time. Back in the day I used Amos on the amiga and Microsoft QBX on the PC to write though-the-window display software for real estate agents (this was 26 years ago). The issue with basic in those days was libraries - doing system level stuff (e.g. using Super VGA graphics required a paid 3rd party library)... ahh the memories... these days i’m C++ / C# / PHP / etc. although the most fun I’ve had recently has been with 8088 assembler...

Back in the day basic was frowned upon - but I think these days the stigma is pretty much gone...

So much that people actually pay for them for embedded development.



They also have support for PIC, ARM, 8051, dsPIC, FT90.

Interesting. The Pascal one doesn't surprise me as much as I'm familiar with Delphi but I wouldn't have thought about Basic being used on embedded

Before Arduino, Basic was quite loved among hobbits.



ic0nstrux (nee XGameStation) also had Basic support for their DYI games console


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


In early 2000 I made some small, commercial, games using BlitzBasic and Blitzmax. Coming from 7+ years programming in C/C++ it was a breeze to work with. Mark Sibly, the creator BlitzBasic, Blitzmax and Monkey, really has a talent to make beautiful simple languages.

What I took from those years is that the best tools are those that let you hit the ground running.

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.

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact