☃

☃ is an esoteric programming language devised by User:mroman in 2016. It's a 2D multi-threaded language. Each thread has its own current value and additional data can be stored in the program space (you can think of them as Flip-Flops of some sort).

Instructions

><^v        Change direction accordingly.
/\          Mirrors (they work as in [[Beam]])
+-          Increment/decrement current value
s           If coming from left or right -> read value (current value = value read)
            from top or bottom -> write value (value stored = current value)
p           Display value
f           Fork left (create new thread)
F           Fork downwards (create new thread)
b           Barrier (for sync)
B           Global barrier (for sync)
d           Distribute two (wait for two processes one goes left, other goes right, implicit local barrier for two threads)
?           if current value > 0 branch down
#           if current value < 0 branch up
n           if current value == 0 branch up

Barriers

b is a local barrier. All threads need to reach and wait at the same exact location.

This will halt:

>Fv
 >b

however this will deadlock (because threads are waiting at different local barriers).

>Fb
 >b

However, there is the global barrier B where threads can continue if every thread has reached a global barrier somewhere in program space, thus the following will not deadlock:

>FB
 >B

Examples

This should be a program creating two threads where one continues to display the value while the other continues incrementing it.

>F>>v   <
 >+   v
    > sp^
 ^    <

Open Questions

Is the computational class if restricted to one single thread the same as when it's allowed to use multiple threads? What's the computational class anyway? (There can always be only a finite amount of storages).