Exceptions and first-class continuations are the most powerful forms of control in programming languages. While both are a form of non-local jumping, there is a fundamental difference between them. We formalize this difference by proving a contextual equivalence that holds in the presence of exceptions, but not continuations; and conversely, we prove an equivalence that holds in the presence of continuations, but not exceptions. By the same technique, we show that exceptions and continuations together do not give rise to state, and that exceptions and state do not give rise to continuations.

The Java Virtual Machine (JavaVM) has contributed greatly to Java's success because it provides a common intermediate format which can be shared across the Internet. Unfortunately, the JavaVM has been optimized for an interpreted model, resulting in inferior performance because its stack-based execution model cannot exploit instructionlevel parallelism. The inherent serialization of the stack execution model can be addressed either by using compilation techniques or by hardware. In this article

Today’s system programmers go to great lengths to extend the languages in which they program. For instance, system-specific compilers find errors in Linux and other systems, and add support for specialized control flow to Qt and event-based programs. These compilers are difficult to build and cannot always understand each other’s language changes. However, they can greatly improve code understandability and correctness, advantages that should be accessible to all programmers. This thesis considers four extensible and extension-oriented compilers: CIL, Polyglot, xtc, and Xoc. These four compilers represent four distinctly different approaches to the problem of bridging the gap between language design and system implementation. Taking an extension author’s point of view, this thesis compares the design of each compiler’s extension interface in terms of extension structure, syntactic analysis, semantic analysis, and rewriting.

A comfort zone is a tested region of a system’s input space within which it has been observed to behave acceptably. To keep systems operating within their comfort zones, we advocate the interposition of rectifiers between systems and their input sources. Rectifiers are designed to transform inputs to ensure that they are within the comfort zone before they are presented to the system. Rectifiers enforce a highly constrained input format and, if necessary, discard information to force inputs to conform to this format. Potential benefits of this approach include the elimination of errors and vulnerabilities, the excision of undesirable excess functionality from large, complex systems, and a simplification of the computing environment. We have developed a rectifier for email messages and used this rectifier to force messages into a specific constrained form. Our results show that this rectifier can successfully produce messages that keep the Pine email client strictly within code previously confirmed (during a small testing and training session) to function acceptably. Our results also show that the rectifier completely eliminates a security vulnerability in the Pine email client. And finally, the rectifier is able to accomplish these goals while still preserving an acceptable amount of information from the original messages.

1 2. INTRODUCTION 1 2.1. Portability and Purity 2 2.2. Goals of Borneo 3 2.3. Brief Description of an IEEE 754 Machine 3 2.4. Language Features for Floating Point Computation 6 3. FUTURE WORK 9 3.1. Incorporating Java 1.1 Features 9 3.2. Unicode Support 10 3.3. Flush to Zero 10 3.4. Variable Trapping Status 10 3.5. Parametric Polymorphism 10 4. CONCLUSION 10 5. ACKNOWLEDGMENTS 11 6. BORNEO LANGUAGE SPECIFICATION 13 6.1. indigenous 13 6.2. Floating Point Literals 16 6.3. Float, Double, and Indigenous classes 17 6.4. New Numeric Types 18 6.5. Floating Point System Properties 20 + This material is based upon work supported under a National Science Foundation Graduate Fellowship. Any opinions, findings, conclusions or recommendations expressed in this publication are those of the author(s) and do not necessarily reflect the views of the National Science Foundation. ii 6.6. Fused mac 21 6.7. Rounding Modes 21 6.8. Floating Point Exception Handling 31 6.9. Operator Overloading 51 6.10...

Grammar Proefschrift ingediend met het oog op het behalen van de graad van Licentiaat in de Informatica Door: Adriaan Peeters Promotor: Prof. Dr. Theo D'Hondt Augustus 2003 Samenvatting Een enkel programmeerparadigma volstaat niet om alle programmeerproblemen op te lossen op de meest optimale manier. Door middel van taal symbiose en multiparadigm programming kunnen meerdere programmeertalen of paradigma's door elkaar gebruikt worden. Hierdoor heeft de programmeur de beschikking over een veel breder aanbod aan mogelijkheden om het probleem op te lossen. De huidige implementaties van een multi-paradigm programmeertaal lijden echter aan een zwak ontwerp omdat ze eerst proberen de concrete syntax van de verschillende paradigma's te combineren en dan een evaluator implementeren voor deze nieuwe taal.

Today’s system programmers go to great lengths to extend the languages in which they program. For instance, system-specific compilers find errors in Linux and other systems, and add support for specialized control flow to Qt and event-based programs. These compilers are difficult to build and cannot always understand each other’s language changes. However, they can greatly improve code understandability and correctness, advantages that should be accessible to all programmers. We describe an extension-oriented compiler for C called xoc. An extension-oriented compiler, unlike a conventional extensible compiler, implements new features via many small extensions that are loaded together as needed. Xoc gives extension writers full control over program syntax and semantics while hiding many compiler internals. Xoc programmers concisely define powerful compiler extensions that, by construction, can be combined; even some parts of the base compiler, such as GNU C compatibility, are structured as extensions. Xoc is based on two key interfaces. Syntax patterns allow extension writers to manipulate language fragments using concrete syntax. Lazy computation of attributes allows extension writers to use the results of analyses by other extensions or the core without needing to worry about pass scheduling. Extensions built using xoc include xsparse, a 345-line extension that mimics Sparse, Linux’s C front end, and xlambda, a 170line extension that adds function expressions to C. An evaluation of xoc using these and 13 other extensions shows that xoc extensions are typically more concise than equivalent extensions written for conventional extensible compilers and that it is possible to compose extensions.

Dynamically typed languages such as Python and Ruby have experienced a rapid grown in popularity in recent times. However, there is much confusion as to what makes these languages interesting relative to statically typed languages, and little knowledge of their rich history. In this chapter I explore the general topic of dynamically typed languages, how they differ from statically typed languages, their history, and their defining features.

There are few programming languages that have had such a profound effect as Lisp in the field of Computer Science. It is considered by some to be the finest programming language

Moderne softwaresystemen zijn dikwijls zo complex dat ze niet slechts één probleem oplossen maar zich toespitsen op het oplossen van fundamenteel verschillende deelproblemen. De ervaring van de laatste decennia leert ons dat niet alle programmeerproblemen op expressieve wijze met eenzelfde taal opgelost kunnen worden. Programmeurs zijn productiever wanneer zij de taal gebruiken die het best geschikt is voor het oplossen van het probleem dat zich voordoet. Maar in het grotere geheel van een softwaresysteem zullen deze delen die in verschillende talen ontwikkeld zijn, uiteindelijk moeten samenwerken. Om die reden zijn er verschillende technieken ontwikkeld om zulke taalinteroperabiliteit te bekomen. Sommige van deze technieken zijn ontwikkeld om de betrokken talen zo nauw mogelijk met elkaar te laten samenwerken, zodat eigenschappen van de ene taal op een transparante manier in de andere taal gebruikt kunnen worden, zodanig dat zij in een taalsymbiose verkeren. Programmeertalen worden onderverdeeld in programmeerparadigma’s,