Summary
Episode #12 closed my second cycle of Adventures. There will be a third cycle. However, now I have to write everything from scratch instead of translating from my original Italian series, therefore the publication rate will
slow down. Here is some anticipation about the future.

In that cycle I discussed at length Scheme macros, spending six
episodes on the subject. However, there is so much to say about macros
that six episodes are not enough to make them justice. Therefore I
plan to write a whole new cycle to discuss the deeper aspects of
macros, such as the hygiene issue, higher order macros and
advanced macrology techniques. However, in this moment I think it is
a good idea if I pause for a while from macros, in order to give to my
readers some time to digest them.

The third cycle of the Adventures will
concern a completely different topic: the functional features of Scheme.
It should be easier to follow than the second cycle since nowadays functional
programming is becoming popular (all scripting languages have some
support for functional programming, a lot of functional constructs
entered in the latest version of C#, Scala is getting traction
in the Java world, etc.).

Still, there is a substantial difference between an imperative
language with some support for functional programming and a truly
functional language.
A true functional language is based on functional data structures,
has strong support for recursion (it requires tail call optimization),
and for higher order functions, and it features pattern matching.
Scheme has all of those things and more, since it is a multiparadigm
language.

I will devolve the next episodes of the Adventures to the
exploration of those topics. However, you will need to have patience
since I have a few Python-related papers to publish first, and the
third cycle will probably start next year.