2
❘
CHAPTER 1 HAVE A BEGINNER’S MIND
c01.indd 04/23/2016 Page 2
Forget everything you know, or think you know about programming, and instead approach it as if
you were learning your very rst programming language. Otherwise, you’ll just be learning a new
syntax, and your Clojure code will look more like Java/C/Ruby and less like Clojure is designed to
look. Learning Clojure/Lisp will even affect the way you write in other languages, especially with
Java 8 and Scala becoming more popular.
FUNCTIONAL THINKING
C, C++, C#, Java, Python, Ruby, and even to some extent Perl, all have very similar syntax. They
make use of the same programming constructs and have an emphasis on an imperative style of pro-
gramming. This is a style of programming well suited to the von Neumann architecture of comput-
ing that they were designed to execute in. This is probably most apparent in the C language, where
you are responsible for allocating and de-allocating memory for variables, and dealing directly with
pointers to memory locations. Other imperative languages attempt to hide this complexity with
varying degrees of success.
In computer science, imperative programming is a programming paradigm that
uses statements that change a program’s state.
This C-style of programming has dominated the programming scene for a very long time, because
it ts well within the dominant hardware architectural paradigm. Programs are able to execute
very ef ciently, and also make ef cient use of memory, which up until recently had been a very real
constraint. This ef ciency comes at the cost of having more complex semantics and syntax, and it is
increasingly more dif cult to reason about the execution, because it is so dependent upon the state
of the memory at the time of execution. This makes doing concurrency incredibly dif cult and error
prone. In these days of cheap memory and an ever growing number of multiple core architectures, it
is starting to show its age.
Functional programming, however, is based on mathematical concepts, rather than any given com-
puting architecture. Clojure, in the spirit of Lisp, calls itself a general-purpose language; however, it
does provide a number of functional features and supports the functional style of programming very
well. Clojure as a language not only offers simpler semantics than its imperative predecessors, but it
also has arguably a much simpler syntax. If you are not familiar with Lisp, reading and understand-
ing Clojure code is going to take some practice. Because of its heavy focus on immutability, it makes
concurrency simple and much less error prone than having to manually manage locks on memory
and having to worry about multiple threads reading values simultaneously. Not only does Clojure
provide all of these functional features, but it also performs object-oriented programming better
than its Java counterpart.
Value Oriented
Clojure promotes a style of programming commonly called “value-oriented programming.”
Clojure’s creator, Rich Hickey, isn’t the rst person to use that phrase to describe functional