Whereas modern programming languages are moving further and further away from basic processor architectures, modern processor architectures also move away, but in the opposite direction. The semantic gap to be bridged thus increases and modern compilers are performing quite a few costly analyses in translating programs efficiently to these complex hardware architectures: besides dealing with complex type systems we perform strictness analysis, usage analysis, escape analysis, data and control-flow analysis, and shape analysis. Based on their outcome we transform a program using a whole plethora of program transformations, amongst which partial evaluation, specialisation, fusion, and inlining. The outcomes of the analyses are most effectively used when based upon the complete program instead of individual modules. Still we want to be immediately informed about the consequences of small program changes: if such a small change suddenly leads to an inconsistency (or a large change) in the inferred types we want to be warned immediately; we likely made a mistake. So we have two conflicting requirements: getting immediate feedback versus depending on time-consuming analyses. Because we apply the analyses repeatedly during program development, we may try to perform them incrementally by only recomputing that part which depends on the changed input part. This insight as such is not new, but how to achieve this effect without making extensive modifications to a compiler still requires considerable research, and that is what this proposal is about. We specifically direct our research to techniques which apply in the area of program analysis and transformation.