
BASIC for Android - watchdogtimer
https://play.google.com/store/apps/details?id=com.rfo.basic&hl=en
======
chipsy
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.

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

[https://itunes.apple.com/us/app/lisping/id512138518?mt=8](https://itunes.apple.com/us/app/lisping/id512138518?mt=8)

I am yet to find something similar on Android.

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

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

------
jarcane
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...](https://play.google.com/store/apps/details?id=com.mobilebasic.freeversion&hl=en)

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.

~~~
onion2k
I've used Termux
([https://play.google.com/store/apps/details?id=com.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](https://play.google.com/store/apps/details?id=com.termux.api)

~~~
raddad
Also in the repository you can find Emacs etc.

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

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

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

~~~
dTal
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").

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

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

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

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

Is this intentional?

~~~
dTal
You can download the latest .apk here:

[http://dl.bintray.com/rfo-
basic/android/v01.78/Basic.apk](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!

~~~
esoteric_nonces
HTTPS link: [https://dl.bintray.com/rfo-
basic/android/v01.78/Basic.apk](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).

------
jjcc
There's a BASIC development tool called B4A which can be used as a RAD tool.
[http://www.b4x.com](http://www.b4x.com)

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

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

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

~~~
Jtsummers
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](https://www.cs.utexas.edu/users/EWD/ewd04xx/EWD498.PDF)

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

~~~
Jtsummers
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](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.

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

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

------
jdalgetty
This would be awesome on a priv.

------
Sarkie
" 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 "

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

~~~
drdaeman
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).

