It was BASIC that got me into computers in the first place-- ok, basic and drawing. I was less than 7 when I started coding, I literally picked up a manual and started typing things in. The good news is, those things were easy. Stuff like 10 PRINT "Hello world" and 20 GOTO 10. While line-numbered loops are easy to explain, I don't think DO... LOOP is that difficult.

Today, more people learn coding from Python or Javascript or Bash. And that's cool, I've done all of those, I feel like Python in particular is getting a lot more complicated (vanilla Javascript is still pretty close to the original if you want it to be, and nobody really cares so long as your code works-- I know everybody uses libraries and frameworks now) but when I wanted to teach coding as a gateway to computing, some of this stuff is very intimidating and complicated to explain. I personally find shell code frustrating sometimes, though I come from Bash-world (don't worry, I know the true origins) and sh is probably less complicated on a certain level. So I may have really brought that on myself.

When I was married, I made a simplified tool for creating scripts for my wife. It was implemented in Python, but you didn't have to know Python or Bash, but it output Bash scripts. The goal was simply to make her comfortable with the idea of coding. She already did some HTML-- which is of course, a markup language. I wanted to help her to broaden her experience a little.

Eventually I started moving towards a "real" (in terms of features at least) programming language, with about 100 commands (I was very conservative or there would be twice that) and it outputs Python.

One of the design choices I made was to put a variable at the beginning of every line, except for a few special commands. Then every command that needs a variable already has one:

p "hello" print
ifequal p "hello"
    p "hi" print
    next

I like Python's indentation, but due to the beginners I used to try to teach Python to, I decided optional indentation was better for them. So it uses commands instead, like sh or or Pascal or QBasic. (Or HTML, at least for markup).

To make the language extensible, I added inline Python:

python 
    print "this is the one exception where indentation counts"

I made it so that PSET (many of the commands are inspired by basic) would draw to a Pygame canvas if it was available, and to the term using escape codes if Pygame was not installed (or if you used the textmode command to force it -- the default was autodetect).

All in all I wanted to make a language that was very flexible for the features it had, though which had as few things to explain as possible. Making the language more consistent would have made it less flexible, but I tried to maintain a fairly strict level of consistency-- as few rules as possible, even if those few rules were generally followed. there were as few exceptions as possible, only when it made things more reasonable.

Commands like ifequal, else, function-- which used more than one line, did not start with a variable or share the line with other commands. Most commands do start with a variable-- and share the line with other commands.

A "shell" command exists to run things in the foreground (unless you use something like & in the command) and there is an "arrshell" command to dump the output of some commands into an array (a list).

I use it to do graphics, but it has few graphics features. I've used it to automatically remaster GNU/Linux distros (several) because being Python-based, it handles real strings more gracefully (my opinion). It's nothing sh can't do, but I didn't want to do it with shell code. I've done a small logo implementation in shell code, but complex programs are not something I enjoy doing with sh scripts or bash or ksh. Some people are great at that though.

I haven't included more details here, as even though I have an actual implementation (it's half a decade old now and I still love to use it) -- this is more about the philosophy than the implementation. I've worked with people before who wanted to make their own version of the language, and learn how to make this sort of thing themselves. The code is public domain and compatible with both the BSD license as well as the GPL, I have no problem with it being used in either scenario. Though I honestly assume that if most people here were going to to teach someone how to code, they would probably use a popular language, rather than try to design one that lowered the bar for as many people as possible. I mean that does typically work out alright.

I wanted to try to make it even easier than that, so that was the goal of the experiment. I have a tool I love to work with , though I figure for something "easier than Python or Basic" most people would just use a drag-and-drop coding app. Since those already exist, my goal was to make actual written code simple enough to do with fridge magnets or paper cards-- to take an idea like Logo and give it functionality more like BASIC. I'd wanted to try that since I was a kid.

# this demo is public domain
c = 0
textmode
for radius 1, 200, .157
    x = 320
    y = 240
    for b -3.14, 3.14, .314
        d = c plus .157 | swap d, c
        xc   = b plus c | cos
        yc   = b plus c | sin
        col  = xc   times radius plus x
        row  = yc   times radius plus y
        colr = b    times 3  mod 2   | int | times 11 plus 4
        col2 = col  divby 8  int     | plus 34
        row2 = row  divby 16 minus 2 | int | plus 1
        xx   = col2 minus 1
        x2   = col2 minus 0
        z      pset xx, row2, colr
        now  = xx plus 1 swap now, xx
        z      pset xx, row2, colr
        next
    next

The only syntax that is mandatory is "quotes for strings" and # hashes for comments. You can use some (not any) punctuation optionally, including | and , and ; and : -- if someone was familiar with BASIC you might choose : though if you were teaching this as a gateway to shell coding, you might use | or ; sometimes.