minuses of the Bicicleta design

[Kragen Javier Sitaker]

Considered as a programming language, Bicicleta has some drawbacks.

1. It tends to err silently.  If you use it in the way I expect people
   normally will, with every argument to every function having a
   sensible default, the consequence is that forgetting or misspelling
   the argument in the function call will produce a wrong result
   rather than an error message.  And, by design, there's no way to
   detect and complain about extra arguments --- for example, if you
   misspell the argument name.

   You can reduce the first part of this problem by overriding all the
   arguments with errors in the public version of a function, or
   deleting them entirely from the definition, but I expect this to be
   uncommon.

2. There's no way to override the behavior on derivation.  "No way to
   detect extra arguments" is a special case of this.

3. There's no multiple inheritance.

4. There's no static typing.

5. Class hierarchies are likely to be relatively deep.  This has been
   an obstacle to understanding in other languages in the past, such
   as Smalltalk, but I am hoping that Bicicleta's user interface
   improvements will compensate.

6. You can define new methods on objects inherited from existing
   classes, and you can evaluate code in a context where it will use
   your modified objects instead of the basic ones, but it might be to
   add new methods to standard library objects, just as in Java or
   Python.

I expect that these drawbacks will be less important than its advantages.