@natecull Have you checked out Lua Carousel on Android?
Pros:
Cons:
I don’t have a phone but I am interested in touch input methods, something came up yesterday that might be relevant here(I’ve cross-posted this here as well but from the other angle).
I’m taking a break off coding this month, but I still lurk in coding-related mailing lists and such things. Most of my focus nowadays is the malleability of rewriting systems, specifically bag-type(multiset rewriting). One of the neat thing, with systems like this, is that they are non necessarily textual, since they are not ordered(a a a b b b is the same as a b a b a b) so the order in which you input things don’t matter, so something like a text-area for inputting programs for these systems equally doesn’t matter either.
The ideal interface for programming systems like this is something akin to the diablo Horadric Cube, or any video game character inventory really. Which occurred to me this morning, is probably the ideal touch interface for coding as well.
+1 for @akkartik’s recommendation. I have played with it a bit, and intend to play more with it later. It turned out to be unusable for my immediate goals at the time because it doesn’t give access to enough of the Android API, but that’s of course very application-specific.
Another on-device malleable development system is cl-repl, which is a full Common Lisp environment. It lacks in documentation, in particular for writing GUI code (which is almost a necessity for something useful on a phone). The GUI is based on Qt, which is a lot more bureaucratic than anything I’d really want to use on a phone. That’s the main reason why I haven’t persisted with exploring it further.
Took a few days to find out what kind of touch-first interface I could come up with that also does away with english altogether. As suggested above, I went with the Horadric crafting box-type interface because it can be explained in 10 seconds and needs no prior programming knowledge:
This is, to me, the most powerful general purpose programming paradigm and it conveniently lends itself well to touch interfaces as it has no keywords.
The interface includes symbols that can be modified, a ruleset and a bag. The whole be explained in very few pages:
Since the paradigm is mostly unknown to most people outside of academia, I also made a little zine:
The zine includes the source for a tiny implementation of multiset-rewriting based on fractions and prime encoding, that anyone can implement in 5 minutes:
long src[] = {2,3,0,0};
long *f = src, acc = 18;
while(f[den])
if(acc % f[den])
f += 2;
else
acc = acc * f[num] / f[den], f = src;
It has been nice to see people make their own, and figure out on their own how to write complex programs. Some people have even made their own physical paper computers for it(it’s like realtalk, only moreso):
One teacher showed their students how to use this and people got it near instantly. One unpredictable effect was that it can be used to tell stories too without anything special extra:
You can try the playground online(3800 bytes), or build it from sources
I hope this gives you a taste of what a minimal and touch-first programming languages can look like 
This particular groundswell has been absolutely spectacular to watch as it happens 
What if the rules were randomly selected… You can always force an order if you want to with a specific element / catalyst.
And this is very similar to distributed programming frameworks, like chymyst
Check this at 5:00 min.
Would people understand it if the rules were executed randomly?
Right now the next rule to evaluate is highlighted, and it makes for a predicatable system that’s easy to learn, random rule evaluation cranks this up a notch and out of easily graspable concept-space(in my eyes).
That being said, we’ve be talking about adding a button that changes evaluation order, non-deterministic rule evaluation is fun, to enforce a specific order, you need to stricter rulesets but that often also makes programs more likely to be reversible for the RHS is more likely to be unique.
Wrapping this in games could make an excellent pedagogical tool for teaching people about computing!
Ended up implementing the unapplication of rules, making it possible to run a program backward and forward. It even has backward time rule hinting
I’ve created a specific topic:
Wrapping this in games could make an excellent pedagogical tool for teaching people about computing!
Puzzlescript is a rewrite based game engine, worth having a look!
This is making me wonder about a visual stack language as a GUI experiment. What if:
Not sure where to take it after that, but it might be fun to mock up and play with.
I went for a completely symbolic multiset because it’s more forgiving/touch-friendly than an ordered set and does away with all textual tokens(instead the sprites are editable), the placing of things with touch can also be done in any order, I’ve done a couple of visual stack machine representations but they’re finicky, and drag/drop has to be very accurate. Plus, something like an inventory allows you to do funky stuff like programming recipes that trigger on drop:
But don’t take my word for it, I hope you still try it out, in any case visual stack transformations are fun to look at.
For the visualization of a stack machine, I recommend having a look at Homer’s interfaces:
I’ve noodled a bit a bit in the past on the subject of a platform that lets you make up unique glyphs for function calls. Like keyword args, except not text. So far I have a glyph for drawing rectangles and editors.
This is the photo of Edwin Brady on GitHub.
The meaning of the photo is that a dependent type is like a specific shape and programming with them means to put the correct shape to the correct box.
One problem we have with DT, is that the number of text symbols eventually explodes, leading to great difficulty in interpreting them.
Here is where a visual representation of a type might actually be very helpful for a subset of DT. Encoding information on the number of angles, the type of color etc. would greatly help. I believe that this endeavor has great potential!
Visual representations are indeed a good safeguard against abstraction overload. It’s something I noticed in my journey towards moldable development in Glamorous Toolkit. An abstract class to which you can’t add useful views is code smell.
