After a short introduction about the relevance of macros as tools to design abstractions, including full programming languages, I show some common patterns of Scheme macrology: recursive macros, accumulators, and the usage of literals to incorporate helpers in macros.

Observations about the organization of the conference and about the talks discussing the future of Common Lisp.

Some thoughts about programming-language communities, inspired by the Lisp conference I attended last week.

A pointer to the slides I prepared for the Second European Lisp Symposium http://www.european-lisp-symposium.org/

In the last episode we saw that PLT Scheme performs much more instantiation and visiting of modules than other implementations. The reason for such behaviour is that PLT Scheme aims to avoid cross-phase side effects. In this episode I explain what cross-phase side effects are and why they are evil.

In episode 19 I noticed that the R6RS module system allows for separate compilation, but I have not mentioned the subtilities associated with it. This episode discusses the topic, the concept of visit time and the intricacies of the "import" semantics.

This episode goes in depth through the most obscure secrets of Scheme, by exploring the (Dark) Tower of Metalevels of the R6RS module system.

Last week my MacBook died of a premature death at age 2. Out of necessity, I have been forced to borrow my wife's EeePC for a while and to use it as my main development platform. The unexpected thing is that it just works perfectly.

In this episode I introduce the concepts of implicit phasing, explicit phasing and multiple instantiation of modules. Moreover, I discuss various portability issues of the R6RS module system related to the different phase separation concepts.

One of the trickiest things about Scheme is the distinction between the interpreter semantics which is typically (but not always) used at the REPL and compiler semantics which is typically (but not always) used in scripts.

This is the first of six episodes concerning the R6RS module system. The module system is quite new and it is the result of several compromises. As a consequence, it has some rough edge and writing portable code - specially for macro writers - is not always trivial.

In this final installment I show a solution of the design problem posed last week, i.e. I show a possible mechanism for adding multiple interfaces to an object without polluting its namespace with mixin methods.

My series against mixins continues. This time I consider using proxies instead of mixins, and I pose a design problem which will be solved in the last issue.

A preview of the next cycle of Adventures is given. I ask from reader's feedback and I announce the availability of the Adventures in both PDF and HTML formats. Rejoice!

A list of all the Adventures published until now.