Java Reference
In-Depth Information
The advantage of reactive programming is that you do not have to worry about execution at all, which
removes an entire place where bugs can arise. Furthermore, the runtime can make wild optimizations
because it is given extreme freedom in determining how to execute the code. One example of this is that it is
(conceptually) easy to distribute a reactive programming through a variety of other machines, which makes
it very cloud friendly.
Stack-Based (Concatenative)
In a way, the stack-based paradigm is a kind of imperative. Stack-based programming is a series of
instructions that are executed in order. However, the instructions all manipulate a stack: the whole program
is simply manipulating the stack. This stack contains both commands and data are pushed and popped, and
in this way, this makes stack-based programming more akin to homoiconic programming than traditional
imperative programming. The most interesting stack-based programming language that I have encountered
is Factor, which seems to be (regretably) struggling. The Java Virtual Machine bytecode is itself a stack-based
programming language, as well, which makes the stack-based paradigm arguably the “native” or “natural”
paradigm for the JVM ecosystem.
Post-Modern
There have been a number of efforts to create meta-commentaries and explorations of the boundaries of
programming languages, which I will lump together under the heading of “post-modern.” Larry Wall, the
inventor of the perl programming language, famously referred to perl as “post-modern,” by which he meant
that you can use it in a variety of different paradigms. There have been a few other languages that have
endeavored to allow you to code in any paradigm that you would like: on the JVM, Scala is of this type. It
is certainly post-functional, but it also wants to allow you to code in a declarative style (see ScalaCheck),
and has a number of advanced features whose primary purpose is to support “internal Domain Specific
Languages” and alternative (dot-less) styles.
Beyond this strain of hyper-flexed post-modern languages, there is also the Dadaist strain of post-
modern programming languages: languages that are self-referentially mock the concept of a programming
language. A perfect example of these languages is Whitespace. In Whitespace, only whitespace is significant:
anything that is not whitespace is treated as a comment and ignored by the compiler. The whole language
is spaces, tabs, carriage returns, and other whitespace characters. Another example is Brainf#ck, which
was intended to be a fully capable language with the smallest possible compiler: the result is practically
impossible to use for nontrivial development. It has a, derivative, Ook!, which claims to be a programming
language for orangutans.
Paradigms, Style, and Post-Functional Programming
Learning a programming language is not easy. It is almost like a hazing ritual, especially for the more
esoteric programming languages. Deeply understanding a new programming language paradigm is quite
literally a transformative experience. This means that people who engage in learning a new language and
a new paradigm are both deeply invested and profoundly shaped by that experience. Unfortuantely, the
tendency of some people - usually young men, and notably including your humble author in an earlier
life - is to then form tribes and elitism around this hard-won and transformative knowledge. From
experience, it is easy to do this, even inadvertantly. And, just as much from experience, let me tell you: it is a
bad way to go.
It is important to remember that these tools are simply that: tools. There are times when you want one
tool, and there are times when you want another. Sometimes you want a nail gun, and sometimes you want
a claw hammer. The better part of wisdom is knowing when to apply each tool. Introducing post-functional
