figbuzz: a programming language for writing fizzbuzz (requires python 2)

figbuzz is a program written in python– it translates a language called “figbuzz” into python. if this sounds a lot like fig, theres a good reason. figbuzz is a stripped-down fig compiler.

at 955 lines, figbuzz contains all the block functions of fig, plus the commands needed to write fizzbuzz, plus a command called “ismultipleof”. this demo (included in the download) will look familiar to those who know my fizzbuzz program written in fig:

#### license: creative commons cc0 1.0 (public domain)
#### http://creativecommons.org/publicdomain/zero/1.0/
for fb 1 100 1
    while
        ifmultipleof fb 5
            ifmultipleof fb 3
                now "fizzbuzz" print
                break
                fig
            fig
        ifmultipleof fb 5
            now "buzz" print
            break
            fig
        ifmultipleof fb 3
            now "fizz" print
            break
            fig
        now fb print
        break
        wend
    next

 

save the above program as fb.figb (or whatever-you-like.figb) and figbuzz will translate it into whatever-you-like.figb.py

figbuzz is not only an over-the-top fizzbuzz demo, its also a slightly more manageable version of fig to experiment with. everything is there, minus more than 50 of the usual commands.

figbuzz does not do graphics, figbuzz does not do colour. figbuzz does not require libraries, figbuzz only needs python 2.

(fig only needs python 2 in gnu/linux and mac os/x, but in windows it requires colorama.)

here is the source for figbuzz:

#!/usr/bin/env python
# coding: utf-8 
#### license: creative commons cc0 1.0 (public domain) 
#### http://creativecommons.org/publicdomain/zero/1.0/ 
proginf = "figbuzz 0.1, apr 2017 mn"
# a version of fig just for writing fizzbuzz
import sys
import os
from sys import stdin, stdout
from os import popen

buf = []

cmdhelp = [("timer", "input (shared-line) change main variable to number of seconds past midnight")

,("print", "output (shared-line) output main variable to the screen (aka stdout)")
,("prints", "output (shared-line) put main var to screen; like print but (s)tays on line.")
,("while", "loop --\\own\\line mark the start of a loop (will keep going without break)")
,("break", "loop --\\own\\line put in the middle of a loop to exit (stop looping)")
,("for var strt stop step", "loop --\\own\\line start a for loop, changing var from strt to stop, by step")
,("forin var array", "loop --\\own\\line loop through each item in array; for each, set var to item")
,("iftrue ckvar", "conditional --\\own\\line run lines between iftrue and fig if ckvar is \"non-zero\"")
,("ifequal var1 var2", "conditional --\\own\\line run lines between ifequal and fig if var1 equals var2")
,("ifmore var1 var2", "conditional --\\own\\line run lines between ifmore and fig if var1 is > var2")
,("ifless var1 var2", "conditional --\\own\\line run lines between ifless and fig if var1 is < var2")
,("ifmultipleof var1 var2", "conditional --\\own\\line run lines between ifless and fig if var1 is divisible evenly by var2")
,("try", "conditional --\\own\\line put code that might not work between try and except")
,("except", "conditional --\\own\\line if code between try/except fails, run the code after except")
,("resume", "conditional --\\own\\line mark the end of try / except / resume command block")
,("else", "conditional --\\own\\line after if- line, before fig. run lines if condition isnt true")
,("function name p1 p2 ...¦", "function --\\own\\line define function named name with optional params p1,p2, etc")
,("fig/next/nextin/wend", "fig (interchangeable) function --\\own\\line finalise a block (started by if/while/function/for/forin")
,("pass", "function --\\own\\line blocks (for/next, etc) require something inside lines; pass works / does nothing")
,("str", "function (shared-line) convert main variable from number to string")
,("not", "function (shared-line) change main variable to zero if non-zero; or -1 if zero")
,("#", "comment (can\\share) place at beginning (or end) of line, prior to a comment")
,("():;|=,. ( ) : ; | = , .", "optional (shared-line) use in a shared line (and some others) for aesthetics/notation")
,("system", "function (shared-line) put on (usually at the end of) a line to stop the program")
,("end", "function (shared-line) interchangeable with system which ends the program")
,("return var", "function (shared-line) (optional) exit current function, returning value var")
,("swap var1 var2", "function (shared-line) change contents of var1 to contents of var2 and vice-versa")
,("plus numstrarr", "math (shared-line) change main variable to itself plus num or string or arr")
,("minus numeric", "math (shared-line) change main variable to itself minus numeric")
,("divby numeric", "math (shared-line) change main variable to itself divided by numeric")
,("times numeric", "math (shared-line) change main variable to itself times numeric")
,("sgn", "math (shared-line) change main variable to 0 if 0, to -1 if < 0, or 1 if > 0.")
,("int", "math (shared-line) change main variable from decimal (aka \"float\") to integer")
,("mod denominator", "math (shared-line) change main variable to: main var modulus denominator")]

def chelp(f):
    ck = 0 ; print "" 
    for p in cmdhelp:
        rcmd = p[0]
        if f in rcmd.split()[0]:
            ck = 1
            rd = p[1].split()
            rcat = rd[0] ; rd.remove(rd[0])
            rt = rd[0] ; rd.remove(rd[0])

            cde = rcmd.split(" ")
            print "" 
            stdout.write("    " + colour(14,0)+ cde[0])
            cda = cde.remove(cde[0])
            for c in cde:
                stdout.write(" " + colour(0, 7)+ " " + c + " " + colour(7,0)+" ") ; stdout.flush()
            print "" 
            print "" 
            print colour(3,0) + "        category:", rcat, rt.replace("\\", " ") 
            print "" 
            print "        " + colour(7,0) + " ".join(rd) 
            print "" 
        colour(7,0);
    return ck

def outfilewrite(outb, p):
    outb += [p]
    #global vrck 
    #vrck += p.strip()
    #if inle: print colour(5, 0) + p.rstrip() ; p=raw_input() ; quit()

def colour(f, b):
    stdout.write("")
    return ""

def bcolour(b):
    stdout.write("")
    return ""

def sgn(p):
    p = float(p)
    if p > 0: return 1
    if p < 0: return -1
    return 0

def left(p, s):
    return p[:s]

def right(p, s):
    return p[-s:]

def leftfour(p):
    try: 
        if left(p, 4) == chr(32) * 4: p = right(p, len(p) - 4)
    except:
        pass
    return p

def atleast(s, p):
    if p < s: return s
    else: return p

def figfsp(p):
    pp = "" ; flg = 0 
    fsp = figfsplit(p)    
    for fp in enumerate(fsp):
        if flg == 0 and fp[1] in cmds.keys():
            pp += colour(8,0) + "_" + colour(7,0) + " " ; flg = cmds[fp[1]]
            if flg < 0: flg = flg * -1
            else: flg = flg + 1
        pp += fp[1] + " "
        if flg > 0:
            flg -= 1 
            if flg == 0 and fp[0] + 1 < len(fsp):
                pp += colour(8,0) + "_" + colour(7,0) + " "
    return pp.rstrip().replace(colour(8,0) + "_" + colour(7,0) + " " + colour(8,0) + 
    "_" + colour(7,0), colour(8,0) + "__" + colour(7,0)).replace(colour(8,0) + "_" + 
    colour(7,0),colour(8,0) + "__" + colour(7,0))

def figfsplit(p):
    # return p.split() # that was fine when strings weren't tokens
    # we have to make this 3 tokens: variable "hello, world!" #comment not string

    px = [] 
    pxc = -1 # could use len(px) -1 instead?

    inquotes = 0
    remarked = 0
    inspc = "" ; vnspc = ""

    #print "->", p

    for l in p:
        if inquotes == 0 and remarked == 0 and l == "#":
            remarked = 1
            pxc += 1 ; px += [""]
        if remarked == 1:
            px[pxc] += l

        if remarked == 0:
            if l == "\"":
                if inquotes == 0:
                    inquotes = 1 ; pxc += 1 ; px += [""]
                else: inquotes = 0 #; px[pxc] += l
        if inquotes == 1: px[pxc] += l

        if remarked == 0 and inquotes == 0:
            if vnspc not in "1234567890-" + chr(32) and l[0] == ".": l = " "
            vnspc = l
            if l[0] in "():;|=,": l = " "
            if inspc != " " and l == " ": pxc += 1 ; px += [""]
            if l != " ":
                if pxc == -1: pxc += 1 ; px += [""]
                px[pxc] += l.lower() 
            inspc = l
    #print "->", px[:]
    while ('') in px: px.remove('')
    while (':') in px: px.remove(':')
    for p in range(len(px)):
        if px[p][0] != "#":
            if right(px[p], 1) == ":":
                lenpx = len(px[p]) - 1
                if lenpx > 0:
                    px[p] = left(px[p], lenpx)
    return px[:]

def nob(p, s):
    r = ""
    if s == len(p) - 1:
        if len(p):
            if p[s].rstrip() != ".": r = p[s].rstrip()
        if len(r):
            if r[-1:] == ".": r = left(r, len(r) - 1)
    pfig = ""
    try: pfig = left(p[s], 3)
    except: pfig = ""
    if pfig.lower() == "fig" and p[s].lower() != "fig": return "figg"
    try: 
        if r != "": return r
        else: return p[s]
    except: return ""

def snobl(p):
    if "\"" in p: return p
    else: return p.lower()

def snob(p, s):
    r = ""
    if s == len(p) - 1:
        if len(p):
            if p[s].rstrip() != ".": r = p[s].rstrip()
        if len(r):
            if r[-1:] == ".": r = left(r, len(r) - 1)
    pqt = ""
    try: pqt = left(p[s], 3)
    except: pqt = ""
    if pqt.lower() == "fig" and p[s].lower() != "fig": return "figg"
    try: 
        if r != "": return snobl(r)
        else: return snobl(p[s])
    except: return ""

def lnob(p, s):
    r = ""
    if s == len(p) - 1:
        if len(p):
            if p[s].rstrip() != ".": r = p[s].rstrip()
        if len(r):
            if r[-1:] == ".": r = left(r, len(r) - 1)
    pfig = ""
    try: pfig = left(p[s], 3)
    except: pfig = ""
    if pfig.lower() == "fig" and p[s].lower() != "fig": return "figg"
    try: 
        if r != "": return r.lower()
        else: return p[s].lower()
    except: return ""

def getmore(p, s):
    try:
        for t in range(1, s + 1):
            if len(p) == 1: p = []
            p = right(p, len(p) - 1)
        while "" in p: p.remove("")
        for prx in range(len(p)):
            if p[prx][0] == "#":
                p.remove(p[prx])
        return p
    except: return []

def getlmore(p, s):
    try:
        for t in range(1, s + 1):
            if len(p) == 1: p = []
            p = right(p, len(p) - 1)
        while "" in p: p.remove("")
        return p
    except: return []

def lc():
    global linecount
    global flen
    es = " \x1b[0;37;40m"
    return "\x1b[0;37;44m" + right(chr(32) * flen + str(linecount), flen) + es

def wr(p):
    global buf
    buf += [p + "\n"]

colour(11, None) ; print proginf; colour(7, None) ; print

addtoout = [0]
addto = [0]

addtoout[0] = """import sys, os
from sys import stdin, stdout
from os import chdir as figoch
from os import popen as figpo
from os import system as figsh
from os import name as figosname
figsysteme = 0
figfilehandles = {}
figfilecounters = {}
"""

addtoout += [0] ; addto += [0]

addtoout[1] = """from sys import stdout
def fignonz(p, n=None):
    if n==None:
        if p == 0: return 1
    else:
        if p == 0: return n
    return p

def fignot(p):
    if p: return 0
    return -1

figbac = None
figprsbac = None
sub = None
def fignone(p, figbac):
    if p == None: return figbac
    return p
    return -1

\n"""
addtoout += [0] ; addto += [0]

addtoout[2] = ""
addtoout += [0] ; addto += [0]

addtoout[3] = ""

addtoout += [0] ; addto += [0]

# -2: print(variable, etc)
# -1: print(variable), 0: variable = int(variable), 1: variable=left(variable, etc)

cmds = {"str":0,
"prints":-1,"system":-1, "end":-1, 
"print":-1, 
"plus":1, "times":1, "divby":1, "minus":1,  
"int":0, "swap":-3, "return":-2, "mod":1, "not":0, "sgn":0}

funcs = {"function" : -1, "iftrue" : -2, "ifmultipleof" : -3, "ifequal" : -3, "ifless" : -3, 
"ifmore" : -3, "try":0, "except":0, "resume":0, "else":0}

ufunc = {}

#addfuncs = addtoout[0] + addtoout[1] + addtoout[3] + """
addfuncs = """

def figsgn(p):
    p = float(p)
    if p > 0: return 1
    if p < 0: return -1
    return 0

def figstr(p): return str(p)

def figprint(p): print p


def figprints(p): stdout.write(str(p)) ; sys.stdout.flush()

def figint(p): return int(p)

def figplus(p, s): 
    if type(p) in (float, int):
        if type(s) in (float, int):
            p = p + s
        else:
            p = p + s # float(s) if you want it easier
        if p == float(int(p)): p = int(p)
    else:
        if type(p) == str: p = p + s # str(s) if you want it easier
        if type(p) == list: 
            if type(s) == tuple:
                p = p + list(s)
            elif type(s) == list:
                p = p + s[:]
            else:
                p = p + [s]
        if type(p) == tuple: 
            if type(s) == tuple:
                p = tuple(list(p) + list(s))
            elif type(s) == list:
                p = tuple(list(p) + s[:])
            else:
                p = tuple(list(p) + [s])
    return p

def figtimes(p, s):
    if type(p) in (float, int):
        p = p * s # float(s) if you want it easier
        if p == float(int(p)): p = int(p)
    else:
        if type(p) == list:
            p = p[:] * s # figval(s)
        else:
            p = p * s # figval(s) if you want it easer
    return p
def figdivby(p, s):
    p = float(p) / s
    if p == float(int(p)): p = int(p)
    return p
def figminus(p, s): return p - s

def figmod(p, s): 
    return p % s

def figfunction(p, s): return p
def figend(x): quit()

def figsystem(x): quit()
\n"""

demo = """
for fb 1 100 1
    while
        ifmultipleof fb 5
            ifmultipleof fb 3
                now "fizzbuzz" print
                break
                fig
            fig
        ifmultipleof fb 5
            now "buzz" print
            break
            fig
        ifmultipleof fb 3
            now "fizz" print
            break
            fig
        now fb print
        break
        wend
    next
"""

p = ""
try: p = right(sys.argv, 1)[0]
except: pass
if not ".figb" in p.lower():
    if p.lower() == "help":
        stdout.write("\n    type (any) part of the command you want help on." +
        "\n\n    fig will show all matches.\n\n\n    ")
        helpf = chelp(raw_input())
        if not helpf: print(colour(14,0)+"\n    no commands match your search.") ; print("")
        colour(7,0)
    #try: inputfile = stdin.read().replace(chr(13), "").split("\n")
    #except: 
    #print "need an input file to do anything..."; print ; quit()
        quit()
    else:
        print "using built-in demo source, translating to demo.figb.py..." ; print
        p = "demo.figb"
        inputfile = demo.replace(chr(13), "").split("\n")
else:
    try:
        inputfile = open(p).read().replace(chr(13) + chr(10), 
        chr(10)).replace(chr(13), chr(10)).split(chr(10))
    except: print "couldn't open \"" + p + "\", exiting." ; print ; quit()
try: outfile = open(p + ".py", "w")
except: print "couldn't write to \"" + p + ".py" "\", exiting." ; print ; quit()
outname = p + ".py"

flen = len(str(len(inputfile)))

linecount = 0
indent = 0
inlinep = 0
inle = 0
errorin = 0
errorsrc = ""
error = ""
mode = 0
figraphics = -1 # -1 = uninitialised, 0 = textmode, 1 = initialised
vrs = []
vr = ""
outb = []
ingfx = 0
linesoutc = 0

for p in inputfile:
    linecount += 1 ; vrop = 0 ; vrcl = 0

    if linecount == 1: 
        outfile.write("#!/usr/bin/env python" + "\n# encoding: utf-8\n")
        if "," in proginf: 
            outfile.write("# figbuzz translator version: " + proginf.split(",")[0] + "\n")
    if inlinep:
        if p.lower().strip() == "fig":
            inlinep = 0
            print lc() + p
            indent = atleast(0, indent - 4)
        else:
            print lc() + colour(2, None) + p + colour(7, None)
            #% write copied lines of inline python
            outfilewrite(outb, chr(32) * atleast(0, indent - 4) + 
            leftfour(p) + "\n")

    elif mode == "output the following:":
        if p.lower().strip() == "display":
            mode = 0
            print lc() + p
        else:
            wr(chr(32) * atleast(0, indent) + "print \"" + p.replace(chr(34), 
            "\" + chr(34) + \"").replace(chr(92), "\" + chr(92) + \"") + "\"")
            print lc() + p.replace(chr(34), "\" + chr(34) + \"").replace(chr(92), 
            "\" + chr(92) + \"") 

    elif mode == 0:
        x = figfsplit(p.lstrip())
        lp = p.lower()
        if not len(p):
            print lc() + ""
            #% write copied blank lines from inline python
            outfilewrite(outb, "\n")

        if len(p.lstrip()):

            e = 0

            if p.lstrip()[0] == "#":
                if linecount == 1:
                    es = 0
                    try: 
                         if p.lstrip()[1] == "!": es = 1
                    except: es = 0
                    if not es:
                        wr(p)
                        print lc(), figfsp(p)
                    else: print lc() + "[this first comment isn't copied over]"
                    es = 0 
                else:
                    #% write comments
                    #print colour(14, 0) + p + colour(7,0) ; znul = raw_input()  #$ 
                    outfilewrite(outb, chr(32) * atleast(0, indent) + p + "\n")
                    print lc(), figfsp(p)

            elif lnob(x, 0) == "figg":
                 e = 2

            elif lp.rstrip() == "python":
                if 1 == 0:    
                    indent += 4
                    inlinep = 1
                    print lc() + p

            else:
                if not lnob(x, 0) == "figg":
                    if lnob(x, 0) != "fig" and not lnob(x, 
                    0) in cmds.keys() and not lnob(x, 
                    0) in funcs.keys() + ["forin", "for", "function", "nextin",
                    "next", "while", "wend"] + ["break", "pass"]: 
                        if not lnob(x, 0) in vrs: vrs += [lnob(x, 0)[:]] # main vars, also func params, etc
                        #% write variable
                        #var: print colour(14, 0) + "variable:" + lnob(x, 0) + colour(7,0) ; znul = raw_input()  #$
                        outfilewrite(outb, "\n")
                        outfilewrite(outb, chr(32) * atleast(0, indent) + 
                        "figlist = 0\n") 

                        outfilewrite(outb, chr(32) * atleast(0, indent) + 
                        "try: figlist = int(type(" + lnob(x, 0) + ") == list)\n")

                        outfilewrite(outb, chr(32) * atleast(0, indent) + 
                        "except NameError: pass\n")
                        outfilewrite(outb, chr(32) * atleast(0, indent) + 
                        "if not figlist: " + lnob(x, 0) + " = 0 \n")

                    if lnob(x, 0) == "fig":
                        #print lc () + p
                        #% write? its whitespace
                        #$
                        indent = atleast(0, indent - 4) 
                    if lnob(x, 0) == "wend":
                        #print lc () + p
                        #% write? its whitespace
                        #$
                        indent = atleast(0, indent - 4) 
                    if lnob(x, 0) == "next":
                        #print lc () + p
                        #% write? its whitespace
                        #$
                        indent = atleast(0, indent - 4) 
                    if lnob(x, 0) == "nextin":
                        #print lc () + p
                        #% write? its whitespace
                        #$
                        indent = atleast(0, indent - 4) 
                    if lnob(x, 0) == "try":
                        #print lc () + p
                        #% write try line
                        #$
                        outfilewrite(outb, chr(32) * atleast(0, indent) + "try:\n")
                        indent = atleast(0, indent + 4) 
                    if lnob(x, 0) == "else":
                        #print lc () + p
                        #% write else line
                        #$
                        outfilewrite(outb, chr(32) * atleast(0, indent - 4) + 
                        "else:\n")
                    if lnob(x, 0) == "except":
                        #print lc () + p
                        indent = atleast(0, indent - 4) 
                        #% write except line
                        #$
                        outfilewrite(outb, chr(32) * atleast(0, indent) + 
                        "except:\n")
                        indent = atleast(0, indent + 4) 
                    if lnob(x, 0) == "resume":
                        #print lc () + p
                        #% write? its whitespace
                        #$
                        indent = atleast(0, indent - 4) 
                    if lnob(x, 0) == "while":
                        #print lc () + p
                        #% write simple loop
                        #$
                        outfilewrite(outb, chr(32) * atleast(0, indent) + 
                        "while 1:\n")
                        indent += 4 
                    if lnob(x, 0) == "function" and len(getmore(x, 1)) > 0:
                        #print lc () + p
                        mkf = []
                        funcname = getlmore(x, 1)[0]
                        prm = 1
                        while 1:
                            try:
                                aprm = getlmore(x, 1)[prm]
                                if len(aprm): 
                                    if aprm[0] != "#":
                                        mkf += [aprm]
                                        if aprm not in vrs: vrs += [aprm[:]]
                                prm += 1
                            except: break
                        ufunc[funcname] = mkf[:] #; print ufunc # #
                        #print ufunc
                        #print len(ufunc[funcname])
                        #% write func def
                        #$ print colour(14,0)+ "def " +  funcname + "(" + ", ".join(mkf) + "):" + colour(7,0)
                        outfilewrite(outb, chr(32) * atleast(0, indent) + "def " +
                        funcname + "(" + ", ".join(mkf) + "):\n")
                        indent += 4

                    if lnob(x, 0) == "for" and len(getmore(x, 1)) == 4:
                        #print lc () + p
                        gmro = getlmore(x, 1)[0]
                        gmrt = getlmore(x, 1)[1]
                        gmrh = getlmore(x, 1)[2]
                        gmrf = getlmore(x, 1)[3]
                        if gmro not in vrs: vrs += [gmro[:]]
                        if "." not in gmrf and (gmrf.strip()) not in ("0", 
                        "0.0", "-0") and "." not in gmrt and "." not in gmrh: 
                            #% write standard for loop
                            #$
                            outfilewrite(outb, chr(32) * atleast(0, indent) 
                            + "for "
                            + gmro + " in range(int(float(" + gmrt + 
                            ")), int(float(" + gmrh + ")) + figsgn(" + gmrf + 
                            "), fignonz(int(float(" + gmrf + ")))):\n")
                        else:
                            #% write for loop that allows floating step
                            #$
                            outfilewrite(outb, chr(32) * atleast(0, indent) + gmro 
                            + " = float(" + gmrt + ") - float(" + gmrf + ")\n" + 
                            chr(32) * atleast(0, indent) + "while 1:\n" + chr(32) *
                            atleast(0, indent + 4) + gmro + " += float(" + gmrf +
                            ")\n" + chr(32) * atleast(0, indent + 4) + "if " + 
                            gmrf +
                            " > 0 and " + gmro + " > float(" + gmrh + "): break\n" 
                            + chr(32) * atleast(0, indent + 4) + "elif " + gmrf + 
                            " <= 0 and " + gmro + 
                            " < float(" + gmrh + "): break\n")
                        indent += 4

                    if lnob(x, 0) == "forin" and len(getmore(x, 1)) == 2:
                        #print lc () + p
                        gmro = getlmore(x, 1)[0]
                        gmrt = getlmore(x, 1)[1]
                        if gmro not in vrs: vrs += [gmro[:]]
                        #% write forin command with params
                        #$
                        outfilewrite(outb, chr(32) * atleast(0, indent) + "for " +
                        gmro + " in " + gmrt + ":\n")
                        indent += 4

                    if lnob(x, 0) == "break":
                        #print lc () + p
                        #% write break command
                        #$ print
                        outfilewrite(outb, chr(32) * 
                        atleast(0, indent) + "break\n") 

                    if lnob(x, 0) == "pass":
                        #print lc () + p
                        #% write pass command
                        #$ print
                        outfilewrite(outb, chr(32) *
                        atleast(0, indent) + "pass\n") 

                    if lnob(x, 0) == "iftrue":
                        #print lc () + p
                        #% write iftrue
                        #$ print colour(14,0) + "if " +    snob(x, 1) + " > " + snob(x, 2) + ":\n"+ " ; " +colour(7,0)
                        outfilewrite(outb, chr(32) * atleast(0, indent) + "if " + 
                        snob(x, 1) + ":\n") ; indent += 4

                    if lnob(x, 0) == "ifequal" and len(getmore(x, 1)) == 2:
                        #print lc () + p
                        #% write ifequal
                        #$ print colour(14,0) + "if " +    snob(x, 1) + " > " + snob(x, 2) + ":\n"+ " ; " +colour(7,0)
                        outfilewrite(outb, chr(32) * atleast(0, indent) + "if " + 
                        snob(x, 1) + " == " + snob(x, 2) + ":\n") ; indent += 4

                    if lnob(x, 0) == "ifless" and len(getmore(x, 1)) == 2:
                        #print lc () + p
                        #% write ifless
                        #$ print colour(14,0) + "if " +    snob(x, 1) + " > " + snob(x, 2) + ":\n"+ " ; " +colour(7,0)
                        outfilewrite(outb, chr(32) * atleast(0, indent) + "if " +
                        snob(x, 1) + " < " + snob(x, 2) + ":\n") ; indent += 4

                    if lnob(x, 0) == "ifmultipleof" and len(getmore(x, 1)) == 2:
                        #print lc () + p
                        #% write ifless
                        #$ print (colour(14,0) + "if " +    float(snob(x, 1)) + " / " + 
                        #snob(x, 2) + " == int(" +  snob(x, 1) + " / " + snob(x, 2) + "):\n"+ 
                        #" ; " +colour(7,0))
                        outfilewrite(outb, chr(32) * atleast(0, indent) + "if float(" +
                        snob(x, 1) + ") / " + snob(x, 2) + " == int(" + snob(x, 1) + " / " + 
                        snob(x, 2) + "):\n") ; indent += 4

                    if lnob(x, 0) == "ifmore" and len(getmore(x, 1)) == 2:
                        #print lc () + p
                        #% write ifmore
                        #$ print colour(14,0) + "if " +    snob(x, 1) + " > " + snob(x, 2) + ":\n"+ " ; " +colour(7,0)
                        outfilewrite(outb, chr(32) * atleast(0, indent) + "if " + 
                        snob(x, 1) + " > " + snob(x, 2) + ":\n") ; indent += 4

                    if lnob(x, 0) in cmds.keys(): # + ufunc.keys():
                        e = 4 ; shln = lnob(x, 0) 

                    if lnob(x, 0) != "fig" and lnob(x, 
                    0) not in funcs.keys() + ["forin", "for", "function", 
                    "nextin", "next", "while", "wend"] + ["break", "pass"]:

                        #print lc () + p
                        vr = lnob(x, 0)
                        #print vr, type(vr)
                        #print getlmore(x, 1)
                        prsc = 0
                        cstrctr = 0
                        csbuf = []
                        vrcs = ""
                        for prs in getlmore(x, 1):                            
                            #$ print prs 
                            if "fig" in prs:
                                if prs[:3] == "fig": e = 2 ; break ; break
                            if prs in funcs.keys():
                                e = 3 ; shln = prs
                            prsc += 1
                            if cstrctr > 0:
                                vrcs += prs
                                cstrctr -= 1
                                if cstrctr == 0:

                                    if lnob(x, prsc - 1) == "return":
                                        #% write return command
                                        #$ print colour(14,0) +vrcs + " ; " +colour(7,0)
                                        outfilewrite(outb, chr(32) * atleast(0, 
                                        indent) + vrcs)

                                    elif lnob(x, prsc - 2) == "swap":
                                        vrcs = lnob(x, prsc - 1) + ", " + lnob(x,
                                        prsc - 0) + " = " + lnob(x, 
                                        prsc - 0) + ", " + lnob(x, prsc - 1)
                                        #% write swap of 2 vars in python syntax
                                        #$ print colour(14,0) +vrcs + " ; " +colour(7,0)
                                        outfilewrite(outb, chr(32) * atleast(0,
                                        indent) + vrcs + " ; ")
                                    else:

                                        if figprsbac in ufunc.keys():
                                            #% write parametered func call 
                                            #$ print colour(14,0)+  vrcs + ") ; " + lnob(x, 0) + " = fignone(" + lnob(x, 0) + ", figbac) ; " +colour(7,0)
                                            outfilewrite(outb, chr(32) * atleast(0,
                                            indent) + vrcs + ") ; " + lnob(x, 0) +
                                            " = fignone(" + lnob(x, 0) +
                                            ", figbac) ; ") ; vrcl += 1
                                        else:
                                            #% write builtin func call assignment
                                            #$ print colour(14,0)+  vr + " = " +  vrcs + ") ; "  +colour(7,0)
                                            outfilewrite(outb, chr(32) *
                                            atleast(0, indent) + vrcs + ") ; ") ; vrcl += 1
                                else:
                                    vrcs += ", " #; print "*"
                                    #if 
                                continue

                            if prs.lower() in funcs.keys() + ["forin", "for",
                            "function", "nextin", "next", "while", 
                            "wend"] + ["break", "pass"]:
                                e = 3
                            figprsbac = None

                            if cstrctr == 0:
                                if not prs.lower() in vrs:
                                    if prs.lower()[0] in "abcdefghijklmnopqrstuvwxyz":
                                        if not prs.lower() in ufunc.keys():
                                            if not prs.lower() in funcs.keys():
                                                if not prs.lower() in cmds.keys():
                                                    e = 5 ; shln = prs

                            if prs.lower() in vrs and cstrctr == 0: 
                                #and len(getmore(x, 1)) == 1:
                                #% write lefthand variable assignment
                                #$ print colour(14,0)+  vr + " = " + prs.lower()  +colour(7,0)
                                outfilewrite(outb, chr(32) * atleast(0, indent) +
                                vr + " = " + prs.lower() + "\n")

                            if prs[0] == "\"":
                                #% write string assignment (any place in shared line)
                                outfilewrite(outb, chr(32) * atleast(0, indent) +
                                vr + " = " + prs + " ; ")

                            if prs[0] in ".1234567890-":
                                #% write numerics
                                outfilewrite(outb, chr(32) * atleast(0, indent) + 
                                vr + " = " + prs + " ; ")

                            if prs[0] == "#": 
                                #% write trailing comments #$ print colour(14, 0) + prs  + colour(7,0)
                                outfilewrite(outb, prs + "\n") ; break


                            if prs.lower() in ufunc.keys():
                                #% write pre-func-call var backup for sub-style behavior #$ print colour(14, 0) + "figbac = " + lnob(x,0) + " ; " + colour(7,0)
                                outfilewrite(outb, chr(32) * atleast(0, indent) +
                                "figbac = " + lnob(x,0) + " ; " ) # ##
                                figprsbac = prs.lower()	

                                cstrctr = len(ufunc[prs])
                                #print cstrctr
                                if cstrctr == 0:
                                    #% write zero-param func/?sub call
                                    #$ print colour(14, 0) + vr + " = " + prs.lower() + "() ; " + lnob(x, 0) + " = fignone(" + lnob(x, 0) + ", figbac) ; " + colour(7,0)
                                    outfilewrite(outb, chr(32) * 
                                    atleast(0, indent) + 
                                    vr + " = " + prs.lower() + "() ; " + lnob(x, 0) +
                                            " = fignone(" + lnob(x, 0) + ", figbac) ; ") # #
                                else:
                                    #print "y"
                                    vrop += 1
                                    vrcs = vr + " = " + prs.lower() + "(" 
                                    #$ print colour(4, 0) + vr + " = " + prs.lower() + "(" + colour(7,0) #$
                                    #multiparameter  


                            if prs.lower() in cmds.keys():
                                if prs.lower() in ["display", "pset", "line"]: 
                                    ingfx = 1
                                ##print prs	
                                cstrctr = cmds[prs]
                                ##print cstrctr
                                if cstrctr == -1:
                                    #% write zero-param subs
                                    #print colour(14, 0) + "fig" +  prs.lower() + "(" + vr 
                                    #+ ") ; " + colour(7,0) ; #znul = raw_input()  #$
                                    outfilewrite(outb, chr(32) * 
                                    atleast(0, indent) + "fig" + 
                                    prs.lower() + "(" + vr + ") ; " ) ; vrcl += 1

                                if cstrctr == 0:
                                    #% write zero-param functions 
                                    #print colour(14, 0) + vr + " = fig" + prs.lower() 
                                    #+ "(" + vr + ") ; "+ colour(7,0) ; #znul = raw_input()  #$
                                    outfilewrite(outb, chr(32) * atleast(0,
                                    indent) + vr +
                                    " = fig" + prs.lower() + "(" + vr + ") ; " ) ; vrcl += 1

                                if cstrctr < -1:
                                    if prs == "return":

                                        cstrctr = abs(cstrctr) - 1
                                        vrcs = "return " #parameter
                                    else:
                                        cstrctr = abs(cstrctr) - 1
                                        if prs == "swap": vrcs = "swap "
                                        else:
                                            vrop += 1
                                            vrcs = "fig" + prs.lower() + "(" + vr 
                                            vrcs += ", " #multiparameter  
                                else:
                                    vrop += 1
                                    vrcs = vr + " = fig" + prs.lower() + "(" + vr 
                                    vrcs += ", " #multiparameter  

                        if vrop == vrcl and e == 0: 
                            print lc(), figfsp(p)

                        #% finish each line with lf
                        outfilewrite(outb, "\n")
                    else:
                        print lc() + p
                else:
                    e = 2

            if e == 1: 
                e = 0 
                if not len(error):
                    error = "error: problem in command structure or details."
                    errorin = linecount
                    errorsrc = p
                print lc() + colour(14, 0) + str(p) + colour(7, 0)
                break

            if e == 2:
                e = 0
                if not len(error):
                    error = "error: cannot create variable or function beginning"
                    error += " with \"fig\""
                    errorin = linecount
                    errorsrc = p
                print lc() + colour(14, 0) + p + colour(7, 0)
                break

            if e == 3:
                e = 0
                if not len(error):
                    error = "error: single-line command \"" + shln + "\" not on own line"
                    errorin = linecount
                    errorsrc = p
                print lc() + colour(14, 0) + p + colour(7, 0)
                break

            if e == 4:
                e = 0
                if not len(error):
                    error = "error: shared-line function \""
                    error += shln + "\" cannot be used to start a line"
                    errorin = linecount
                    errorsrc = p
                print lc() + colour(14, 0) + p + colour(7, 0)
                break

            if e == 5:
                e = 0
                if not len(error):
                    error = "error: variable or function not created, but referenced... \""
                    error += shln + "\" needs to be set before first use"
                    errorin = linecount
                    errorsrc = p
                print lc() + colour(14, 0) + p + colour(7, 0)
                break

    if vrcl != vrop: 
                e = 0 
                if not len(error):
                    error = "error: a command has the wrong number of parameters."
                    errorin = linecount
                    errorsrc = p
                print lc() + colour(14, 0) + str(p) + colour(7, 0)
                break

if ingfx == 0: addtoout[3] = ""
outfile.write(addtoout[0] + addtoout[1] + addtoout[3] + addfuncs)
for outsb in outb: outfile.write(outsb)
outfile.close()

print
if errorin:
    print error ; colour(14, None) ; print "error in line " + str(errorin) + ":"
    colour(7, None)
    print errorsrc
    #from os import system as stf ; p = stf("touch e")
else:
    try: os.system("chmod +x \"" + outname + "\"")
    except: pass
    colour (11, None) ; print "translation complete. ", ; colour(7, None)
    print "here's a python script you can run: ", 
    print colour(11, None) + outname + colour(7, None)
print

 

there is no perfect language for coding

you can joke that x is “perfect” or that a language is close enough, but theres no such thing.

if i were to pick a perfect language, i would probably single out python. but its not the fastest, i dont like the direction its going in, its not the best language for low-level tasks like writing drivers or an operating system (youd probably want c for that) and its not even the best language for teaching first-time coders, but it does pretty well in that regard.

then theres fig. its designed for teaching, it addresses a number of things that make python less ideal sometimes, its heavily integrated with python (even allows inline python code and translates into python code) but its got tons of design decisions that are for a range of specific uses. i love using fig and i use it all the time, but its good for what its good for– it isnt perfect either.

one of the surest ways to improve (or ruin) a language is to try to make it perfect. people dont know (im not sure they can know) what “perfect” would be, but that doesnt stop them from trying. occasionally, that effort goes well. more often, it seems like they break more than they fix.

this is subjective of course, but thats really the point– the cons are subjective, but so are the pros. and so really no language can be “perfect.” people could never agree what that would even mean, and many notions of perfection are so impractical, they might as well be impossible.

the more elaborate your notion of quality is, the more work it takes to maintain it if you update it. the amount of work that will actually get done depends on the level of resources and interest towards that effort.

this is a highly variable thing, more than people seem to realize. they take for granted that monumental efforts require monumental interest– whether to volunteer time, or spend money, or both. and that level of interest can change any time the nature of the result changes.

some people clearly build large languages on the assumption that there will be substantial interest– at least their own. its difficult to predict the amount of interest even you will have in something in the future. im still very interested in fig, 2 years later. and ive been using python for most of a decade.

but if trends are easy to predict, no one is releasing much data on them– or almost no one is paying much attention to the data. if any language were perfect, the data probably wouldnt be as spread out as it is.

 

 

 

find and zip all .py files with bash

Create a Zip folder including all .py files on your computer.

via Find and Zip All .py Files — Data Science for Engineers

 

not to be obtuse, its a good demo of pythons capabilities; but it didnt take very long to figure out this one-liner to do more or less the same:

echo found $(find . -name '*.py' -print0 | 
xargs -0 zip all-python-source-files.zip -@ | wc -l) 'file(s)'

 

 

coding by voice

although im not certain what date i downloaded it, this video may have partly inspired the quick language experiment “nudity,” which led to fig:

 

the video will start at the 9:00 mark.

nudity was a language designed specifically for coding by voice– kind of like in star trek, except  rather than just google-like queries and construction of routines through ai and description of output (which is probably quite a time-saver,) nudity was meant to have functionality similar to basic.

the name was a reference to how it was “stripped” of all unnecessary punctuation in its syntax. it relied on keywords, introductory phrases, and newlines (stops) instead. i got bored with it very quickly, as i didnt install any kind of voice recognition, and started on a new and related language that used keywords closer to existing basic dialects. this language was originally named “fig basic,” and is now known as simply “fig.”

i never got around to watching the video until yesterday, so i can now recommend the point at 9:00 until about 14:00 or so to get an idea how this guys setup works. hes not just coding in one language, but navigating and controlling his console using emacs and voice recognition software.

personally i think i would hate to write python this way. fig has minimal (required) punctuation but allows you to use the following pretty much as you please:

( ) . , | : ;

# hashes are for comments, and you can have comments to the right of program lines or leading spaces, but you cant do this:

,,,,,,,,,,,,,,,#

# you can do this
now print # and this
##############and this

most other lines can have leading commas or spaces:

for x(1, 100, 1)
,,,,now x prints ” ” prints # valid
,,,,next

indents are not required, parentheses are not required, colons and semicolons and commas are not required. decimals are used in floats:

now 5.5 plus(14).str().left(2) : print

that code results in the same output as:
now = 5.5 : plus 14 : str : left 2 ; )() ; )() ; )() ; print

the language goes left to right (like english, and unlike math generally does) and most punctuation is for visually grouping and categorizing code, rather than actual syntax that changes the literal meaning of the code.

lets eat, grandpa <- unthreatening english
lets eat grandpa <- threatening english
now ask grandpa “when is dinner” <- unambiguous english, and valid fig code

function ask whom what
quotemark 34 chr
now quotemark plus whom plus “, ” plus what plus “?” plus quotemark print
fig

grandpa = “grandpa”
now ask grandpa “when is dinner” # call the “ask” function

output: (including quotes)
“grandpa, when is dinner?”

 

 

for those just joining– a little about my work so far

since around the first years of school, ive been a philosopher, student and programmer. granted my programs up until age 10 were not much, but i was teaching myself with one or two books. i even taught myself how to write programming languages, and i can teach you the same.

in terms of philosophy, i declared myself an atheist at the age of 4. i didnt know the word, i grew up in the bible belt, but i was never pushed to go to church (or reject it, or to be agnostic, or anything.) i loved science, and it simply didnt jibe with this hand-wavey spiritual business (which i would come to accept at least in part, later on.)

at about the age of 4 is when i started using computers as well. its a fact that i was a bright kid. but i could show anyone how its done, explain it in plain terms (to anyone interested) and by the time i was in my 20s i was showing my best friends 7-year-old how to type in basic programs. if you really want to understand, dont just read them– type them in!

unfortunately, basic and programming have gotten a lot more complex. and by “a lot more,” i mean its optional. but unless you know a lot about computer languages, you simply have the whole thing dumped on your lap with no idea how much of it is optional and how much of it you must learn in order to understand the gist of the thing.

enter basic, in 1964.

basic was created in hanover, new hampshire to take the esoteric discipline of computing and make it conceptually accessible to everyone on campus. it was so wildly successful, that by the 1970s it had spread to secondary schools who could access the dartmouth timesharing system (dtss) via teletype, and basic for the altair 8800 was the original product microsoft was created to sell. there are several videos of an altair running basic on youtube:

another computer language from the 1960s to take over the world of education was logo, which is actually a full-featured programming language but you will probably only see it used to move a cartoon turtle around the screen, drawing colorful lines in its path. in some logo-inspired dialects this part of the language could not be easier:

u 40 l 40 d 40 r 40

 

in english: “draw upwards 40 points, draw left 40 points, draw down 40 points, draw right 40 points.”

this creates a square on the screen.

the problem with logo and most of its descendants is that it starts easy and becomes very complicated or esoteric very quickly. or alternatively, it starts out easy and becomes very cumbersome– you may never get past moving a turtle (or cat) around the screen, which makes it difficult to introduce logo to adults.

but in the 80s the way computing was taught to children and adults was to get them into typing itself, then into typing basic programs or exploring with logo. as the 90s gave way to training with applications and using tools online, we stopped exposing students to the very essence of computing. instead of understanding code as the building block of all software, we operated on the idea that showing how to click on magic boxes was like teaching someone to fish. but clicking on magic boxes will teach you nothing about fish, or about fishing; a better metaphor for 90s computer education is “teaching someone how to buy and eat a fish.”

fortunately we are in a new era of single-board computers like the beaglebone, odroid-x, or raspberry pi, and once again students are learning some very familiar lessons. they are using powerful and flexible languages like python and javascript, but ive tried teaching both of these languages and to be honest, they are so complex that unless youre committed to learning them they will not hold your interest.

this is not to disparage python– i coded in basic for 25 years and spent about 5 of them looking for the “basic of the 21st century” and came back from that quest with python itself. (a note to python 2 fans: i am referring specifically to python 2.)

but to share the joy and simplicity of basic, i spent a year working on a new language, which is inspired by basic and logo with a few cues from python, as all of these languages have their own nods to ease and simplicity.

from python it takes lists, which are like basics arrays but they do not restrict each array to “just strings” or “just numerics.” in python and fig, you can mix the two types.

from logo it takes the simplicity of syntax, which rivals basic and python in what you do NOT have to learn. want to create a variable “x” that is equal to 5? here you go:

x 5

 

done!

but wait, you keep hitting equals (or you want to bring back the := for assignment?) voila:

x = 5
x=5
x := 5
x:=5

 

they all work.

for most of history, basic was not case-sensitive. python is. no problem:

X=5
p=x : PRINt

 

it works! and the colon : is optional. as in logo, you can use space, or you can use a semicolon, or a pipe:

X=5
p=x print
p=x ; print
p=x | print

 

the reason for this is that sometimes these syntax elements will provide valuable visual cues. but fig ignores most of them. it still pays attention to quotes:

now "hello, world!" print

 

that sets variable “now” to “hello, world!” and then prints the variable. qbasic has a ucase$ command, and so does fig:

now "hello, world!" ucase print

 

that prints HELLO, WORLD! instead.

fig goes left-to-right, because the last time i showed basic to a friend of mine, she told me “its too much like math.”

well of course it is. but i thought if it was more like english, that might help people learn how to code for the first time. want some more features? fig has about 100 commands. and one of those allows (tada!) inline python code:

function funkyfunky p
now #you have to create it in fig to call it in fig
fig

python
    def funkyfunky(p):
        if p == 3: print "yeah!"
fig

now funkyfunky 3

 

in that example, the python code isnt necessary, just a demonstration:

function funkyfunky p
    ifequal p 3
        now "yeah!" print
        fig
    fig

 

python indentation is great– but i know people that really have trouble with it. fig uses pascal/basic/bash-like commands instead of indentation or braces:

function funkyfunky p
ifequal p 3
now "yeah!" print
fig
fig

 

the “fig” command is like unindenting in python, and also returns from inline python to, well… fig. in many cases you can use basic-like “next” or “wend” for aliases. if you like bash, then “fig” is one letter different than the “fi” command.

this year i wrote a book that pretty much explains the entire fig language, which (like fig itself) is in the public domain.

if you want a nifty live gnu/linux distro that features the fig language, there is fig os, or you can look at this review on distrowatch of the first operating system distro to include the fig language– refracta:

http://distrowatch.com/weekly.php?issue=20161017#refracta

refracta is based on the “devuan” fork of the software they run on the international space station. because i havent found a screencap of fig running in refracta, here is one of it running in devuan:

prs

 

i designed fig as a teaching tool to make it so anyone can learn to code. if you didnt learn fig, i would recommend python, or javascript. each one has its advantages, but i designed fig to make it easier to learn a language more or less in its entirety. that was possible with basic in the 80s, and is now possible with fig today.

i use fig to teach programming, but i would like to do that more often. i would also like to teach people how to create their own programming language.

the hardest part of creating a programming language is writing a program that can parse code. figs left-to-right parser demonstrates how a useful language can be parsed fairly easily. if fig were more strict and required syntax between commands, it could be parsed even more easily.

i have tried to create a recursive parser (the kind that makes a language “too much like math” in my friends words) on a few occasions, and i know its something trivial that im not doing, because ive seen them work.

you dont ever have to write your own parser to create your own language. certainly it can be fun and rewarding, but whether you modify an existing parser or use a parser generator, not every language has its own parser– you can find tools for creating them in c, javascript, python and even php.

why more languages? so we can get closer to making languages that truly anyone can learn. basic, logo and fig are really good for that, in my opinion. python isnt bad for it. fig is the most ambitious language project ive ever worked on, but i wouldnt mind participating in the design of another one.

because its written in python, fig runs on most gnu/linux distros, windows, mac os/x, android, bsd, and some other operating systems that are capable of running python.

 

 

migrating from python 3 to 2

i just blogged about switching back to python 2 for development, and then today someone posted to their blog about python 2 to 3 migration.

so the following is partly tongue-in-cheek, but i thought i might post a little guide for anyone migrating to python 2: some of the pros and cons, and answer a few questions.

first of all: is it difficult?

i dont recommend migrating all of your projects from python 3 to 2. although it should be pretty easy, this is a theory vs. practice thing, and it probably isnt worth time migrating existing projects until there is a real need. (i would say the same for migrating in the other direction.)

for the most part, let need (and convenience) rather than hype or peer pressure be your guide here. you might try doing your next project with python 2 instead of 3, and see if it makes your project easier.

if so, you may find (as a former nokia developer i knew did) that theres no reason to forsake python 2 for 3– but ymmv. certainly python 3 wouldnt be here if it were useless to everyone. the push to standardize however, has shown (in my opinion) that python 3 is overrated, and its usefulness overestimated.

how is the library support for python 2?

library support will be mixed, as a number of libraries have moved to support python 3. the advice here would be to treat the two versions like different languages– if you need a library that is only supported by python 3, then you have the choice of a different library (where possible) or to use python 3.

which libraries will continue to be supported in python 2? perhaps a good guess would be the ones that are already supported in pypy– more about that later.

what is coding in python 2 like, vs. 3?

of course it depends on your goals. python 2 is supposed to have inferior support for unicode; hence the push in python3 to standardize on it. but not everything in computing is actually unicode; whether you use 2 or 3, there are conversions back and forth. personally, i find the conversions in python 2 less brittle, and the ones in python 3 more verbose, tedious and less predictable.

to sweeten the deal, you dont have to put parentheses in the print statement:

print “hello world– pretty cool, huh?”

if only theyd thought of that back in the days of python 3, eh?

of course you will hear stories from both camps– 3 is so much easier for unicode, or 2 is so much easier for strings– it should be obvious which camp im in. give python 2 a try, and if it doesnt feel like everything just got a lot easier, dont migrate! use what works for you.

isnt the python foundation dropping support for python 2?

yes, they are. in fact they were going to drop it last year! but they extended it to 2020. after that, you will have to use an unsupported interpreter or switch to pypy. pypy is an alternative implementation of the python interpreter– you should be able to run many of your existing python 2 programs with zero modifications.

library support for pypy is not exactly as broad as it is for python 2. for example: my own python project– fig– uses pygame optionally, but i have not succeeded in getting pygame to work in pypy. im told its possible, and ive tried. tips are welcome. ive used pygame in both python 2 and 3. python 3 support for pygame is pretty much “build it yourself,” if youre using debian/devuan stable. (and ive built it in devuan.)

how do i do float division?

this is one thing that python 3 definitely got right– 3/7 is .43857, not 0. the trick to make float division work in python 2, is to explicitly make either the numerator or denominator a float:

x = 3/7 # gives 0

x = float(3)/7 # gives .43857142857142855

x = 3/float(7) # gives the same as float(3)/7

it also works with variables on the right side.

how do i print on the same line without a space added after it?

there are probably multiple ways to do this, i prefer sys.stdout:

from sys import stdout

stdout.write(“hello”) ; stdout.flush()

the chr() command wont do codes over 255; how do i do unicode?

you can use unichr instead, or even overload the chr() command:

def chr(p): return unichr(p)

# you can also use unicode strings:

print u”\u2588″

more tips are available as “python 2 to 3” migration guides; to some degree they work in both directions.