Pretty simple. It doesn’t even look pathological! Let’s try a bit harder…<\/p>\n
\n#Prints \"Hello World!\"\n33>o<100 108>o<114 111>o<87 32>o<111 108>o<108 101>o<72\n<\/pre>\n Now, that’s more like it. Work it out, and you’ll see it’s pushing the characters
\nof “Hello world!” onto the o stack in the correct order.<\/p>\n
Let’s get a bit harder, and look at the fibonacci series.<\/p>\n
\n24>n\n0>t\n1>a\n# push fibonacci numbers onto stack t\n(n-1\na+0\nt<a>b+a\nc<b>a<c\nn?\n)\n# output numbers:\n(t>@\n(@>o)\n32>o\n)\n<\/pre>\n It’s actually amazingly clear. “n” used as a loop counter. Each iteration through the loop, it pushes the last fib number onto the “t” stack; then it does an add and swap, so that “a” and “b” contain the next pair of fibonacci numbers; and then it checks if the loop index is zero – if it is, it empties the stack, ending the loop. Then it outputs the numbers on t, with spaces between them.<\/p>\n
Getting slightly trickier, here’s a program that squares a number taken from
\nthe input. The reason for trickiness is that it needs to do multiple nested loops to be able to do the multiplication.<\/p>\n
\n#Reads a number from input, and squares it.\n#by Jannis Harder\n1>j\n0>n\n(i>s-10\ns?\n(s-22 s?\n(s-16\nj+0\ns+0\nj>t\n0>u\n(t-1 u+s+0 t?)\nn+u\n10>t\n0>u\nj+0\n(t-1 u+j+0 t?)\n0>j?\nu>j\n0>s?)\n)\n)\nn+0 a<n>b+0\n0>u\n(a-1 u+b+0 a?)\nu>@ 10>o (@>o)\n<\/pre>\n And finally, as usually for pathological languages, the proof that it’s really Turing complete is a Brainfuck interpreter. It’s actually quite a nice piece of code – easier to understand than the squaring program above!<\/p>\n
\n# Brainfuck interpreter. Input is separated from the source with\n# an ! character. Cell size is 8 bits.\n#\n# Brainfuck example:\n#\n# >,[>,]<[.<]!Hello.\n#\n# This program (the part before the !) will output it's input\n# (the part after the !) in reverse\n(i>a)\n1>x\n# Loop that reads the source code into t, ignoring invalid\n# characters, until an ! is encountered:\n(x #while(!x.empty())\n0>b\na-43 a>z? 0>y (z y? 0>z?) (y? a>t b?) #if a.peek()=='+' t.push(a.pop())\na-44 a>z? 0>y (z y? 0>z?) (y? a>t b?)\na-45 a>z? 0>y (z y? 0>z?) (y? a>t b?)\na-46 a>z? 0>y (z y? 0>z?) (y? a>t b?)\na-60 a>z? 0>y (z y? 0>z?) (y? a>t b?)\na-62 a>z? 0>y (z y? 0>z?) (y? a>t b?)\na-91 a>z? 0>y (z y? 0>z?) (y? a>t b?)\na-93 a>z? 0>y (z y? 0>z?) (y? a>t b?)\n(b a>z b?) # discard characters that aren't Brainfuck operators\n# if current character is ! then stop\na-33 a>x? x>y?\n(y\na+0\na>x?\n0>y?\n)\n#Move the source code to s\n(t>s)\na>z # discard the ! character\n(a>b) (b>i) # move the input to i\n(s\n0>z? #empty z\n# +\ns-43\ns>x? 0>y (x y? 0>x?)\n(y?\nd>z+1\nz-256 z? z>q #emulate 8 bit cells\nz>d\n)\n# -\ns-45\ns>x? 0>y (x y? 0>x?)\n(y?\nd>z+0\nz>q? 0>r (q r? 0>q? z-1)\n(r z+255 r?) #emulate 8 bit cells\nz>d\n)\n# ,\ns-44\ns>x? 0>y (x y? 0>x?)\n(y? d>z i>d)\n# .\ns-46\ns>x? 0>y (x y? 0>x?)\n(y? d+0 d>p)\n# <\ns-60\ns>x? 0>y (x y? 0>x?)\n(y? d<e)\n# >\ns-62\ns>x? 0>y (x y? 0>x?)\n(y? d>e)\n# [\ns-91\ns>x? 0>y (x y? 0>x?)\n(y\nd+0 d>m? 0>n (m n? 0>m?)\n(n\n1>b\n(b\ns>t\ns-91 s>x? 0>y (x y? 0>x?) (y? b+1)\ns-93 s>x? 0>y (x y? 0>x?) (y? b-1)\nb?\n)\nn?\n)\ny?\n)\n# ]\ns-93\ns>x? 0>y (x y? 0>x?)\n(y\nd+0 d>n?\n(n\n1>b\n(b\ns<t\ns-91 s>x? 0>y (x y? 0>x?) (y? b-1)\ns-93 s>x? 0>y (x y? 0>x?) (y? b+1)\nb?\n)\n0>n?\n)\ny?\n)\ns>t\n)\n(p>o)\n<\/pre>\n","protected":false},"excerpt":{"rendered":"Insane Stacking Todays pathology is playing with stacks. Lots of lots of stacks. Stacks for data. Stacks for control. Stacks out the wazoo. It’s called Kipple for no particularly good reason that I know of. Kipple happens to be one of the pathological languages that I highly recommend trying to write some programs in. It’s […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2}},"categories":[92],"tags":[],"class_list":["post-311","post","type-post","status-publish","format-standard","hentry","category-pathological-programming"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_shortlink":"https:\/\/wp.me\/p4lzZS-51","jetpack_sharing_enabled":true,"jetpack_likes_enabled":true,"_links":{"self":[{"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/posts\/311","targetHints":{"allow":["GET"]}}],"collection":[{"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/comments?post=311"}],"version-history":[{"count":0,"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/posts\/311\/revisions"}],"wp:attachment":[{"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/media?parent=311"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/categories?post=311"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/tags?post=311"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}