To understand the advantages provided by our approach we need to start by summarizing the conventional approach of compilation. Conventional technology for compiler construction evolved from the need to release the programmer of the burden of writing machine-language programs. That is, a conventional compiler allows programmers to develop their programs using a notation closer to the problem domain while the computer is designed to execute programs written in a binary machine language. This technology is not founded upon a formal concept of a programming language and is not based on a mathematical algorithm that models a compiler. Rather, it consists of a series of well understood transformations performed on the notations used by programmers to express their algorithms mapping them into the binary notations that represent machine language programs. The lack of a mathematical model for the compiler makes it difficult to integrate these transformations into a software artifact that can be proven correct and is understandable to its user, the programmer. The side effect is that the compiler implementation is a difficult task and the correctness of the commercial compilers is usually not proven mathematically. This situation is typical for the current software and has led to profound problems in the software industry [19]. In addition, a compiler may incorporate assumptions on its source and target languages that are not necessarily acceptable for another compiler that has the same source and target languages. The consequence is that programs are not portable between platforms of machines nor between generations of languages. On the other hand while a compiler freezes the notation that programmers can use to develop their programs, the problem domain evolves and requires extensions that are not supported by the compiler. The programmer must then use old and sometimes inappropriate tools to solve new problems. Consequently the computation power of the new machines cannot actually be used and the efficacy of problem solving is reduced. The best example illustrating this conclusion is provided by the need to exploit parallel machines using sequential languages. This state of the art leads to the paradoxical situation where the compiler developed as a tool to make programming easier becomes a burden for the programming activity.