Let me elaborate.|
When we think about building sw abstractions, it is common to note that the first implementation we build is rarely the most efficient implementation possible. It may be fast enough, but often we need to change the implementation to get better performance. For example, we may need to change the data structures used, or the choice of algorithms.
Still, if the abstraction is good, which means it has a well designed interface, we can change the implementation while keeping the interface stable. This is one of the major benefits of information hiding and data abstraction (another benefit is seperate compilation, by the way).
The simple implementation we designed at first, can be any implementation that supports the specification. Wouldn't it be great if we could arrive at some such implementation, simply by making transformations on the (algebraic) specification?
Of course, it would be even better if we could than optimize the implementation by using program transformations on the basic implementations!
(Of course, this will only get you so far. It will not reinvent new algorithms for you. But heck, you are paid to do some of the work yourself!)