- 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.
- Decided that arrays and hashes will both use square-brackets, which
(for overloading) calls a function named
- Similarly, decided the other operators will be overloadable: addition
op-add, subtraction 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
- 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
- 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.
- 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
- 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
- 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!
- 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.
- 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.
- Created a SourceForge project
- Proof-of-concept/reference ("REF") flex/bison parser handles whitespace
- 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
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
- 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.
- 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.
- designed an initial syntax for exceptions.
loop..while, which is like
- World of Warcraft: Warlords of Draenor was released.
- decided that there's no need for C-style
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
- 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
- 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.
- 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.