Dynamic Software Type Checking Clause Samples
Dynamic Software Type Checking. In the GC environment, software fragments may need to be reused in unexpected combinations and the safety of these combinations needs to be verified. In these circumstances, it is extremely helpful to use an expressive type system and have a principal typing for each software fragment in that system, because this avoids any need to reanalyze the fragment. In the GC environment, it may be important to avoid reanalysis for various reasons. Analysis may be difficult because a fragment may be available only in object-code form or because the resources used in analyzing a fragment may be impractically large for the local node.
Dynamic Software Type Checking. Maintaining the safety and reliability of software requires verification of basic properties when the software is assembled. Type system technology is frequently used to fill this need because type systems can provide strong guarantees that basic safety properties are not violated. Types have been successfully used to rule out undefined behavior, various kinds of exceptions, deadlocks, etc. Unfortunately, much of the existing type system technology has serious drawbacks in the GC environment where software fragments are communicated and must be dynamically compiled and/or linked into already running programs. Most type systems fail to support compositional analysis. As a result, when asking whether fragment A may be safely combined with B, the prior analyses of A and B may not be sufficient to answer the question, making it necessary to reanalyze A and B. Type systems with a computable analysis algorithm yielding principal typings [Jim96] avoid this problem, because the principality property guarantees that reanalyzing a fragment does not yield different results. This proposal aims to find type systems with principal typings that also address the issues of dynamic soft- ware assembly and reconfiguration. The search will begin with type systems which support intersection types [BCDC83], as these are the only known technology which can provide principal typings in a wide variety of settings. (It is important not to confuse principal typings with the much weaker “principal type” property often mentioned in the context of ▇▇▇▇▇▇▇ or SML.) We will show how to use the type systems we design for supporting such things as separate compilation and incremental type inference. The combination of dynamic type checking with dynamic assembly and reconfiguration is essential, since ad- dressing these issues separately will either fail to guarantee safety and efficiency or be significantly less useful in the GC environment.