Welcome to the official (and likely only) 3code programming language page!
3code came about as I pondered over some of the reasons that software tends to be hard build and understand. A theory I came up with was that perhaps one factor that contributes to the complexity of software is the nearly infinite number of options available to a programmer at any time. For instance, there are usually countless ways to implement a given functionality. Some ways are better than others, but the fact remains that the programmer has an almost limitless supply of resources to use when constructing. This is not true of physical disciplines. To use an example, consider the construction of a house: There are all sorts of constraints that control the final shape of the house. The most obvious one is money. The budget will limit how much can be spent on materials and labor. This, in turn, places limits on the types of materials that can be used. A reasonable option might be wood. That in turn will put limits on the styles of construction. The list goes on and on.. Eventually, after settling each style and material constraint, the shape of the entire building sort of emerges from those decisions.
With 3code, I decided to take one of the more limitless aspects of most programming languages and place a restriction on it. In 3code, you may only have three local variables and three global variables. Those are the fundamental limitations in the language. Originally I had also planned on limiting the number of function calls per function to three, but I never got around to implementing that limitation. Perhaps I will try it some day. In my very limited tests, I have come to a feeling (not a conclusion) that it may not be necessary to place a function call limitation in the language simply because the local variable limitations and the structure of the language itself sort of forces the idea of small, succinct functions that do one thing and one thing well.
One other aspect of 3code that is notable (I think) is that variable assignment is reversed from what we have generally come to think of as "normal." With most languages, you assign values like this:
variable := 42;2 + 7 = 942 = iThere are only functions, variables, and numbers in 3code. The structure of the language could, I think, easily support other data types such as characters and strings, but I did not get to implementing them. Variables have fixed predefined names.
The current implementation of 3code is far from complete, however it has been sitting on my hard drive for quite awhile and I decided it was time to post it to the web so that I could get it out there. Perhaps it will inspire someone. Hopefully in a good way...
| Reserved Characters | |
| = | assignment |
| [ | start parameter group |
| ] | end parameter group |
| ? | end if statement |
| F | begin function definition |
| Reserved Words | |
| x | global variable 1 |
| y | global variable 2 |
| z | global variable 3 |
| i | local variable 1 |
| j | local variable 2 |
| k | local variable 3 |
| then | used in if/then |
| else | used in if/then/else |
| Currently Built-in Functions | |
| > | greater than |
| < | less than |
| = | equality |
| >= | greater than or equal to |
| <= | less than or equal to |
| + | addition |
| - | subtraction |
| * | multiplication |
| / | division |
| nl | output new line |
| output number | |
| println | output number and new line |
| write | output ASCII character with given value |
3code programs are made up of sequences of statements. In many languages, statements require a separator token of some sort (usually a semicolon). 3code does not require such separators thanks to the structure of the language. With 3code, a single token is a valid statement that executes and the result of that execution in copied into the result buffer. Assignments and function returns are always done using the value in the result buffer. To make this slightly more clear, consider the following perfectly legitimate 3code program:
42=xprintln[x]=y println[y]42=x println[x]=y println[y]Functions are the backbone of 3code. Defining a new function is easy. Here's a sample function that returns the square of the number that is passed into it:
F sq 1 *[i i]println[sq[7]]The final piece of syntax is branching. Every language needs some way to make decisions and usually that manifests itself in the form of if/then/else. In 3code, it takes the following form:
condition then branch1 else branch2?F ! 1 i then *[i ![-[i 1]]] else 1?println[![7]]That covers the basics of 3code as it is now. Looping is done using recursion as is common in functional languages. My current interpreter does not support tail recursion and has issues with hitting stack limits due to how it is implemented. It isn't the best and I have long wanted to rewrite it, but time and motivation have not been forthcoming. Just keep that in mind when playing with large numbers and recursive functions--especially factorial!
| Fibonacci Sequence |
F fib 2 println[i] +[i j]=k j=i k=j fib[i j] |
fib[1 1] |
| Count down from 100 |
F counter 1 i then println[i] counter[-[i 1]]? |
counter[100] |
| Power (for positive powers only) |
F ^ 2 j then *[i ^[i -[j 1]]] else 1? |
println[^[2 8]] |
| Hello, World! |
write[72]write[101]write[108]write[108]write[111]write[44]write[32]
|