José de Oliveira Guimarães

Reflection for Statically Typed Languages

An object-oriented language that permits changing the behavior of a class or of a single object is said to support computational reflection. Existing reflective facilities in object-oriented languages are either complex, type unsafe, or have a large performance penalty. We propose a simple, easy-to-understand, and statically typed model that captures much of the functionalities of other reflective facilities. It brings the power of reflection to the world of type safe and efficient languages.

Learning compiler construction by examples

In traditional compiler construction courses, each compiler phase is studied in detail before moving on to the next one. This not only places a great distance between theory and practice but also makes the students lose the big picture of the subject. We have been employing a different course format in which the subject is incrementally introduced through ten compilers of increasingly complexity. The first compiler is in fact just a syntax analyzer of a very simple language. The last one is a complete compiler of a Pascal-like language. Students of this course learn how to build compilers faster than the usual.

Experiences in building a compiler for an object-oriented language

Traditionally books on compiler construction focus on procedural languages leaving some questions on compilation of object-oriented languages unanswered. This article presents some problems found in the building of a compiler for the object-oriented language Green using Java. The solutions used for these problems are exposed and whenever possible alternatives are discussed. We hope to provide programmers with some hints and caveats on compilation of object-oriented languages.

Testing student-made compilers

This article presents a few guidelines and examples for testing Pascal compilers designed by students in introductory courses. A standard Pascal subset with little alteration is used, and the possible sources of errors are divided into eight categories. Examples and probable sources of error are exposed for each category.

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.

The Green language type system

A programming language that considers basic values and classes as objects brings more opportunities of code reuse and it is easier to use than a language that does not support this feature. However, popular statically typed object-oriented languages do not consider classes as first-class objects because this concept is difficult to integrate with static type checking. They also do not consider basic values as objects for sake of efficiency. This article presents the Green language type system which supports classes as classless objects and offers a mechanism to treat basic values as objects. The result is a reasonably simple type system which is statically typed and easy to implement. It simplifies several other language mechanisms and prevents any infinite regression of metaclasses.

Closures for statically-typed object-oriented languages

Closures increase considerably the level of a language by mixing access to local variables with remote execution of a set of locally-defined statements. However, to date closures have not been added to statically-typed languages because it is difficult to type them and runtime errors occur if local variables that no longer exist are accessed. We proposed a limited but quite general kind of closure for statically-typed object-oriented languages. They can be used in most situations normal closures can without introducing any runtime errors.

Clever programming languages exercises

Books about programming languages usually propose exercises and questions requiring little creativity from students. Most exercises do not induce deeper thoughts about characteristics of languages and constructions. The paper proposes some exercises showing new constructions under unusual viewpoints, stimulating creativity.