Metaprogramming

Design patterns, 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 patterns could be used for customizing and integrating the Intellectual Property (IP) components into Systemon-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.

Meta-programming languages provide infrastructure to generate and execute object programs at run-time. In a typed setting, they contain a modal type constructor which classifies object code. These code types generally come in two flavors: closed and open. Closed code expressions can be invoked at run-time, but the computations over them are more rigid, and typically produce less efficient residual object programs. Open code provides better inlining and partial evaluation of object programs, but once constructed, expressions of this type cannot in general be evaluated.Recent work in this area has focused on combining the two notions into a sound system. We present a novel way to achieve this. It is based on adding the notion of names from the work on Nominal Logic and FreshML to the λ -calculus of proof terms for the necessity fragment of modal logic S4. The resulting language provides a more fine-grained control over free variables of object programs when compared to the existing la...

C++ template metaprogramming has been used with great success to build software applications and libraries. In practice, however, template metaprogramming suffers usability, reliability, and capability shortcomings, and it is not well understood in theory. Template metaprogramming has these problems because it relies on emergent properties of disparate language features that were tailored to other purposes. As a step toward solid and sound language support for metaprogramming, this paper establishes firm semantic foundations for select capabilities of template metaprogramming. We analyze C++ and the idioms of template metaprogramming and isolate, in a language-neutral fashion, fundamental capabilities of C++ that enable metaprogramming. Guided by this analysis, we present a design for a core calculus that directly expresses fundamental metaprogramming capabilities, including static computation, code generation, and type reflection. We prove a typesafety property for compile-time eva...

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.

* € (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.

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.

MetaJ is a programming environment that supports metaprogramming in the Java language. The environment is designed to allow extensions via plug-ins which permit the user to manipulate programs written in different languages. This facilities concern only syntactic aspects. Semantics aspects are language-dependent and are not addressed here, but could be tackled with other tools, which could even be layered on the top of MetaJ. Accessing patterns by example inside ordinary Java programs is a major feature of MetaJ programming. This paper presents a conceptual descrip- tion of the environment, implementation details and three applications on analysis, restructuring and generation of programs.

This article discusses an efficient implementation of tensors of arbitrary rank by using some of the idioms introduced by the recently published C++ ISO Standard (C++11). With the aims at providing a basic building block for high-performance computing, a single Array class template is carefully crafted, from which vectors, matrices, and even higher-order tensors can be created. An expression template facility is also built around the array class template to provide convenient mathematical syntax. As a result, by using templates, an extra high-level layer is added to the C++ language when dealing with algebraic objects and their operations, without compromising performance. The implementation is tested running on both CPU and GPU.

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.

Mirror-based systems are object-oriented reflective architectures built around a set of design principles that lead to reflective APIs which foster a high degree of reusability, loose coupling with base-level objects and whose structure and design corresponds to the system being mirrored. However, support for behavioral intercession has been limited in contemporary mirror-based architectures, in spite of its many interesting applications. This is due to the fact that mirror-based architectures only support explicit reflection, while behavioral intercession requires implicit reflection. This work reconciles mirrors with behavioral intercession. We discuss the design of a mirror-based architecture with implicit mirrors that can be absorbed in the interpreter, and mirages, base objects whose semantics are defined by implicit mirrors. We describe and illustrate the integration of this reflective architecture for the distributed object-oriented programming language AmbientTalk.

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.

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.

Particular profiling tools are sometimes used as a prelude to coaching and training interventions. The rationale for this is that individuals may start to recognize and develop key understandings in advance of the coaching journey. Key understanding may include these:
• We are all different and these differences can be explained
• If I have inherent weaknesses or blind spots and know about them, I can manage these to ameliorate these weaknesses or may gain improved performance
• Understanding others can help me to communicate and motivate others better. Many profiling systems, including Meyers-Briggs, place people in boxes or types, the descriptions of which are generalized and refer to 'preferences' rather than actual, meaningful competencies (or real motivations). This merging or greying of so-called 'typologies' means that each type is less pertinent to any one individual. Preferences do not necessarily describe actual behaviours and performance at work. In contrast, in recent years a new profiling system that measures motivations has been designed; this is based upon meta-programmes. An added bonus of the methodology is that each individual has a unique profile reducing the generalized 'type-typing' that can be a turn-off to some people. This 'iWAM' system (Merlevede 2009) 1 is based upon 48 meta-programmes (Cameron-Bandler 1985) and provides a useful and accessible basis for both individual change and team development. This article does not aim to explain thoroughly the whole system, or the many interpretive distinctions that arise, but rather to illustrate, using individual examples, how this profiling tool can be used both as a prelude, and as an aid to, coaching journeys. Whenever a coaching relationship uses a profiling tool, the tool will throw up capability-gaps between where the coachee is and where the coachee wants to be. The iWAM approach, like other profiling tools, allows the coachee to choose areas for gap-management coaching. The iWAM system has at least one key point of difference from other profiling systems-it brings highly individualised precision, in that it measures the individual according to his/her current work context. This distinction is 'specific to the individual' rather than a generic 'personality profile.' This means that if the individual's role or work context changes to any significant degree, the iWAM system of profiling can point to the likely effect of that change on the individual's patterns of thinking and their consequent performance/behaviours as a result. In other words, iWAM does not 'box' or 'type' individuals but provides highly individualized data to work with. Let's look at two illustrations.

Cyclone is a type-safe programming language derived from C. The primary design goal of Cyclone is to let programmers control data representation and memory management without sacrificing type-safety. In this paper, we focus on the region-based memory management of Cyclone and its static typing discipline. The design incorporates several advancements, including support for region subtyping and a coherent integration with stack allocation and a garbage collector. To support separate compilation, Cyclone requires programmers to write some explicit region annotations, but a combination of default annotations, local type inference, and a novel treatment of region effects reduces this burden. As a result, we integrate C idioms in a region-based framework. In our experience, porting legacy C to Cyclone has required altering about 8% of the code; of the changes, only 6% (of the 8%) were region annotations.

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 dis- tinguish the level of object programs (which are the manipulated data) from the meta programs (which perform the computations). In functional programming, modal types

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.

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.

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.

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.

MetaJ is a programming environment that supports metaprogramming in the Java language. The environment is designed to allow extensions via plug-ins which permit the user to manipulate programs written in different languages. This facilities concern only syntactic aspects. Semantics aspects are language-dependent and are not addressed here, but could be tackled with other tools, which could even be layered on the top of MetaJ. Accessing patterns by example inside ordinary Java programs is a major feature of MetaJ programming. This paper presents a conceptual description of the environment, implementation details and three applications on analysis, restructuring and generation of programs.

Session types allow communication protocols to be specified typetheoretically so that protocol implementations can be verified by static type-checking. We extend previous work on session types for distributed object-oriented languages in three ways. (1) We attach a session type to a class definition, to specify the possible sequences of method calls. (2) We allow a session type (protocol) implementation to be modularized, i.e. partitioned into separatelycallable methods. (3) We treat session-typed communication channels as objects, integrating their session types with the session types of classes. The result is an elegant unification of communication channels and their session types, distributed object-oriented programming, and a form of typestates supporting non-uniform objects, i.e. objects that dynamically change the set of available methods. We define syntax, operational semantics, a sound type system, and a correct and complete type checking algorithm for a small distributed class-based object-oriented language. Static typing guarantees that both sequences of messages on channels, and sequences of method calls on objects, conform to type-theoretic specifications, thus ensuring type-safety. The language includes expected features of session types, such as delegation, and expected features of object-oriented programming, such as encapsulation of local state. We also describe a prototype implementation as an extension of Java.

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.

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)

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.

Class sharing is a new language mechanism for building extensible software systems. Recent work has separately explored two different kinds of extensibility: first, family inheritance, in which an entire family of related classes can be inherited, and second, adaptation, in which existing objects are extended in place with new behavior and state. Class sharing integrates these two kinds of extensibility mechanisms. With little programmer effort, objects of one family can be used as members of another, while preserving relationships among objects. Therefore, a family of classes can be adapted in place with new functionality spanning multiple classes. Object graphs can evolve from one family to another, adding or removing functionality even at run time.

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.

This paper uses Template Haskell to automatically select appropriate skeleton implementations in the Eden parallel dialect of Haskell. The approach allows implementation parameters to be statically tuned according to architectural cost models based on source analyses. This permits us to target a range of parallel architecture classes from a single source specification. A major advantage of the approach is that cost models are user-definable and can be readily extended to new data or computation structures etc. * This work is generously supported by EPSRC grants GR/R 70545/01, GR/R 91298/01 and GR/S 15198/01 and by joint travel grants from the British Council/DAAD.

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.

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.

In domains, where great variability of requirements and products exists such as embedded system design domain, a product line (PL) approach is emerging as the most promising design paradigm. The key for the PL implementation is the use of domain analysis and domain modelling methods. We propose to represent domain variability using feature models enriched with lightweight domain ontology. We transform such models into generative component specifications using meta-programming techniques. We suggest: 1) to use domain analysis methods from two perspectives, software engineering and cognitive science; 2) to enrich domain variability models explicitly by contextualization and repurposing (i.e., by lightweight domain ontology); 3) to represent the model using the enriched feature diagrams (EFDs); 4) to encode EFDs using heterogeneous meta-programming.

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-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.

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.