Metaprogramming

We present a novel dynamic analysis technique that finds real deadlocks in multi-threaded programs. Our technique runs in two stages. In the first stage, we use an imprecise dynamic analysis technique to find potential deadlocks in a multi-threaded program by observing an execution of the program. In the second stage, we control a random thread scheduler to create the potential deadlocks with high probability. Unlike other dynamic analysis techniques, our approach has the advantage that it does not give any false warnings. We have implemented the technique in a prototype tool for Java, and have experimented on a number of large multi-threaded Java programs. We report a number of previously known and unknown real deadlocks that were found in these benchmarks.

Meta-programming is a discipline of writing programs in a certain programming language that generate, manipulate or execute programs written in another language. In a typed setting, meta-programming languages usually contain a modal type constructor to distinguish the level of object programs (which are the manipulated data) from the meta programs (which perform the computations). In functional programming, modal types of object programs generally come in two flavors: open and closed, depending on whether the expressions they classify may contain any free variables or not. Closed object programs can be executed at run-time by the meta program, but the computations over them are more rigid, and typically produce less efficient residual code. Open object programs provide better inlining and partial evaluation, but once constructed, expressions of open modal type cannot be evaluated.

SafeGen is a meta-programming language for writing statically safe generators of Java programs. If a program generator written in SafeGen passes the checks of the SafeGen compiler, then the generator will only generate well-formed Java programs, for any generator input. In other words, statically checking the generator guarantees the correctness of any generated program, with respect to static checks commonly performed by a conventional compiler (including type safety, existence of a superclass, etc.). To achieve this guarantee, SafeGen supports only language primitives for reflection over an existing well-formed Java program, primitives for creating program fragments, and a restricted set of constructs for iteration, conditional actions, and name generation. SafeGen's static checking algorithm is a combination of traditional type checking for Java, and a series of calls to a theorem prover to check the validity of first-order logical sentences constructed to represent well-formedness properties of the generated program under all inputs. The approach has worked quite well in our tests, providing proofs for correct generators or pointing out interesting bugs.

We present the design and implementation of an infrastructure that enables monitoring of resources, services, and applications in a computational grid and provides a toolkit to help manage these entities when faults occur. This infrastructure builds on three basic monitoring components: sensors to perform measurements, actuators to perform actions, and an event service to communicate events between remote processes. We describe how we apply our infrastructure to support a grid service and an application: (1) the Globus Metacomputing Directory Service; and (2) a long-running and coarse-grained parameter study application. We use these application to show that our monitoring infrastructure is highly modular, conveniently retargettable, and extensible.

We use multi-stage programming, monads and Ocaml's advanced module system to demonstrate how to eliminate all abstraction overhead from generic programs while avoiding any inspection of the resulting code. We demonstrate this clearly with Gaussian Elimination as a representative family of symbolic and numeric algorithms. We parameterize our code to a great extent -over domain, input and permutation matrix representations, determinant and rank tracking, pivoting policies, result types, etc. -at no run-time cost. Because the resulting code is generated just right and not changed afterward, MetaOCaml guarantees that the generated code is well-typed. We further demonstrate that various abstraction parameters (aspects) can be made orthogonal and compositional, even in the presence of name-generation for temporaries, and "interleaving" of aspects. We also show how to encode some domain-specific knowledge so that "clearly wrong" compositions can be rejected at or before generation time, rather than during the compilation or running of the generated code.

Maintaining the source code of large software systems is hard. One underlying cause is that existing modularisation mechanisms are inadequate to handle crosscutting concerns. We propose intentional source-code views as an intuitive and lightweight means of modelling such concerns. They increase our ability to understand, modularise and browse the source code by grouping together source-code entities that address the same concern. They facilitate software development and evolution, because alternative descriptions of the same intentional view can be checked for consistency and relations among intentional views can be defined and verified. Finally, they enable us to specify knowledge developers have about source code that is not captured by traditional program documentation mechanisms.
Our intentional view model is implemented in a logic metaprogramming language that can reason about and manipulate object-oriented source code directly. The proposed model has been validated on the evolution of a medium-sized object-oriented application in Smalltalk, and a prototype tool has been implemented.

By using practical examples, this paper outlines the power of reflection mechanisms for logic programming systems in the domain of knowledge structuring. In particular, it presents an extension of Prolog, where separate databases can be handled as first-class objects. Different forms of database combination such as inheritance and dynamic context extension/contraction are specified and implemented in a dynamic and flexible way through reflection. The main aim is to broaden the application area of logic programming to encompass most of the paradigms needed by systems that use artificial intelligence techniques. Practical results presented in the paper show that logic programs that use reflection can be shorter, more readable and efficient than those using more conventional full meta-interpretation techniques. Full metainterpretation, however, is more general than reflection.

Meta-AspectJ (MAJ) is a language for generating AspectJ programs using code templates. MAJ itself is an extension of Java, so users can interleave arbitrary Java code with AspectJ code templates. MAJ is a structured metaprogramming tool: a well-typed generator implies a syntactically correct generated program. MAJ promotes a methodology that combines aspect-oriented and generative programming. A valuable application is in implementing small domain-specific language extensions as generators using unobtrusive annotations for syntax extension and AspectJ as a back-end. The advantages of this approach are twofold. First, the generator integrates into an existing software application much as a regular API or library, instead of as a language extension. Second, a mature language implementation is easy to achieve with little effort since AspectJ takes care of the low-level issues of interfacing with the base Java language. In addition to its practical value, MAJ offers valuable insights to...

Due to the pervasiveness of diagrams in human communication and because of the increasing availability of graphical notations in Software Engineering, the study of diagrammatic notations is at the forefront of many research efforts. The expressive power of these kinds of languages and notations can be remarkably improved by adding extensibility mechanisms. Extensibility, the ability of a notation or a modeling language to be extended from its own modeling constructs, is a feature that has assumed considerable importance with the appearance of the UML (Unified Modeling Language). In this paper, a holistic proposal to formally support the evolution of the UML metamodel is presented. To attain this aim, an algebraic formalization is provided which leads to a seamless formal model of the UML four-Iayer semantics architecture. These two characteristics-being holistic and seamless together with reflection are the most innovative aspects of the research with respect to formalizing the UML. In particular, a central role is played by reflection. A formal language supporting this feature called Maude is studied and put forward as the basis for the formalization of the UML extensibility mechanisms. Since Maude is an executable specification language, the final set of formal models can also be used as a UML virtual machine at the specification level. To illustrate the approach, a UML Class Diagram prototype is implemented using the Maude interpreter. The •Granted by the CICYT (Science and Technology Joint Committee), Spanish Ministries of Education and Industry, research project TIC97-0593-C05-02 MENHIR, OM integration of this Maude prototype with a UML commercial CASE has been developed, in Java, and is currently working.

Although modular programming is a fundamental software development practice, software reuse within contemporary GPU kernels is uncommon. For GPU software assets to be reusable across problem instances, they must be inherently flexible and tunable. To illustrate, we survey the performance-portability landscape for a suite of common GPU primitives, evaluating thousands of reasonable program variants across a large diversity of problem instances (microarchitecture, problem size, and data type). While individual specializations provide excellent performance for specific instances, we find no variants with "universally reasonable" performance. In this paper, we present a policy-based design idiom for constructing reusable, tunable software components that can be co-optimized with the enclosing kernel for the specific problem and processor at hand. In particular, this approach enables flexible granularity coarsening which allows the expensive aspects of communication and the redundant aspects of data parallelism to scale with the width of the processor rather than the problem size. From a small library of tunable device subroutines, we have constructed the fastest, most versatile GPU primitives for reduction, prefix and segmented scan, duplicate removal, reduction-by-key, sorting, and sparse graph traversal.

Design pattersn, which encapsulate common solutions to the recurring design problems, have contributed to the increased reuse, quality and productivity in software design. We argue that hardware design pattern could be used for customizing and integrating the Intellectual Property (IP) components into System-on-Chip designs. We formulate the role of design patterns in HW design, and describe their implementation using metaprogramming. We propose a Wrapper design pattern for adapting the behavior of the soft IPs, and demonstrate its application to the communication interface synthesis.

The C++ language has only a limited runtime type information system, which doesn't provide full reflection capabilities. We present a general mechanism to support reflection, exploiting template metaprogramming techniques. Two solutions are presented: a static one where metaclass information is only available at compile time to produce class specific code; and a dynamic one where metaclass objects exist at runtime. As a case study of technique we show how to build an object interface to relational database tables. By just annotating a class definition with meta information, such as storage attributes or index properties of fields, a programmer can define objects that can be stored, fetched or searched in a database table. This approach has been used in building a high-performance, full text search engine.

The success of learning objects (LO) is limited by the ability to integrate them into coherent teaching courses in order to enable the educational goal-oriented creation of competency. LO sequences must be defined that are adapted to different types of learners, their personal needs and knowledge states to allow for effective personalized learning. In this paper, we propose a method

Design methodologies have as their objective the provision of a rational framework for the sequencing of choices in producing a design. Thus the so-called waterfall model establishes a sequence of stages-requirements, specifications, demon, coding, testing and maintenance-to guide the development process. The success of a methodology can be measured by how well it accomplishes its intended function. A methodology is useful if it allows technical people and managers to allocate properly resources during development and makes the job of monitoring accomplishment easier. The waterfall method has been under considerable criticism recently because it is believed to misallocate resources, owing to it having an improper model of the software development process. A successful methodology must be founded on sound technical and economic bases. The use of economic methods is emphasized primarily as a rational basis for choice among alternatives, not as a monetary criterion. The concerns with productivity and the recent emphasis on software reuse stress both these aspects. Software development methodologies are analysed from both the technical and economic perspectives. Quantitative models consider the various organizational approaches to software development as well. In one of these models a quantitative analysis of the conditions needed for software reuse is provided, as well as an explanation of why it has generally not achieved the projected levels of success. Other models analyse the role of experts in the software development process, and the division of labour. software economics, design methodologies, object-oriented pro-9rammm9, expert systems, metaprogrammin9, software reuse METHODOLOGY Design methodologies have as their objective the provision of a rational framework for the sequencing of choices in producing a design. Thus the so-called waterfall model establishes a sequence of stages-requirements, specifications, design, coding, testing and maintenance-to guide the development process. The success of a methodology can be measured by how well it accomplishes its intended function. A methodology is useful if it allows technical people and managers to allocate resources properly during development and makes the job of monitoring accomplishment easier. The waterfall method has been under considerable criticism recently because it is believed to misallocate resources, OBJECT-ORIENTED PROGRAMMING What is object-oriented programming? A short summary Object-oriented programming (OOP) 4'5 is a program development methodology of which the constituent techniques are: • program decomposition based on objects (not functions)

We present a framework for code generation that allows programs to manipulate and generate code at the source level while the joining and splicing of executable code is carried out automatically at the intermediate code/VM level. The framework introduces a data type Code to represent code fragments: methods/operators from this class are used to reify a method from a class, producing its representation as an object of type Code. Code objects can be combined by partial application to other Code objects. Code combinators, corresponding to higher-order methods, allow splicing the code of a functional actual parameter into the resulting Code object. CodeBricks is a library implementing the framework for the .NET Common Language Runtime. The framework can be exploited by language designers to implement metaprogramming, multistage programming and other language features. We illustrate the use of the technique in the implementation of a fully featured regular expression compiler that generates code emulating a finite state automaton. We present benchmarks comparing the performance of the RE matcher built with CodeBricks with the hand written one present in .NET.

Domain-specific programming is bound to play a central role in improving the productivity of writing software. This is because modern, intricate, general-purpose abstractions are rarely applicable directly to everyday programming. However, such abstractions can be used to encode domain-specific abstractions, so that the general-purpose language serves as a host in which domain-specific fragments are embedded. The benefit of traditional software engineering is maintained, while allowing writing software that integrates multiple domains. This thesis describes two such techniques in Scala –a modern language with functional and object-oriented features. The first allows embedding fragments of code with domain-specific syntax, which is weaved within the host language's own syntax so that it appears as being different. The second technique uses structural types to encode domain-specific correctness properties that object-oriented types cannot represent. An implementation of structural types in Scala is also described. The common characteristic of both techniques is that domain-specific properties are provided by a library relying only on general-purpose abstractions. However, the techniques also exemplify how certain embedding tasks rely on data that is available in the compiler but is then lost in statically-typed languages. General-purpose abstractions do not give access to this data, nor do traditional runtime reflection techniques; keeping all data is also impractical. This thesis describes two metaprogramming techniques whereby compiler data on code (code lifting) and types (manifests) can be requested by embedding libraries when needed. Compiler data is then available as literal values in the program. It further describes a metaprogramming framework that combine compiler data available in code with reflection. Its design is mirror-based, and allows a high degree of code sharing between the metaprogramming framework and the compiler.

Efficiency and flexibility are often mutually exclusive features in a code. This still prompts a large part of the Scientific Computing community to use traditional procedural language. In the last years, however, new programming techniques have been introduced allowing for a high level of abstraction without loss of performance. In this paper we present an application of the Expression Templates technique introduced in [13] to the assembly step of a finite element computation. We show that a suitable implementation, such that the compiler has the role of parsing abstract operations, allows for user-friendliness and gain in performance with respect to more traditional techniques. Both the cases of conforming and discontinuous Galerkin finite element discretization are considered. The proposed implementation is finally applied to a number of problems entailing different kind of complications.

The Adaptive Object-Model (AOM) architectural pattern has been significantly documented in literature, but there is not yet enough documentation explaining how to design and build a full AOMbased system. A AOM framework would need to address an additional number of issues that go well beyond individual software patterns. In this paper, we propose a design for a AOM framework that addresses several issues of building AOM-based systems, namely: integrity, runtime co-evolution, persistency, user-interface generation, communication and concurrency. We borrow concepts from distributed version-control systems. We show how applications based on a concrete realization of this framework, called Oghma, helps to avoid a traditional two-level domain classification, reduces accidental complexity, and directly exposes confined model evolution to the end-user.

* € (D) sind gebundene Ladenpreise in Deutschland und enthalten 7% MwSt; € (A) sind gebundene Ladenpreise in Österreich und enthalten 10% MwSt. CHF und die mit ** gekennzeichneten Preise für elektronische Produkte sind unverbindliche Preisempfehlungen und enthalten die landesübliche MwSt. Programm-und Preisänderungen (auch bei Irrtümern) vorbehalten. Es gelten unsere Allgemeinen Liefer-und Zahlungsbedingungen. Interaktiv in Common Lisp ▶ Behandelt theoretische und praktische Aspekte der Programmiersprache Common Lisp ▶ Motiviert den Leser zum Ausprobieren ▶ Bietet zahlreiche Übungsmöglichkeiten Dieses Buch vermittelt die einzigartige Idee hinter der Programmiersprache Lisp. Aus der Verbindung von interaktiver und funktionaler Programmierung entsteht eine Arbeitsstrategie in der Software-Entwicklung, mit der ein Programmierer schneller als mit konventionellen Verfahren einen korrekten, verständlichen und leicht anpassbaren Code entwickeln kann. Durch die Anwendung algebraischer Methoden auf die wandelbare Sprache Common Lisp lernt der Leser, bekannte Probleme der Anwendungsprogrammierung neu zu denken und dadurch zu präzisen und bündigen Lösungen zu kommen. Der Autor veranschaulicht an mehreren Beispielen aus der Praxis die Nutzung der Programmiersprache und motiviert den Leser, sich selbst mit Common Lisp zu befassen. Der Inhalt • Elementares Lisp • Common Lisp • Funktionale Programmierung < • Rekursionsstrukturen • Kategorientheorie • Programmieren mit Morphismen • Metaprogrammierung mit Lisp-Makros • Der metazirkuläre Interpreter Die Zielgruppe • Informatiker • Software-Entwickler • Praktiker und Mathematiker mit Interesse an funktionaler Programmierung Der Autor Patrick M. Krusenotto studierte Informatik an der Universität Bonn und ist Systemarchitekt beim Auslandsrundfunk Deutsche Welle.