1,942 research outputs found
Static Computation and Reflection
Thesis (PhD) - Indiana University, Computer Sciences, 2008Most programming languages do not allow programs to inspect their
static type information or perform computations on it. C++, however,
lets programmers write template metaprograms, which enable programs to
encode static information, perform compile-time computations,
and make static decisions about run-time behavior. Many C++ libraries
and applications use template metaprogramming to build specialized
abstraction mechanisms, implement domain-specific safety checks, and
improve run-time performance.
Template metaprogramming is an emergent capability of the C++ type
system, and the C++ language specification is informal and imprecise.
As a result, template metaprogramming often involves heroic
programming feats and often leads to code that is difficult to read and
maintain. Furthermore, many template-based code generation and
optimization techniques rely on particular compiler implementations,
rather than language semantics, for performance gains.
Motivated by the capabilities and techniques of C++ template
metaprogramming, this thesis documents some common programming patterns,
including static computation, type analysis, generative programming, and the
encoding of domain-specific static checks. It also documents notable
shortcomings to current practice, including limited support for reflection,
semantic ambiguity, and other issues that arise from the pioneering nature of
template metaprogramming. Finally, this thesis presents the design of a
foundational programming language, motivated by the analysis of template
metaprogramming, that allows programs to statically inspect type information,
perform computations, and generate code. The language is specified as a core
calculus and its capabilities are presented in an idealized setting
C++ Metaprogramming Examples
Tato práce pojednává o metaprogramování v jazyce C++. Obsahuje přehledovou část zaměřenou na metaprogramování obecně a dále sadu příkladů demonstrujících různé techniky podporující metaprogramování v C++ s důrazem na nové vlastnosti nadcházející verze normy, zatím zvané C++0x. Příklady ukazují použití šablon s proměnným počtem parametrů, jejich výpočetní sílu, staticky polymorfní generování kódu a také obecnou implementaci několika návrhových vzorů.In this thesis we investigate possibilities of metaprogramming in C++. It contains a~general overview of metaprogramming and a~set of examples of various metaprogramming techniques in the C++ programming language with an emphasis on the possibilities proposed by the upcoming standard, called C++0x for now. Examples demonstrate usage of variadic templates, computational power of templates, statically polymorphic generation of a~runtime code and generic implementation of several design patterns.
Transparent Replication Using Metaprogramming in Cyan
Replication can be used to increase the availability of a service by creating
many operational copies of its data called replicas. Active replication is a
form of replication that has strong consistency semantics, easier to reason
about and program. However, creating replicated services using active
replication still demands from the programmer the knowledge of subtleties of
the replication mechanism. In this paper we show how to use the metaprogramming
infrastructure of the Cyan language to shield the application programmer from
these details, allowing easier creation of fault-tolerant replicated
applications through simple annotations.Comment: 8 page
Information flow analysis for a dynamically typed language with staged metaprogramming
Web applications written in JavaScript are regularly used for dealing with sensitive or personal data. Consequently, reasoning about their security properties has become an important problem, which is made very difficult by the highly dynamic nature of the language, particularly its support for runtime code generation via eval. In order to deal with this, we propose to investigate security analyses for languages with more principled forms of dynamic code generation. To this end, we present a static information flow analysis for a dynamically typed functional language with prototype-based inheritance and staged metaprogramming. We prove its soundness, implement it and test it on various examples designed to show its relevance to proving security properties, such as noninterference, in JavaScript. To demonstrate the applicability of the analysis, we also present a general method for transforming a program using eval into one using staged metaprogramming. To our knowledge, this is the first fully static information flow analysis for a language with staged metaprogramming, and the first formal soundness proof of a CFA-based information flow analysis for a functional programming language
Control Flow Analysis for SF Combinator Calculus
Programs that transform other programs often require access to the internal
structure of the program to be transformed. This is at odds with the usual
extensional view of functional programming, as embodied by the lambda calculus
and SK combinator calculus. The recently-developed SF combinator calculus
offers an alternative, intensional model of computation that may serve as a
foundation for developing principled languages in which to express intensional
computation, including program transformation. Until now there have been no
static analyses for reasoning about or verifying programs written in
SF-calculus. We take the first step towards remedying this by developing a
formulation of the popular control flow analysis 0CFA for SK-calculus and
extending it to support SF-calculus. We prove its correctness and demonstrate
that the analysis is invariant under the usual translation from SK-calculus
into SF-calculus.Comment: In Proceedings VPT 2015, arXiv:1512.0221
- …