BASIC for Android | Hacker News Reader

BASIC for Android

play.google.com

86 pointswatchdogtimer44 comments

I remember trying this one and thinking that the language was fine(it is literally an update from the makers of the Atari 8-bit BASIC) but the UI is unsuitable as it uses generic Android text input, the same flaw shared by most every other on-device IDE I've tried. That doesn't just mean that it's crude, it's also buggy - the view desynchronizes when editing large bodies of text using that text control.

What touchscreen programming needs is a really polished touchscreen UI, and that challenges the whole assumption of a text editor being ergonomically optimal.

Lisping is a very good example on iOS of coding with touch.

https://itunes.apple.com/us/app/lisping/id512138518?mt=8

I am yet to find something similar on Android.

How about https://mad.cs.fau.de/fasl/?

Unfortunately, the development seems to have completely stalled and the site's partially dead, but it's still in the Play Store: https://play.google.com/store/apps/details?id=de.fau.cs.mad...., and the source's on Bitbucket: https://bitbucket.org/mad_fau/fasl

Doesn't look as user friendly.

Check the iPad screenshots, https://itunes.apple.com/us/app/lisping/id512138518?mt=8#

However I never tried it, just saw a demo of it a while back.

I think LISP is an excellent fit for the poor text input facilities that touchscreens offer.

Structuring, wrapping an navigating code bodies is very easy, thanks to the simple syntax structure of the language, and you need very few uncommon characters (parens, quotes and dashes being the most common ones), buttons for which would easily be fitted into the touchscreen UI.

auto-completion is also pretty simple, since most of the time the first entry of a non-quoted list will be a function listed somewhere near in a defun, and other entries will often be an identifier nearby. Other cases, such as constants, new identifiers or unknown functions, will need more input work from the user, but this is still feasible.

Yes, but there is other area that I think it keeps unexplored, taking advantage of writing recognition to write programs.

Just writing down as one would be on a piece of paper.

Many tablets have their algorithms quite good nowadays and yet developers use them to create ToDo list apps.

There is just a few Android apps I know that make use of it for drawing diagrams.

I desperately wish there was an Android port of Lisping. I want it badly, but iOS devices are ludicrously expensive in my country.

In the interim, I've found hacked (https://play.google.com/store/apps/details?id=com.hackedapp), while a game, I think actually does a pretty good job as an interface. It's largely pleasant to work with, save that I would prefer to be able to name my own vars. The game itself jumps in difficulty rather quickly though, by chapter 3 or 4 you are already asked to write a sort algorithm in what is a pretty restricted language.

On Windows Phone I was also really impressed with Touch C (https://www.microsoft.com/en-us/store/apps/touch-c/9wzdncrdr...) as an interface, it's just a shame that the implementation was so buggy and incomplete.

I have tried two approaches to address these problems: "Pure" graphical programming (http://flowgrid.org) and collapsed function declarations, avoiding large text bodies (although for JS, not BASIC: https://tidejnet.appspot.com/v3/). Both are still prototype-ish, but if you take a look, let me know what you think should be improved..

Microsoft has something like that: https://www.touchdevelop.com/ People have also built tools off of Google Blockly: https://developers.google.com/blockly/about/showcase

There's also this one, which seems to be a bit more of a structured approach: https://play.google.com/store/apps/details?id=com.mobilebasi...

The trouble I always wind up having with these though is you quickly discover that it's a huge pain in the ass trying to type code on an Android touch keyboard. Even in the days you could still get physical keyboards it was hardly pleasant. I just wind up writing a couple basic "Hello World" programs and get bored.

I've used Termux (https://play.google.com/store/apps/details?id=com.termux) with a Bluetooth keyboard on my Nexus 6P to write a few nodeJS apps. I'd say it's about as good as writing code over SSH. All the important stuff works - serving on localhost, npm, git, etc. Actually, the most annoying thing about it is switching between windows.

As a bit of a bonus there's an extension app for Termux that gives you access to some phone features like SMS receiving and sending, the accelerometer and GPS. https://play.google.com/store/apps/details?id=com.termux.api

Also in the repository you can find Emacs etc.

Just looking around, I found a programmable calculator from the same developer with BASIC support - https://play.google.com/store/apps/details?id=com.visualisat...

This is great. BASIC was my first programming language on a TI-92 calculator. It provides an invitation to new would-be programmers to explore writing code. Having it available on Android just opens the door for more people to try.

I thought TI calculators used Pascal, and Casios used BASIC.

No, the TI-8x series used in high schools use TI-BASIC, a version of BASIC that makes most other BASIC dialects look good by comparison. Seriously, it's rubbish.

You clearly haven't tried the BASIC on the TI-89, which is capable of symbolic math. Not only does BASIC get full access to the CAS, it also has some really powerful features I've not seen anywhere else - for example, #("some_string") will return the value of the variable named some_string (they call this "indirection").

...So, you've never used LISP, or played with a language with eval in it? In either, the above isn't exactly built in, but it is trivial to create.

But yes, being unaware of the 89, I was talking about the Z80 calculators that make up the rest of the TI-8x range, which are still used in schools to this day, which are programmed in a rubbish version of BASIC called TI-BASIC. It sucks. The 68k calculators, like the 89 and the nspire are programmed in a completely different and much better version of BASIC. This is also called TI-BASIC. This leads to much confusion, and to make it worse, there is a third TI-BASIC, which is also completely different, and was used in the computers made by TI.

I seem to recall that back when Android was new, Google was pitching a web based RAD tool to develop simple apps.

That's probably App Inventor. It was based on an MIT project called Open Blocks. Google shut down their version and transferred everything to MIT who now publish it independently, so it still exists.

"This item cannot be installed in your device's country" (Turkey)

Is this intentional?

Since it has functions for encryption, it might be subject to US export restrictions.

Can be installed just fine in Russia.

Russia > Turkey

Please don't do this here.

Ok got carried away :)

This is purely speculation -- I have no reason to favor any belief about the actual state of reality here -- but it might also be subject to import restrictions.

You can download the latest .apk here:

http://dl.bintray.com/rfo-basic/android/v01.78/Basic.apk

(Don't take my word for it though - that would be a security risk. I could be a malicious actor! Poke around on the site and you'll find the link.)

Incidentally, I always do this (or use F-Droid). Google Play gives me the creeps. It angers me when supposedly "free" (as in libre) software only offers binary downloads through Google Play, or makes the .apk difficult to find. Prominent links to a downloadable .apk, people!

HTTPS link: https://dl.bintray.com/rfo-basic/android/v01.78/Basic.apk

(I have done no verification of the contents here, merely added an 's' and checked that the download still works).

There's a BASIC development tool called B4A which can be used as a RAD tool. http://www.b4x.com

One of the things that keeps Android in my phone is the ability to load languages: Ruby, J, Forth, Octave, Clojure...now Basic. I want a supercomputer in my pocket, not a curated garden.

Haven't worked on it for a while, but see also www.hecl.org

BASIC. It's still a fun language for toys and prototypes, and Dijkstra is a moron for saying it ruins programmers, but on the other hand, it is kind of rubbish.

That letter by Dijkstra was certainly hyperbolic. But he was also referring to a version of BASIC where unstructured programming was the norm. To say that that ruins programmers is not entirely wrong. Consider the developer who has to unlearn years of habit involving the use of numerous global variables and temporary variables that produce unreasonable code. What does t1324ab123 mean?!? Seriously. What does it mean? This is in code written by people with bad habits. The hyperbolic element is that they're "brain damaged". But the truth is, they have to be rehabilitated and convinced that what they're doing is unmaintainable and unreasonable. Programmer background does matter. Modern BASIC is not at all what he was railing against in that letter.

EDIT: EWD498 - https://www.cs.utexas.edu/users/EWD/ewd04xx/EWD498.PDF

That's certainly one point of view.

Another point of view is that expecting beginners to adhere to a rigid set of rules and design principles is both unrealistic and makes the learning process dull.

Pretty much an entire generation of programmers cut their teeth on the BASICs in the early microcomputers, and we have all kinds of whizzy stuff now.

Where's the modern equivalent? I would argue that it's HTML/Javascript/CSS ecosystem. It has many features in common with the early BASICs.

It's on every machine (well, every machine with a brower, which is pretty close to every machine) It's there as soon as you start up. It lets you tinker around with graphics and sound out of the box. It doesn't require any tedious and confusing (to a beginner) compile/link process.

It's danged-near as messy as old school BASIC, too, yet it's also where most of the innovation seems to be occurring. Personally, I do not think this is a coincidence.

That same generation of programmers also moved us out of the GOTO hell that they existed in with more reasonable structured languages. There's a reason, and it's not just coincidence, that old school Fortran and BASIC and assembler written in an unstructured manner is difficult to maintain and reason about, while software written in more structured language is easier to maintain and reason about.

This is what Dijkstra was commenting about. It's related to his "Go to statement considered harmful" (1968) paper and his text (with Hoare and Dahl) Structured Programming (1972).

EDIT: I was looking for something like this.

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

  Version 6 saw the introduction of separately compilable
  procedures with parameters. In 1976, Steve Garland added
  structured programming features to create Dartmouth SBASIC,
  a precompiler which produced version 6 output (and which
  formed the basis of ANSI BASIC).

Structured programming was introduced into at least this version of BASIC after Dijkstra's statement about BASIC causing brain damage.

You are missing my point, I think.

There is no reason why "language suitable for building gigantic, uber-complex, mission-critical systems" and "language suitable for fooling around with as a beginner" should be the same, and many reasons why they shouldn't.

I never said they should. But languages like the historic BASIC created a set of habits and ideas that had to be unlearned to build reliable, scalable software. Your example of JavaScript as a modern BASIC is a different language. It provides all the structured programming ideas that Dijkstra wanted. Where it fails (failed?) is in its concurrency mechanism favoring a version of callback hell and its weak type system. Those are much easier to overcome than first learning to code by interleaving code blocks and using gotos rather than subroutines, while loops and the like.

That "rubbish" created an industry worth hundreds of millions at the height of Visual BASIC and thousands of programmers were exposed to BASIC as their first language from the late sixties onwards, including Bill Gates. BASIC evolved over the years to become a powerful language to build solid systems with. And unlike Python it could do proper division from the start without loading libraries.

But VB ISN'T BASIC. As in, at all. It may have started out that way, but VB has as much of a relation to BASIC as modern C++ has to C: There's a legacy connection, and C is supported by the compiler, but the actual code doesn't look or feel like C in any way. The BASIC we talk about here is Unstructured and Structured BASIC, which bears very little resemblance to VB, and has many failings.

As for python, I believe you can do division just by using the / operator, just like most other languages. Unless I misunderstood what you meant by "proper" division. Even so, what's so bad about having to load a library to do division? It's not great, sure, but it's not awful, and it's a good deal better than the many sins of BASIC.

This would be awesome on a priv.

" Version 1.90 can access: Location approximate location (network-based) precise location (GPS and network-based) access extra location provider commands SMS send SMS messages read your text messages (SMS or MMS) receive text messages (SMS) Phone read phone status and identity directly call phone numbers Photos/Media/Files modify or delete the contents of your USB storage read the contents of your USB storage Storage modify or delete the contents of your USB storage read the contents of your USB storage Camera take pictures and videos Microphone record audio Wi-Fi connection information view Wi-Fi connections Device ID & call information read phone status and identity Other full network access mock location sources for testing control vibration prevent device from sleeping pair with Bluetooth devices access Bluetooth settings install shortcuts uninstall shortcuts "

It is rather obvious from the description that is required so that you can write BASIC programs that use GPS features, etc.

I know that it's quite common at HN to complain about android permissions but this is probably a wrong context to do so.

Well, that's still a scary set of permissions. Application can be fine, but one has to be really careful with the scripts from the untrusted sources. It's not hard to sneak something in a large enough file.

Android 6 on-demand permission requests should somewhat fix this, but is still not a remedy. I've yet to see any scripting/automation tool that's able to run scripts properly sandboxed (generate APKs for them or otherwise obtain different UIDs with restricted just-enough permissions).

Reply on news.ycombinator.com