Editing Programming Language (section)

=API Versioning=
* API version as a hash of the binary representation of the API?
** Need to deal with non-breaking things. Like changing the order of functions.
* Function definitions and the like could be tracked, and breaking changes to syntax noted automatically.
** Allow adding fields with defaults without api change.
** Allow optional named arguments.
* Implementation stuff is harder (ie we changed the format of the string this function returns but the signature is the same).
** Functions that have no source code changes can be safely ignored.
** Changing the implementation doesn't mean the result is different (ie optimisation).
** Changing the implementation of a function could accidentally change the result (bug). Being told when that happens is handy.
** Allow specifying functions for specific API versions so if you do change the implementation you can keep backwards compatibility.
** How do consumers choose which version (ie specific version they used, or 'latest'?)... Compiled binaries could keep a list of the api version used.
** Unit tests could provide a hint. (ie if this unit test changed...), but doing something like adding an extra test or changing the order doesn't mean the implementation's result is different.
*** Automatic 'quickcheck' when possible? Compiler can implement a unittest with no effort from the programmer and log results. But you won't know when it's possible (ie halting problem, use of globals/statics, side effects, etc...). Maybe just best effort (ie if it didn't finish in 1 second and/or used more than 512kb of ram, kill the test). Don't store the result of tests that returns a lot of stuff. Do store the meta information about killed tests and the number of items returned (or even better a hash of the items returned, pointers would be a pain though...).
*** 'quickbench'? To benchmark performance? Obvious problems of different hardware but could still be useful. Probably not for API versioning