Update: 2015/06/16

  • Split out the web site so that the front page isn't the blog.
  • Decided that I should position the language to better cooperate with C++. This helps adoption both because it gives developers a way to use existing C++ code, and because it lets developers drop down from Anduin to C++ when speed/memory is super important.

Update: 2015/01/25

  • Decided that arrays and hashes will both use square-brackets, which (for overloading) calls a function named op-index.
  • Similarly, decided the other operators will be overloadable: addition with op-add, subtraction with op-subtract, multiplication with op-multiply, and division with op-divide. Note that I'm specifically using the semantic name, not any symbol character name, because I want to avoid a single character having multiple semantics, especially when the behavior is user-defined. Also, since not all of these operations are associative, I'm defining the implementation of "a + b" to be "a.op-add(b)" and never "b.op-add(a)".
  • Removed ability of identifiers to start with a hyphen, because of confusion with negation, pre-decrement, and "-=".
  • Decided on function pointer declaration syntax. For a function foo taking two integers and returning one, declaring a variable pointing to it would look like, "var:func(int,int)->(int) myvar = foo".
  • Added predecrement and preincrement. (There will be no post-decrement or post-increment.)

Update: 2015/01/11

  • Even though scoping is done with "::", object method calls will still be done with ".".
  • I am considering having no precedence between the various math operators, which encourages programmers to parenthesize exactly what they mean.
  • REF parser AST is showing signs of life.

Update: 2015/01/04

  • Decided to revert the assignment operator from ":=" back to "=". That extra colon is aesthetically pleasing but obnoxious for typing.
  • Possibly decided to flip variable declarations from "var id:type" to "var:type id". (Even though the name is still more important than the type, initializations must be last because they are least important. That would leave "var id:type=value", which is terrible. (And also gives us "var id1:type1=value1,id2:type2=value2", allowing variables of different types to be declared together, which is even worse.) The best reshuffling is "var:type id=value". (And thus "var:type id1=value1,id2=value2".)
    • Because of this flip, adding props to variables is now a syntactic mess ("var:type,prop1,prop2 id=value"?), so for now I'm removing them completely.
  • We obviously missed the expected version 1 release date of 2015/01/01. Pushed expected release date back a year. Nothing could possibly go wrong!

Update: 2014/12/28

  • Now require parentheses around the right-hand-side of multi-assignment statements. I reserve the right to revisit this if it interferes with functions returning multiple values.
  • Changed variable assignment during declaration to use ":=", for consistency with normal assignments. I may revisit this too, because now there are two colons in variable declarations and it's visually trecherous. (Four+ colons if the value has a variable with namespace scoping!)
  • Decided on C's math operators: ==, !=, <, <=, >, >=.
  • REF parser handles constants, 'if' blocks, logic and math expressions, and assignment statements.

Update: 2014/12/21

  • Added definition of anonymous enums, mostly for function parameters.
  • Chose "next" and "break" as the loop control keywords (vs. "continue" and "last").
  • Chose a script extension: ".an".
  • REF parser handles limited variable declarations.

Update: 2014/12/14

  • Created a SourceForge project here. We're official!
  • Proof-of-concept/reference ("REF") flex/bison parser handles whitespace and comments.

Update: 2014/12/07

  • Removed the ability to comment out a closing "*/" with a "#".
  • Established that floating-point constants must have at least one digit before and after the period. That is, neither ".3" nor "3." is acceptable.
  • Began a prototype flex/bison implementation of the lexer/parser. Using flex and bison is not the long-term plan (because we need unicode support), but for now I'm using it to start ironing out details and discover testcases.

Update: 2014/11/30

  • Happy Thanksgiving, world! This is a time when we all should reflect on how thankful we are that someone is developing a language that's better than perl, python, and tcl! Also, we should eat pie.

Update: 2014/11/23

  • As much as I hate the redundancy of "new Foo::Foo" when you declare the Foo class in the Foo module, it still tells you (and the interpreter) exactly where to look for the definition. For now I'll retain that redundancy as a known wart.
  • Decided against "++" and "--" operators. Though common, there are pre- and post- versions of each, which gives class writers more things to overload, and they are redundant with "+=" and "-=",
  • Decided against native support of base-8 and base-16 numbers. Instead, there are library functions to translate strings in those bases.

Update: 2014/11/16

  • designed an initial syntax for exceptions.
  • added loop..while, which is like do..while in other languages.
  • World of Warcraft: Warlords of Draenor was released.

Update: 2014/11/09

  • decided that there's no need for C-style typedef..though I'm still on the fence about allowing aliases for generics so that consumers don't have to type out full type signatures all the time.
  • decided that the logical operators will follow C: "&&", "||" and "!", because they are easier to read in code.
  • decided that there will be no built-in operators for bitwise operations. Since bitwise operations are fairly rare, especially in high-level languages, they do not warrant reserved language operators. Instead, we have the built-in functions bit-and, bit-or, bit-not, and bit-xor.
  • possibly decided how enums shall be defined.
  • established that identifiers contain hyphens instead of underscores. The only anticipated problem is that \w and \b in regexes will not work intuitively.
  • established that scoping is done with "::", like in C++. It will not use python's chain of dots.
  • formalized that whitespace does not contain tab characters. Tabs are evil and must die.

Update: 2014/11/02

  • decided that the condition part of both "?:" operators must be enclosed in parentheses as a visual cue.
  • in the absence of any good argument to the contrary, I'm going to allow assignment chaining for now, even for list-assignment.
  • decided that coroutines (=yield=) are probably not a good idea. Saving state is what objects are for, not functions.

Update: 2014/10/26

  • created a living document for the continually updated grammar.
  • decided that condition evaluation shall be limited to boolean expressions, so that integers and strings no longer had an implicit conversion to boolean like they do in most other languages.
  • decided to add a "?:" operator, which is similar to the ternary operator but checks the defined-ness of the condition and reusese its value as the true-case.
      // this:
      foo = (bar) ?: bas   // (Anduin)
      // works like this:
      $foo = (defined $bar) ? $bar : $bas;  // (perl)
      // except that 'bar' is typed out and evaluated only once