Comparison between Aardappel and Bicicleta

[Kragen Javier Sitaker]

Aardappel is a very inspiring language that has some important things
in common with Bicicleta:

- Both languages use a simple tree structure.
- There is no fundamental distinction between functions and data
  structures.
- Function arguments have example values.
- Consequently, the program is normally never unrunnable while
  editing, so you can evaluate any subexpression of your program
  in-place.
- Editing normally takes place by dragging bits of the program around
  with your mouse to make references to or copies of them.

But there are some differences:

- I'm not entirely satisfied that I know what Bicicleta's imperative
  side is going to look like.  Aardappel's approach to state (and
  concurrency!) preceded the rest of the language design, and is the
  most interesting part of the language.
- Subexpressions of an Aardappel program are not evaluated
  automatically while it is being edited; you have to ask for an
  expression to be evaluated explicitly.
- Aardappel uses positional parameters for many things; Bicicleta
  generally uses named parameters instead.
- You can't walk through the evaluation of an Aardappel expression
  step by step.
- Aardappel entirely rejects names for variables, while Bicicleta uses
  them extensively.
- Aardappel uses unification in place of conditionals and consequently
  can use eager evaluation; Bicicleta uses lazy evaluation and
  polymorphism in place of conditionals, and does not support
  unification or even pattern-matching.  It's possible that this is a
  mistake on Bicicleta's part.
- In Aardappel, while there isn't a fundamental distinction between
  functions and data structures, it generally isn't possible for a
  single object to be both.  In Bicicleta, it is.  This is less of a
  difference than it sounds like --- if you have an object X that's a
  data structure and you want to use it as a function, in Bicicleta
  you call a method on it, such as X() or X.width or something, and in
  Aardappel you would say value X or width X.  The difference is that
  Bicicleta lets you do this to any object, even one originally
  intended for use as a function.
- Aardappel doesn't have much in the way of separate namespaces.
  Bicicleta has so many namespaces you wouldn't believe it; a two-line
  dumb recursive factorial pogram creates five namespaces.
- Aardappel has an existing implementation that produces good code.