A few feral cats in an ALGOL trenchcoat.

Hacker News Top Tools

Summary

POP-2 is a programming language with ALGOL-like syntax and concatenative evaluation, featuring stack-based operations and efficient compilation for systems like Uxn. It includes simple constructs for variables, functions, loops, and I/O, making it suitable for retro-computing environments.

No content available
Original Article
View Cached Full Text

Cached at: 08/30/26, 06:41 AM

# pop2 Source: [https://wiki.xxiivv.com/site/pop2.html](https://wiki.xxiivv.com/site/pop2.html) ## A few feral cats in an ALGOL trenchcoat\. The syntax of**POP\-2**is ALGOL\-like, assignments are in the[infix notation](https://wiki.xxiivv.com/site/notation.html), but the evaluation scheme is[deeply concatenative](https://wiki.xxiivv.com/site/concatenative.html)\. ``` foo := 123; ( In Pascal ) ``` ``` 123 -> foo; ( In POP-2 ) ``` The language has the explicit notion of an operand stack\. Thus, the prior assignment can be written as two separate statements where the first one leaves a value on the stack, and the second, consumes it: ``` 123; -> foo; ``` ![](https://wiki.xxiivv.com/media/refs/uteky_domu.jpg)Typical POP\-2 Programmer![](https://wiki.xxiivv.com/media/refs/pop2.png)### Interpreter The language can easily be compiled for[Uxn](https://wiki.xxiivv.com/site/uxn.html), in fact, the language is so elegant and small that an entire compiler is less than 800 lines and fits within 2\.5kb of memory\. At first glance, the language looks a little like[Pascal](https://wiki.xxiivv.com/site/pascal.html)\. A statement begins with a keyword, followed by expressions, terminated by a semi\-colon\. Evaluation consists of moving through the program leaving values on the stack as needed\. ``` function sum x y; x + y; end sum(5,6) * 2; ``` But it's important to remember that everything is evaluated by a stack machine, a function returning multiple values, is merely leaving them on the stack for the next one to use\. ### Comment The comment statement will block out a length of text until a terminating semi\-colon\. ``` comment This is a comment, these can span multiple lines; ``` ### Vars Variables are allocated inside the vars statement, these can be of any length, by default in a 16\-bit system, a variable is made of two 8\-bit cells\. ``` comment These are 3 variables x, y and z; vars x y z; comment The variable foo is 10 bytes long; vars foo:10; ``` ### If/Then/Elseif/Else/Close At first glance, the language looks awfully unsurprising, but notice how each case pushes a value on the stack instead of returning a value or doing an assignment: ``` vars x; 4 -> x; if x > 4 then 1; elseif x = 4 then 2; else 3; close ``` ``` 2 ``` ### Function/End Functions are declared in the typical ALGOL fashion, recursion leaves the arguments on the stack: ``` function factRec n; if n = 0 then 1; else n * factRec(n-1); close end factRec(5); ``` ### Goto Loops are written with simple[GOTOs](https://wiki.xxiivv.com/site/basic.html), there are no iterators\. ``` comment Loop for 10 times; vars i; loop: if i < 10 then i + 1 -> i, goto loop; close i; ``` ``` 10 ``` ### I/O While the original implementation used the big arrow\(=\>\) without a destination, here the host system of this implementing is[Varvara](https://wiki.xxiivv.com/site/varvara.html)and so it can make use of multiple output destinations\. The[Console port](https://wiki.xxiivv.com/site/varvara.html#console)number\(0x17, 0x18\) to output the[ASCII](https://wiki.xxiivv.com/site/ascii.html)letter "H": ``` 0x48 => 23; Outputs: H ``` ### Arrays A variable can hold a length of cells, each cell is a byte, the absolute position of a reference in memory\(a pointer\) is accessed with the\#prefix\. To store the short`0x0048`in the third and fourth cells of the array: ``` vars array:10 i; 2 -> i; 0x48 -> (#array+i); ``` The curlies can enclose pointer arithmetic and load the value at a location in memory\. The big arrow is sending it to the Console port\. ``` {array+i} => 23; ``` Putting it all together, we can make a string printing function: ``` comment The 23 is a port number in Varvara; function putChar c; c => 23; end function printString s; vars c:1 i; 0 -> i; loop: {s+i} >> 8 -> c; if c then putChar(c), i + 1 -> i, goto loop close end printString("Hello World!\n"); ``` - [Source](https://wiki.xxiivv.com/etc/pop2.tal.txt), Uxntal\. - [Repository](https://git.sr.ht/~rabbits/pop2), Uxntal\. - [A Modest Proposal](https://hitogata.neocities.org/POP-2000), intercatlang\. ![](https://wiki.xxiivv.com/media/refs/neko.png)**incoming:**[oscean](https://wiki.xxiivv.com/site/oscean.html)[2026](https://wiki.xxiivv.com/site/2026.html)

Similar Articles

POP-2000, a lingua-franca POP-2 dialect

Lobsters Hottest

POP-2000 is a new dialect of the POP-2 programming language, designed as a lingua franca for tiny compilers and low-level systems, emphasizing minimal syntax and ease of implementation.

T3X/0 a Minimal Procedural Language

Hacker News Top

T3X/0 is a minimal procedural programming language with a freely available compiler, designed for teaching and portability across systems like Unix, DOS, and CP/M.

AP8L - apl

Lobsters Hottest

AP8L is an APL-inspired programming language embedded inside PICO-8, supporting APL-like functions and basic graphics.

Multistack Concatenative Programming Languages

Lobsters Hottest

An exploration of multistack concatenative programming languages, discussing how auxiliary stacks and dynamic bindings like Factor's namespaces and PostScript's dictionaries can ease data stack management without sacrificing concatenative composition.