Abstract not found

Abstract. I consider the problem of the domain-specific optimization of programs. I review different approaches, discuss their potential, and sketch instances of them from the practice of high-performance parallelism. Readers need not be familiar with high-performance computing. 1

For software engineering reasons, it is often best to provide domain-specific programming environments in the context of a general-purpose language. In our view general-purpose languages are not yet general-purpose enough, and progress needs to be made before we can provide domain-specific languages that are both fast and safe. We outline some goals in this regard, and describe a possible implementation technology: guaranteed optimization, a technique for building compilers that provide proven guarantees of what optimizations they perform. Such optimizers can provide capabilities similar to staged languages, and thus provide the relevant performance improvements. They can also function as decision procedures, suggesting an approach of 'optimizers as theorem provers,' in which optimizing compilers can be used to check domains-pecific safety properties and check proofs embedded in programs.

In this paper we suggest a three-language (3L) paradigm for building the program generator models. The basis of the paradigm is a relationship model of the specification, scripting and target languages. It is not necessary that all three languages would be the separate ones. We consider some internal relationship (roles) between the capabilities of a given language for specifying, scripting (gluing) and describing the domain functionality. We also assume that a target language is basic. We introduce domain architecture (functionality) with the generic components usually composed using the scripting and target languages. The specification language is for describing user's needs for the domain functionality to be extracted from the system. We present the framework for implementing the 3L paradigm and some results from the experimental systems developed for a validation of the approach. Key words: specification language, scripting language, target language, generic component, program g...

this file with prentcsmacro.sty for your meeting, or with entcsmacro.sty for your meeting. Both can be found at the ENTCS Macro Home Page. A lightweight approach to customizable composition operators for Java-like classes

We present the following topics in this thesis: 1) the extension to the experimental scripting language Open PROMOL (Stuikys et. al., 2000); 2) the integrated environment for the language; and 3) applications of the language for modifying and generalizing VHDL components. We consider Open PROMOL (PROgram MOdification Language) as a language dedicated to the development of parameterized (generic) software components. It has been developed and extended aiming: 1) To specify

A lightweight approach to customizable composition operators for Java-like classes 1

We propose a Java-like language where class definitions are first class values and new classes can be derived from existing ones by exploiting the full power of the language itself, used on top of a small set of primitive composition operators, instead of using a fixed mechanism like inheritance. Hence, compilation requires to perform (meta-)reduction steps, by a process that we call compile-time execution. This approach differs from meta-programming techniques available in mainstream languages since it is meta-circular, hence programmers are not required to learn new syntax and idioms. Compile-time execution is guaranteed to be sound (not to get stuck) by a lightweight technique, where class composition errors are detected dynamically, and conventional typing errors are detected by interleaving typechecking with meta-reduction steps. This allows for a modular approach, that is, compile-time execution is defined, and can be implemented, on top of typechecking and execution of the underlying language. Moreover, programmers can handle errors due to composition operators. Besides soundness, our technique ensures an additional important property called meta-level soundness, that is, typing errors never originate from (meta-)code in already compiled programs.

MetaFJig- A meta-circular composition language for Java-like classes (full version with proofs)