Sorry for the missed weeks of friday pathological programming language columns. To be honest, I’m running out of languages. I’m sure there must be more, but my usual sources (dealers?) are running out – so send links!
\nAnyway, today I’m going to look at a really simple one, which I find fun. It’s
\nnot an overly exciting language, but it is a language which is has semantics almost as
\ntrivially simple as [BrainFuck][bf], but which ends up looking almost as much like line-noise as [TECO][teco]. It’s called [Betterave][betterave].
\n[betterave]: http:\/\/www.esolangs.org\/wiki\/Betterave
\n[teco]: http:\/\/scienceblogs.com\/goodmath\/2006\/09\/worlds_greatest_pathological_l_1.php
\n[bf]: http:\/\/scienceblogs.com\/goodmath\/2006\/07\/gmbm_friday_pathological_progr.php<\/p>\n
Sorry for the missed weeks of friday pathological programming language columns. To be honest, I’m running out of languages. I’m sure there must be more, but my usual sources (dealers?) are running out – so send links! Anyway, today I’m going to look at a really simple one, which I find fun. It’s not an […]<\/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-448","post","type-post","status-publish","format-standard","hentry","category-pathological-programming"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_shortlink":"https:\/\/wp.me\/p4lzZS-7e","jetpack_sharing_enabled":true,"jetpack_likes_enabled":true,"_links":{"self":[{"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/posts\/448","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=448"}],"version-history":[{"count":0,"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/posts\/448\/revisions"}],"wp:attachment":[{"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/media?parent=448"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/categories?post=448"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/tags?post=448"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
\nBetterave is a very simple language which is based on prefix operators. (The authors calls them functions, but they’re not.) It uses a storage system with 26 variables (one for each letter of the alphabet), and a dictionary of strings indexed by number.
\nThere are 8 kinds of operations in Betterave, and 2 kinds of control flow operators.
\nHere’s the basic list of operators:
\n1. **Literals**:
\n* `0-9` – a single digit in Betterave is a zero-parameter operator that returns
\nthe value of the digit. This is the only way to do numeric literals in betterave;
\nto create a literal like 42, you’d need to use multiple literals and
\narithmetic operators: `*76`.
\n* A literal string written in quotes adds a new string to the dictionary, and
\nreturns the index of the string.
\n2. **Arithmetic**: `+`,`-`,`*`,`\/`,`%` – binary operators that add\/subtract\/multiply\/divide\/modulo
\nthe values of the next two expressions.
\n3. **Comparisons**: `=`, “ – compare the value of the next two expressions,
\nreturning 1 if the first is equal\/less than\/greater than the other.
\n4. **Input**: “`:`” reads a number from the command-line, and returns it; “`;`” inputs
\na string, adds it to the end of the string dictionary, and then returns its index.
\n5. **Output**: “`.`” prints the value of the following expression as a number; “`,`” prints it as
\nan ASCII character.
\n6. **String Operations**:
\n* *String Append*: The string append commands are “`&`” and “`#`”.
\nThey’re both binary operators. Their first parameter is the index of a string
\nto modify, and the second is a number. “`#`” interprets the second parameter
\nas a number, and the string representation of that number is appended to the
\nspecified string; “`&`” interprets the second character as the ASCII code of
\na character, and appends the character to the specified string.
\n* _Delete character_: “” takes one parameter, which is the index of a string
\nto modify. It removes the first character from the string, and then returns
\nthe value of that character.
\n* _Delete string_: “`_`” takes one parameter which is a string index,
\ndeletes that string from the dictionary, and returns the index of the deleted
\nstring. The index of strings after it are modified by this.
\n* *Print string*: “`$`” takes one parameter which is the index of a string in
\nthe dictionary, and prints that string.
\n7. **Variable Operations**: there are 26 variables, a through z. A variable name
\nin uppercase assigns the value of the next expression to the variable; a variable
\nname in lowercase returns the value of the variable.
\nThere are two control flow operators in Betterave: loop, and conditional.
\n* __Loop__: “`[expr1 | expr2]`”: this evaluates expr1; then expr2. If expr2 returns
\na non-zero value, then it repeats. Loops nest like you’d expect.
\n* __Conditional__: “`? expr1 expr2 !`”. Evaluates expr1. If expr1 evaluates to
\nnon-zero, then it evaluates expr2; otherwise, it skips to the expression following
\nthe next “!”. Conditions do not<\/em> nest: on false, it will just skip to the
\nnext “!”, not to a matching<\/em> “!”. So, for example, “`?0 ?=10!.5!.6`” will
\noutput 56: 0 evaluates to zero (false), so it skips to the next “!”, after which
\nit “.5” and then “.6”.
\nSo. First example, as usual, is “Hello World”.
\n$”Hello, World!”
\nPretty simple. A more interesting version:
\n“Hello, World!”A+95[,_0A-a1|a]
\nThis stores the string “Hello, World!” in the string dictionary at index 0, and
\nstores 13 (the number of characters in the string), into variable A. Then it starts a loop. Inside the loop, it removes and outputs the first character of string 0, then subtracts one from A, and repeats the loop if A>0. So it outputs the characters in sequence.
\nHow about a beautifully line-noisy fibonacci series?
\nAB1[.b,*48TbB+abAt|a0].b,*25
\n* Read a number from the keyboard, and store it in A.
\n* Set B (which will store the result) to 1.
\n* Start a loop:
\n* Multiply B by the current value of A
\n* Subtract one from A
\n* Repeat as long as a is greater than 0.
\n* Output B, followed by a carriage return.
\n*(Note: a couple of typos were corrected in this post.)*<\/p>\n","protected":false},"excerpt":{"rendered":"