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.
