When I was describing my API design adventures in [[TheAPIBook]], I could not realize that many of these problems would not even appear if we had better languages, or systems more suitable for the [[DistributedDevelopment]].

I may be wrong, but I do not know about any language that would support ''modularity''. And here I mean not compilation piece by piece, but also ''modularity in time''. Because that is the kind of modularity that is needed quite often during development of APIs for our libraries.

At one point of time we release a version of a library and distribute it to others by publishing it on the website. Now people unknown to us, distributed all around the world download it and use it. As a result, the amount of applications built on top of such library is increasing, which implies also that the amount of bugs and feature requests is growing too. After a while the time to release new version of the library comes. However what if the first version used to have a class:

<source lang="java">
public abstract class View {
public abstract String getDisplayName();
}
</source>

What if one of the feature requests demands to add an HTML title to each view. Can we change the view class to following form:

<source lang="java">
public abstract class View {
public abstract String getDisplayName();
public abstract String getHTMLTitle();
}
</source>

Indeed, this cannot be done. Existing subclasses of ''View'' would no longer compile, because the change is not source compatible. Also, even if someone links already compiled subclass with the new version of the library, the Java virtual machine will complain and throw some kind of linkage error, as definition of an abstract super class method is missing.

I would love to see a language or system that would fail the compilation whenever I want to modify my already released classes in a style that could prevent some of their users to continue to use them in previously working way. This would be the real ''modularity'', which is ready for changes in time. So far it seems to me that the current languages do not deal with changes in time really well. Just like Andrei described in his [[Blogs:AndreiBadea:EnumsInAPIs|Enums in APIs]] blog, it seems that our languages do not think about the process of API evolution much and include constructs that one needs to avoid to make [[DistributedDevelopment]] possible.

Releasing new version of libraries with modified APIs is really common and our software engineering practices cannot live without it, yet it seems that there is no language in the world that would make this easy and [[Cluelessness|clueless]]. Or am I wrong?


<comments/>