Forem: Thomas Leathers

Constants & Variables: SSTNPL's new Integer Constants

Thomas Leathers — Thu, 16 Apr 2020 20:35:46 +0000

Part 1: SSTNPL Integer background

SSTNPL (A Programming Language for my Balanced Ternary VM: SBTCVM), f has always had integer variables, as they were part of its original design. creating & using integer variables in SSTNPL is easy enough:

#create 3 variables using: decimal, ternary, & a character value.
var bob=@11
var bob2=*+0-
var bob3=:L
#dump the decimal values of each variable to SBTCVM's Terminal
dumpd bob
dumpd bob2
dumpd bob3

Part 2: The Integer Literal Syntax

However, we can also just use SSTNPL's 'literal' syntax, that's supported on most integer input arguments:

#same as above, just using the 'literal' syntax
dumpd @11
dumpd *+0-
dumpd :L

Part 3: The builtin constants

Whats changed in SSTNPL, is the introduction of a special, forth 'literal' syntax: the constant. Currently, SSTNPL has 2 of them builtin:

#$true=1, $false=0
dumpd $true
dumpd $false

Part 4: Use a custom constant to store a module's version number.

while there are still some holes (you can't use constants in var & val statements yet for example), We can use constants to provide static values that when not used, don't use up Memory:

for example, in an SSTNPL module called 'bob':

const version=@15

That way we could write an SSTNPL program like this:

#print version of bob module
prline Bob version:
dumpd $b.version

#wait for keystroke, then power-off the VM
keyprompt
stop

include bob as b

Conclusion

While SSTNPL & SBTCVM are still technically in alpha, and aren't that useful for practical purposes, I've put a lot of work into both, & hope others find programming a Balanced Ternary VM as interesting as I do.

SBTCVM Gen2-9 On github: https://github.com/SBTCVM/SBTCVM-Gen2-9
SSTNPL Language docs: https://github.com/SBTCVM/SBTCVM-Gen2-9/tree/master/textdocs/SSTNPL

SSTNPL v0.3: Modules & command prompts.

Thomas Leathers — Wed, 20 Feb 2019 05:35:23 +0000

Overview:

Some of you may have seen my tutorials on SSTNPL in the past, but considering how much has been added since then, i figure id post about some of its latest features.

This post will refrence this SSTNPL source file

simple, yet endlessly helpful.

One of the first things you might notice if you scroll down past the comments, is the code indenting. similar to languages like C, it means nothing, but is there to help make code more readable.

command prompts ahoy!

The linked SSTNPL soruce code actually creates basic Command line shell. now, part of this involves the new module system, and a module called comprompt. but all the latter does is take user input and pass it into an SSTNPL table (2D array, note that SSTNPL has no normal 1D arrays).

gsub cp.getentry

The actual syntax checking is done via the tabstrc operations that start at line 57. all it does is checks if the given string is at the given location, in the given table. notice the table name starts with cp..

tabstrc cp.buffer,@0,@0,help
    set cmdflg
    if cmdflg,@1 =validcom @1
    if cmdflg,@1 gsub help

module system.

if you scroll to the end of the file, you will see a command that looks like such:

include comprompt as cp

Have you ever designed your own language?

Thomas Leathers — Sun, 27 Jan 2019 02:44:10 +0000

Rainbow effect: ternary color spaces and SBTCVM

Thomas Leathers — Sat, 17 Nov 2018 06:03:43 +0000

SBTCVM's pygame frontend and its many colors.

The pygame frontend. It was the oldest interface SBTCVM had aside from a barren terminal, without even a period of curses to be seen. Now, after much work on the common components of SBTCVM gen2-9, pygame makes a return to SBTCVM, with a new frontend. A few new features have made it into SBTCVM via the pygame frontend as well.

SBTCVM, traditionally, had only plain, black & white text coloring. However, it has had graphics of one sort or another for a while, so color is no new addition to it.

With the many changes in SBTCVM's newest revision, comes colored text functionality. While the feature itself is new, it, in-part, uses some research that began before SBTCVM even did.

colortext demo. Shows off 27-color foreground and background colors.

Years ago, before SBTCVM was even a thing, I was working with balanced ternary color palettes, and possible graphics resolutions, and so forth. namely:

1-trit Greyscale (3 shades)
2-trit Greyscale (9 shades)
3-trit Greyscale (27 shades)
3-trit RGB (27 colors)
6-trit RGB (729 colors) [later on]
9-trit RGB (19683 colors) [later on]

These 3 Balanced Ternary color spaces were interesting to work with ascetically, and are the reason even SBTCVM's predecessor, TDA-Mark1, had color support, in the form of a crude 729-color, 27x27 pixel vector plotter, and a smaller monochromatic, 9x9 vector plotter.

While those plotters no longer exist in SBTCVM Gen 2-9, a new 243x243, 19683 color (9-trit RGB), vector plotter has appeared, in the form of SBTGA mode 30.

colorpack demo. Shows off a 3-trit RGB color-block encoding scheme.

The new pygame frontend's TTY has both a 3-color indexed and a 27-color RGB color-block encoding scheme. (mainly to save memory, and ease coding.)

Some observations on ternary colors

While SBTCVM may have had colors for a while, as far as I've seen, its the only balanced ternary computer, virtual or not, to really tackle the problem. One odd thing is 0 is never black in linear RGB and monochrome palettes. the lowest negative value is. while the highest positive value is always white.

Compared to binary, balanced ternary color palettes balloon in size quite quickly:

No. of Units	ternary colors	binary colors
1	3	2
2	9	4
3	27	8
4	81	16
6	729	64
8	6561	256
9	19683	512

Units, refers to the equivalent bits/trits measurements of binary & balanced ternary respectively.

Overall, I've learned quite a few things about balanced ternary since starting SBTCVM, and even learned some things before that. As well, all this new color text and graphics should make SBTCVM a bit more interesting at least.

To use the new pygame frontend, just run:

./pyg_sbtcvm.py

SBTCVM's SSTNPL, Part 3: iterators

Thomas Leathers — Mon, 22 Oct 2018 19:07:23 +0000

Welcome back to part 3 of my tutorial series on SSTNPL, a programming language for the 9-trit balanced ternary Virtual machine known as SBTCVM. In part 1, we discussed basic menus and did some basic variable setting. While in part 2 we looked at SSTNPL's 2D, array-like table system.

In this part, we will take a look at SSTNPL's iterators and how to use them to iterate over tables.

Getting Started

like before, copy the tutorial_example_3.stnp file into your VMUSER directory located where you installed SBTCVM.

basic iterators

the basic iterators come in 2 variants, each with 4 arguments:

itval: a variable name to be newly created. use this to get iterator 'state'
sub: a subroutine label. You need to put the code you want to iterate with in a subroutine, and specify it here.
start: The starting value of the iteration. Can be variable or literal
end: The ending value of the iteration. Can be variable or literal

uiter itval,sub,start,end
diter itval,sub,start,end

So what does uiter and diter do? Well, uiter iterates Up from start to end, while diter iterates Down from start to end

double iterators

Double iterators, are just that, 2 iterators in 1. For the sake of this tutorial, we'll call them the X iterator and the Y iterator. Whats the point of double iterators? Well, you will see later in this tutorial.
the double iterators also come in 2 variants, however, they have 7 arguments:

u2iter itvalx,itvaly,sub,startx,endx,starty,endy
d2iter itvalx,itvaly,sub,startx,endx,starty,endy

itvalx: a variable name to be newly created. Use this to get the X iterator state.
itvaly: a variable name to be newly created. Use this to get the Y iterator state.
sub: a subroutine label. You need to put the code you want to iterate with in a subroutine, and specify it here.
startx: starting value of the X iterator. Can be variable or literal
starty: starting value of the Y iterator. Can be variable or literal
endx: ending value of the X iterator. Can be variable or literal
endy: ending value of the Y iterator. Can be variable or literal

u2iter counts from startx UP TO endx for each number of starty UP TO endy
and needs both ENDs to be GREATER than their respective STARTs

d2iter counts from startx DOWN TO endx for each number of starty DOWN TO endy and needs both ENDs to be LESS than their respective STARTs

Basically u2iter and d2iter run the X iterator for each iteration of the Y iterator.

iterating over rows

Now that we know how to use SSTNPL's iterators in general, lets look how they apply to tables. For starters, lets iterate over the first row of our table 'sam'.

All we really need to do, is iterate over the X position argument of tabr, while having the y position argument pointing to the desired row.

uiter itval,getat1,@0,@2

label getat1
tabr sam,itval,@0
set cb
chardump cb
return

remember: table X and Y indexes start at 0, so our iterator range is 0-2

iterating over columns

Exactly the same as rows, but we iterate over the Y position argument of tabr while the X position argument points to the desired column.

uiter itval,getat1B,@0,@2
#
label getat1B
tabr sam,@0,itval
set cb
chardump cb
return

iterating over the whole thing

You see where this is going, don't you? Yes, all we need to do to iterate over the whole table is iterate over both the X and Y position arguments of tabr

u2iter itvalx,itvaly,getat2,@0,@2,@0,@2
#
label getat2
tabr sam,itvalx,itvaly
set cb
chardump cb
return

Simple eh? oh, and if you want to iterate over arbitrary sections of the table, say just columns 2 and 3:

u2iter itvalx,itvaly,getat2,@1,@2,@0,@2
#
label getat2
tabr sam,itvalx,itvaly
set cb
chardump cb
return

Now do you see the point of the double iterators? i sure hope so.

Compiling & running

just as in part 1:

compile: ./stnpcom.py tutorial_example_3

run: /SBTCVM_G2_9.py tutorial_example_3

Conclusion

Well, i hope you found these 3 tutorials helpful and informative. Just don't be surprised to see more SSTNPL tutorials in the future, as SSTNPL gains more features.

Whats the most obscure open source project you've worked on?

Thomas Leathers — Fri, 19 Oct 2018 23:57:45 +0000

SBTCVM's SSTNPL Part 2: cards on the table

Thomas Leathers — Fri, 19 Oct 2018 01:34:46 +0000

Welcome back to part 2 of my tutorial series on SSTNPL, a programming language for the 9-trit balanced ternary Virtual machine known as SBTCVM. In part 1, we discussed basic menus and did some basic variable setting.

In this part, we will take a look at how to work with SSTNPL's tables, and look at how they can be quite useful.

Getting started

like before, copy the tutorial_example_2.stnp file into your VMUSER directory located where you installed SBTCVM.

Now, you may be asking, whats a table in SSTNPL? to put it simply a table is a 2D array of 'cells' that can be accessed via x and y coordinates.

the 3 table types:

self-printing single-cell (name in example: sam, labeled: 'prline-based')
basic single-cell (name in example: sam2, labeled: 'tstr-based')
double-cell (name in example: bob, labeled: 'Double-cell table')

you will see at the top, both single-cell types are within subroutines, but only the self-printing table actually prints itself, while the other doesn't do much of anything.

table structure:

table name,[width],[height]
tstr abcx
tdat @1;@2;@3;@4
prline ABC

Note that self-printing tables need to be specified as 1 column wider than they appear, due to prline always appending a newline. (That's why they print correctly formatted.) (notice that prline has 3 characters visible, while tstr and tdat have 4 values shown.)

All three of these are technically the same type, and aside from the double-cell tables having an extra value in each cell, there's not much difference.

Reading and writing tables:

looking at the section commented with the same name, we see tabr, tabw and tabcd all referencing our self-printing single-cell table 'sam', and making liberal use of decimal and character literals, of which part 1 discusses in more detail.

tabr, tabdd, and tabcd's arguments:

tabr table,x,y
tabcd table,x,y
tabdd table,x,y

looking at the code, we see 0,0 is our x,y location, and that the coordinates start at 0,0. tabr is a basic read operation, while tabdd and tabcd print the read value as decimal or a character respectively, but still provide the value to our old friend set.

tabw's arguments are similar:

tabw table,x,y,value

the only difference is value, yet another variable, that contains the value we wish to write to the given table coordinates. or we could just throw a literal at it and call it a day.

working with double-cell tables:

As we delve into our third and final table type, i must first explain the warning at the top of the associated code section: the second value is stored in the instruction word, that means, anything put there can cause any opcodes that happen to match to be triggered, if the CPU tries to execute it.

The table itself, bob, uses tdat, which has 2 modes:

singe-cell mode:

tdat @1;@2;@3

double-cell mode:

tdat @1 :a;@2 :b;@3 :c

A few things to note here:

Do not place semicolons at either end!
DO NOT try to use integer variables. the tables are statically compiled, and REQUIRE use of any of the 3 literal types (decimal, ternary, and character).
the left value in tdat double-cell mode is accessed using the methods below, while the right value is accessed like in any of the other table types.

reading the extra value.

as you might deduce, reading the extra value is as simple as suffixing the tab* operations with '2':

tabr2 table,x,y
tabw2 table,x,y,value
tabcd2 table,x,y

As you can see, syntax is identical, and its fairly simple to actually use.

Compiling & running

just as in part 1:

compile: ./stnpcom.py tutorial_example_2

run: /SBTCVM_G2_9.py tutorial_example_2

so how are tables useful in SSTNPL? How did they come about?

Well, the whole table system was inspired by the data lookup algorithm of a prototype of a maze engine i wrote in SSTNPL (that actually works by the way), and so far has gone on to power a card-matching game.

As far as what could be done with them, that's a question only time, and a bit of experimentation, will really answer.

Where can i read more?

well you can find SSTNPL's full documentation here

Whats next?

In part 3, we will look at how SSTNPL's single and double iterators work, and how they can be used to iterate over tables, and even help populate them.

SBTCVM's SSTNPL, Part 1: basics

Thomas Leathers — Sat, 13 Oct 2018 19:34:10 +0000

SBTCVM, being as different to binary as any balanced ternary computer, virtual or not, has plenty of differences that keep existing languages from it (without a shipload of work that is)

In light of this, i wound up creating a second programming language for it, called SSTNPL, or SBTCVM Simplified Ternary Numeric Programming Language. This is the beginning of a series of tutorials on its use, and best practices when working with it.

In part 1, we will take a look at using the 'keyprompt' command in two types of menus, to create a simple program that lets a user change a boolean value.

getting started

First thing you'll need is SBTCVM gen 2-9, SBTCVM's latest and greatest iteration, featuring among other things, SSTNPL's compiler.

Once you have that, you can proceed with creating a *.stnp file in the VMUSER directory. (note: if you prefix the .stnp with 'auto_' you can also place it in a subdirectory there)

For this tutorial however, i recommend downloading the example program from the gist embedded in the following section, and placing the *.stnp in VMUSER.

The code

To make things easier, i marked each section clearly with comments #### LIKE THIS ####

Vars

First off, lets look at the VARS section. as SSTNPL is fairly static, we need to let it know what variables we will be using. We do this with the var statement:

var varname=@10
var varname2=+0-
var varname3=:a

The first example uses signed decimal, via the @ prefix.
The second is plain balanced ternary.
The third uses the given character's code value in SBTCVM's text encoding. This means integer variables can act as 'characters' as well.

Main

Now, lets take a look at MAIN.

first, we see a label. This lets us use both goto and gsub (subroutine goto) to jump to that location.

Following that we see some text output code:

print: prints raw text
prline: prints raw text, but appends a newline
newline: prints a newline character
dumpd: dumps the specified variable in signed decimal as this is used to print our boolean value (called value)

Keyprompt and set:

keyprompt Is a input loop macro that waits for the user to press a key, then continues.

set is used to set values returned by several operations to variables.
here, we set the variable kb to the value returned by keyprompt

Conditional subroutine gotos (gsub's):

Its at this point in main that we check kb against literal character values (letters prefixed with a :)

if kb,:q gsub quit If kb is equal to the character code of q, call quit as a subroutine

goto:

as you might guess, we need to loop here. since we have a label at the top of main, we can jump there:

goto main

goto both by itself and in conditionals, does not affect return, while gsub does. This lets you do complex jumps within subroutines, so its important to note.

quit:

On a quick touch, exiting an SSTNPL program is simple enough. just use:
stop
This will neatly shutdown the VM.

number:

This section is similar to main, but its acting as a 'value selection' rather than a 'subroutine selection'

retflg reset:

looking past the label, we see val. This, when used with set can be used to directly change the value of variables. here, we use it to reset a return flag.

subroutine loop:

after a nifty prline message telling the user to press 1 or 0, we then run keyprompt in a loop as before. label number_loop

conditional variable set:

how this 'value selector' works, is it uses pairs of conditional variable sets of both our boolean value variable value and our return flag retflg

if kb,:0 =retflg @1
if kb,:0 =value @0

Ooh what have we here? literal decimal integers, using the @ prefix.
this variable set mode works by setting the variable immediately following the = sign, and using the variable or literal just next to that as the data value to use. so if you had a variable called bob and wanted to set using that:

if kb,:0 =value bob

while we are talking about literals i should mention the ternary literal:

if kb,:0 =value *+0-

same idea as the decimal and character literals, just with a * prefix.

conditional return:

handily, we can conditionally return from subroutines in SSTNPL using conditionals, rather than the usual return command, we do:

if retflg,@1 return

This means it will only return when value has been set via the user either pressing 1 or 0.

loop

As before, we jump to the label we used for the beginning of the loop.
goto number_loop

compiling and running:

easy enough:

compile: ./stnpcom.py tutorial_example

run: ./SBTCVM_G2_9.py tutorial_example

Conclusion:

SSTNPL is fairly low-level, but that doesn't mean it isn't quite useful, if you want to mess around with SBTCVM, and lack good understanding of low level computing.

The takeaway from this, is other than the underlying logic, the overall structure of balanced ternary machines are similar to binary ones, as they both are digital computers and need to be programmed. Hope you found this interesting.

You can find more information on SSTNPL at these links:
SSTNPL documentation
General SSTNPL Guide

pygame, gopherspace, and window managers

Thomas Leathers — Mon, 24 Sep 2018 15:35:17 +0000

Some people may think pygame is mostly useful for games and multimedia, that's not all its useful for. Some people may also think you can't use multiple windows in pygame. While the latter is true, i managed to work around that.

What is gopherspace

First off, I want to give a brief description of what gopherspace actually is.

Way back before the web, in the year 1991, a new protocol emerged onto the internet. Gopher. Rather than being hyper text, or as crude as a FTP directory listing, gopher is kinda in-between.

Gopherspace is really just one big series of menus. No scripts, no more formatting than a plain .txt document, and no CSS. Over the years, gopher slid into obsucurity. However, its still out there, in part to its absurdly simple protocol:

Step 1:

client connects to server.

Step 2:

client sends a 'selector' aka path of the desired document, a tap+query if its a search query, and a CR+LF.:

/some/document[CRLF]
/some/query[tab]some search terms[CRLF]

Step 3:

Client waits for server to send the full document/file selected, or, if an error occurs, usually an error page containing item type '3'

The Menus:

A gopher menu's synax probably couldn't be simpler (literally):
usually the port is 70. The first char of each line defines the item's type.
notice the 'i' type has a 'null' selector field, as its not supposed to be even selectable.

iI'm an information type[tab]null[tab]server[tab]port[CRLF]
1I'm a gopher menu somewhere[tab]/this/is/a/selector/[tab]server[tab]port[CRLF]
0I'm a text document somewhere[tab]/this/is/a/selector/also.txt[tab]server[tab]port[CRLF]
7I'm a text query (or index search) somewhere[tab]/some/search[tab]server[tab]port[CRLF]

a type '3' is returned upon an error of some kind. most commonly a nonexistent selector, which is akin to a 404 error.

There are plenty of other types and things, but that's the basics.

how i got around pygame/sdl's 1-window limit (sort of ;D )

Now to the fun part. how do you run multiple windows, while you only have 1?
a virtual window manager.

ThomasTheSpaceFox / Strazoloid-windowing-framework

Strazoloid is a virtual window manager for pygame applications & games. Useful for creating custom multi-window enviornments. such as with many 2D simulation games.

Strazoloid windowing framework

v1.4.0
a Python/pygame virtual window manager framework.
Copyright (c) 2018-2020 Thomas Leathers and Contributors

Need help? For documentation see the docs directory

Strazoloid windowing framework is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

Strazoloid windowing framework is distributed in the hope that it will be useful but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with Strazoloid windowing framework. If not, see http://www.gnu.org/licenses/.

all images and other media content, unless otherwise noted are licensed under the Creative Commons Attribution-ShareAlike 4.0 International License. To view a…

View on GitHub

I actually had already written the basic structure of strazoloid before working on zoxenpher, but it was greatly improved.

Starting up strazoloidwm is easy enough:

import strazoloidwm as stz
desk=stz.desktop(800, 600, "This is the window title", pumpcall=event_test, resizable=1)
#init Framework
framesc=stz.framescape(desk)
#create new 'framex' object (virtual window)
testframe2=stz.framex(200, 100, "test2", pumpcall=event_test)
#add the frame (window) to our framescape instance.
framesc.add_frame(testframe2)
#hand over main thread to framescape instance, starting the window manager.
framesc.process()

whats event_test you might ask? well:

def event_test(frameobj, data=None):
    #note: you should make sure all non if-statement code is behind if statements. see comments on frame/desktop flags below.
    if frameobj.statflg==1:
        print(frameobj.name + " stat 1: init call")
    elif frameobj.statflg==2:
        print(frameobj.name + " stat 2: post-resize call")
    elif frameobj.statflg==3:
        print(frameobj.name + " stat 3: frame terminate call. type:")
        if frameobj.runflg==0:
            print("   run 0: wm quit call")
            print(frameobj.pid)
            print(frameobj.wo)
        if frameobj.runflg==2:#the desktop class should never set runflg=2
            print("   run 2: frame (window) close call")
            print(frameobj.pid)
            print(frameobj.wo)
    elif frameobj.statflg==4:
        print(frameobj.name + " stat 4: clickdown")
    elif frameobj.statflg==5:
        print(frameobj.name + " stat 5: clickup")
    elif frameobj.statflg==6:
        print(frameobj.name + " stat 6: keydown")
    elif frameobj.statflg==7:
        print(frameobj.name + " stat 7: keyup")
    elif frameobj.statflg==8:
        print(frameobj.name + " stat 8: desktop window resize")
    elif frameobj.statflg==9:
        print(frameobj.name + " stat 9: frame shade")
    elif frameobj.statflg==10:
                print(frameobj.name + " stat 10: frame unshade")

Whats all the statflg checks? well. that's how strazoloidwm lets the program know, what reason frame/desktop object's 'pumpcall' was called. Note that pumpcall can easily be a class instance method.

You can find a full test program here.

Zoxenpher

ThomasTheSpaceFox / Zoxenpher

A python/pygame gopherspace client, in the style of a retro desktop GUI.

Zoxenpher

A python & pygame gopher client.
v3.0.0.indev

libgop gopher library v0.2
strazoloid virtual window manager framework v1.4.0

Zoxenpher is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Zoxenpher is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Zoxenpher. If not, see http://www.gnu.org/licenses/.

all images and other media content, unless otherwise noted,
are licensed under the Creative Commons Attribution-ShareAlike 4.0
International License. To view a copy of this license…

View on GitHub

Combining a custom gopher parser/access library, and some implementation-specific code, and the power of strazoloidwm, zoxenpher Is a neat gopher client sure, i was able to get the basic functionality up and going quite quickly, as much of the grunt work was already handled by strazoloidwm.

Its complete with bookmarks, window-history navigation, images and even sound type support. plus using pygame allowed me to give it a bit of a retro-ish look that fits the protocol quite well i think.

I'm the lead developer of SBTCVM, a FOSS balanced ternary VM project, Ask Me Anything!

Thomas Leathers — Thu, 09 Aug 2018 15:55:43 +0000

Balanced Ternary Fibonacci, in a new language.

Thomas Leathers — Mon, 06 Aug 2018 17:28:48 +0000

Overview:

SBTCVM is a balanced ternary (a variant of ternary that uses a negative digit instead of 2) virtual machine written in python.

Recently, I and the rest of the SBTCVM developers have been hammering away at a new, 6.5Khz, modular, codebase called 'SBTCVM Gen 2'. Its still in alpha, but its definitely making progress, and can already run moderately complex math programs, and print their output to a virtual TTY.

For those of you who saw my previous post on Fibonacci in balanced ternary, you probably already know, SBTCVM's old codebase only had an assembler. Well...

SBTCVM's new SSTNPL (SBTCVM Simplified Ternary Numeric Programming Language)

SO, Whats going on here? well, this is the new, abstracted, primarily-numeric, language, built for SBTCVM gen2, thats not a week old.

basics:

SSTNPL is a language built primarily for mathematics. its driven by a seamless, named-integer-variable system. Its main goal is to abstract the complexities of the Virtual machine enough to provide a nice abstract language for learning Balanced Ternary mathematics, and doing calculations.

var

var = is how we create variables for use & change later. (you must call var for every variable you use, regardless of whether it needs a starting value. Also most operations (other than a val followed by a 'set' statement), only take variable names as arguments.

value can have 2 forms:

prefix the value with '10x' if you wish to use decimal. i.e.
10x-59

otherwise you can use ternary in both +0- and p0n notations.

Result printing:

here we have two strange commands:
dumpd and dumpt

dumpd dumps the specified integer in decimal form
dumpt does the same, but in ternary form.

newline and space are just TTY macros intended for formatting.

end condition:

the conditional goto. you might notice that it takes 3 arguments. 2 operators that are comma-separated, and a label to actually jump to.

there are actually 3 types: if(equals), ifmore, and ifless. (this is no coincidence, as SBTCVM's new CPU also has these 3)

math

add does just what you'd expect. It adds the two specified arguments. But how do we get our result?

thats the job of 'set' in this example, we 'set' num0 to the result of the previous operation.

swap, just switches the values of the two arguments.

And finally we just do 'goto loop' to return to the top of our loop at 'label loop', and then write a small exit routine to jump to in our conditional, and we have a program.

When we build this SSTNPL program into a memory image (.trom) and run it, via the stnpcom.py compiler and SBTCVM gen 2's curses VM frontend, the logged output looks like so:

SBTCVM's new codebase can be found here, and works in both python2 and python3:

SBTCVM / SBTCVM-Gen2-9

SBTCVM is a virtual machine implementation of a balanced ternary (base 3) computer. Features several compiled languages for ternary software development.

SBTCVM Gen2-9

Simple Balanced Ternary Computer Virtual Machine

v2.1.0.alpha

Need Help? See our Getting started guide

SBTCVM Project blog

What is SBTCVM?

Ever wonder what computers other than the boring-old binary would be like? Well, look no further SBTCVM, a python-written VM, simulates the little-known base number called Balanced Ternary!

What is balanced ternary? well, it has "0" and "+1", just like binary, but added into the mix is a "-1"! Yes, this means EVERY number is signed.

Intrigued? Well, as SBTCVM is Free & Open Source Software, and comes with a ready-to-use set of compilers and development tools, Getting started with balanced ternary with SBTCVM, should prove a fun challenge!

Screenshots:

Features:

bundled ternary software. including demos, games and utilities.
4 channel sound chip
6.5Khz, 9-trit CPU
3.25Khz 9-trit Coprocessor
39.388 KiloNonets of system RAM
pygame frontend features color graphics.
multiple specialized programming languages with integrated compilers. (SSTNPL, SBTCVM…

View on GitHub

Ternary, Trytes, and Python: The Story of a VM.

Thomas Leathers — Fri, 29 Dec 2017 23:52:08 +0000

Introduction

SBTCVM, that's Simple Balanced Ternary Computer Virtual Machine, is just that. A virtual machine that uses 3-state logic. but What drove me to write such a program? Well, the story of SBTCVM starts with a rather simple program. SBTCVM would not be possible if it wasn't for a particular python module called libbaltcalc. The origin of it is a Balanced ternary calculator, sure enough called BalTcalc.

How it all Started

It was over a year and a half ago... late may to early June, 2016. I was reading Wikipedia article after Wikipedia article, as sometimes happens to many of us, and happened across Balanced Ternary. A nonstandard variant of Base 3. I don't recall exactly what caught my eye about it, but something did, as in early June i put a balanced ternary calculator on GitHub.

this calculator wasn't much, just simple add, subtract, multiply and integer division, along with 2-way base conversion to decimal. It was only usable in a terminal. It did however, leave me with a library that could work with balanced ternary integers, and convert them to and from decimal, and It is this library that would power the most complex python project i have ever worked on...

Enter the VM:

TDA Mark 1 was no Ternary supercomputer, the D in TDA literally stood for "Demonstration". It featured 4-trit instructions and 6-trit data. It didn't have a lot of the features SBTCVM has today, but what Mark 1 did introduce helped pave the way for SBTCVM. TDA did introduce a text encoding, and what eventually evolved into SBTCVM's assembler.

SBTCVM Mark 1.1 was more of a revival than anything else, but the most important feature It introduced was Full rewritable program memory, as until 1.1, the program memory was treated as ROM.

SBTCVM Mark 2 is the latest in the original branch of SBTCVM, and has been in development for around 10 months, has thousands of lines of code, and even a framebuffered display. It features 6-trit instructions, and 9-trit data, unlike its two predecessors. Mark 2 also marks when SBTCVM became more of a suite of utilities, centered around the VM itself. The assembler is more capable than ever, and while not as flexible as what the next codebase will bring, It is still quite useful in the meantime.

The future:

SBTCVM's next generation codebase is in early development. And while the new codebase has a vastly different design under the hood, It builds on what was learned with the old codebase, while looking towards the future.

What I learned:

Working on the SBTCVM project has taught me some important lessons:

Documentation can be boring, but it is endlessly useful. Even if you designed most of the working of a program, and think you will remember, write it down. It will help both you, others helping you, and the user.

Don't be afraid to try new ideas. Even if you wind up being the only project of its kind on GitHub, don't let that stop you. The best way to get your ideas realized is to get coding!

Don't pretend there is a deadline when there isn't. Taking one's time can really help. You will do much better on your projects if you just take the time to stop, think, and read over your code.

You Never know where a program will take you. Programming is both predicable, and as unpredictable as a random number generator. Often at the same time. Whats most important is to keep working at your ideas, and you might just get there.