I'll state up front my position that computer programming languages are simply tools that let us communicate with other programmers and give human control of the machine. But, what does it mean to compute? Alan Turing was an English mathematician who invented the disciplines of computer science and artificial intelligence. You can read more about him at http://en.wikipedia.org/wiki/Alan_Turing. He believed that computation can be thought of as an actualization or concrete version of a mathematical function. His ideas of computation can be found in the contributions he made to the concept of an algorithm and his description of a Turing Machine. He perceived an algorithm to be a step-by-step procedure used for calculations. These steps are expressed as a finite list of well-defined instructions to calculate a function. Further, Turing postulated a theoretical computer (the Turing Machine) that could calculate anything that is computable, in spite of the complexity involved.

Others, such as Alonzo Church, approached the notion of computation by trying to solve the Entscheidungsproblem, which is German for a decision problem (http://en.wikipedia.org/wiki/Entscheidungsproblem). The decision problem asks for an algorithm, where the input is a statement of first-order logic and answers yes or no according to whether the statement is universally valid. Alonzo Church proposed the lambda calculus as a formal system in mathematical logic that satisfied this decision problem. The lambda calculus expresses computation based on function abstraction and application using variable binding and substitution (http://en.wikipedia.org/wiki/Lambda_calculus).

Further still, MIT professor, Gerald Sussman, says, "We (as humans) really don't know how to compute" (you can read more at http://www.infoq.com/presentations/We-Really-Dont-Know-How-To-Compute). That is in comparison with data and computation that we see in the natural world. Plants, for example, can harvest up to 95% of energy from the light that they absorb. They transform sunlight into carbohydrates in one million billionths of a second, preventing much of this energy from dissipating as heat. This near instantaneous process uses the basic principle of quantum computing—the exploration of a multiplicity of different answers at the same time—to achieve near perfect efficiency. The protein structure of a plant, which can be derived using this quantum effect, somehow allows the transfer of energy but not heat. According to David Biello, "Inside every spring leaf is a system capable of performing a speedy and efficient quantum computation" (you can read more about it at http://www.scientificamerican.com/article/when-it-comes-to-photosynthesis-plants-perform-quantum-computation/). We as humans just don't understand how it happens. Gerald Jay Sussman compares our computational skills with a genome, concluding that we are way behind in creating complex systems such as living organisms.

Even if our tools and approaches are primitive, we can still grasp the importance of such capabilities. The structures of the modern world dictate tools that let humans quickly calculate, abstract, and derive algorithms (ways of representing abstract data, credit in this case). The computation tools we use simply give us fine-grained control of these problems. Without them, the modern world as it is today would not be possible. Strong computation has applications in every real-world discipline [engineering, science, business (credit and financial systems), and so on], or at least any discipline where data can be represented digitally.

It's useful to think of capital as a store of time and labor. Let's consider money outside our current banking system. In The Ascent Of Money: A Financial History of the World by the Penguin Group, Niall Ferguson discusses the history of money and credit in human civilization (you can find it at http://www.amazon.com/The-Ascent-Money-Financial-History/dp/0143116177). This approach lets us consider how societies use capital to distribute wealth. Among other things, he argues that the evolution of credit and debt is as important as any technological innovation in the rise of a civilization. I've mentioned this to highlight the purpose of finance and the fact that money and finance have existed across many banking systems, including before our current one. It's important that this approach not be ideological. I want to frame the core purpose and function of a bank and flesh out the mechanics of money flows.

When programming (computers), the first task is to build an understanding of the systems we're trying to model and the problems that we are trying to solve. As such, let's distill some central notions of money and how it fits into the banking function. This is written in the spirit of banks simply becoming information processes and looking more like software companies. Technology produces alternative mediums of capital, such as cryptocurrencies, for example, bitcoin (you can find more about this at http://en.wikipedia.org/wiki/Cryptocurrency). But this concept is outside the scope of the book. I make the point to emphasize the seismic effect that software is having on finance and all modern professions. I will try to describe the context and constraints within which such banking software must operate.

Money is a medium of exchange, unit of account (divisible, fungible, or of a specific measure or size), store of value, and a standard of deferred payment. In economics, money creation is the process by which the money supply of a country or a monetary region (for example, the EU) is increased. Changes in the quantity of money may be caused due to the actions of a central bank, depository institutions (principally commercial banks), or the public. However, the major control rests with a central bank. The actual process of money creation takes place primarily in banks (refer to https://archive.org/details/ModernMoneyMechanics and http://upload.wikimedia.org/wikipedia/commons/4/4a/Modern_Money_Mechanics.pdf). In the U.S., the money creation process centers around the US Federal Reserve. So, a central bank may introduce new money into an economy by purchasing financial assets or lending money to financial institutions or governments. The majority of money in our modern economy is created by commercial banks who give loans or demand deposits.

There's much more to take into account. However, this context allows us to begin considering how to faithfully represent credit levels and flows within and between bank and bank-like entities. We can also start thinking about a commercial bank's core functions and constraints, and the systems it should implement to perform all of these.

Most to all computer languages are Turing Complete or can compute every Turing-computable function. This refers to a language that has conditional branching and allows an arbitrary number of variables. If this is the case, then how do different language categories address the notion of computation?

There are other categories and techniques being researched, such as logic programming, type theory, and so on. We'll focus mainly on functional programming and Clojure, as they provide sufficient and powerful expressivity needed to model our problem domains. These provide a high fidelity of information, faithfully representing credit levels and credit flows within and between bank and bank-like entities. For example, the notion of a function used in imperative programming is that it can have side effects that may change the value of the program state. Functions lack referential transparency, where the same language expression can result in different values at different times depending on the executing program state. This has negative implications when making financial calculations or representing credit properly in your systems. Conversely, in FP, the output value of a function depends only on the arguments that are input to the function, which is much closer to a mathematical function. Eliminating these side effects make it much easier to understand and predict the behavior of a program. This and FP's close proximity to mathematical functions are some of the key motivations for the development of functional programming.

Let's begin by setting up the tools we'll need to run the book's code. You can author the code for this book in any text editor you prefer. I'll be using Emacs. Leiningen will be the build tool that we'll use to compile and run our Clojure code. It lets us leverage Clojure's many key features shown as follows:

The following steps will guide you to create your first Clojure project:

Clojure has some special reserved characters that it needs to use exclusively. As such, we won't be able to use them when naming our program elements. The Macro characters section of Clojure's Reader page at http://clojure.org/reader, itemizes them.

There are many places you can refer to for Clojure's core functions such as the official Clojure documentation (http://clojure.org/documentation). Additionally, this site provides a handy cheatsheet that gives a bird's-eye view of core functions and their categories (http://clojure.org/cheatsheet).

These are a few community maintained sites that help you get an overview of Clojure's core functions:

Let's take a look at the Grimoire Community Clojure documentation. If you navigate to http://conj.io, you'll see a good mix of the official cheatsheet's overview, with a dynamic ability to filter on function names that we type into a search field. The functions are also grouped into overriding concerns. We'll only touch on a few functions from each category. The following section will provide you with a Clojure environment where you can explore Clojure's core functions.

In this chapter, we were introduced to the notions of computation and finance. This gave us the background required to understand Clojure's utility to solve real-world problems in many domains and finance in particular. It also gave us an orientation to help us understand Clojure's approach to computation. Clojure fits under the banner of functional programming, a different approach from imperative or object-oriented programming. We took a first look at its core Functions that act on primitives (numbers, characters, strings, symbols, and keywords) and Collections (lists, vectors, sets, and maps). Many other core functions and their categories (sequences, functions, and others) will be addressed further on in this book. Finally, we installed the Leiningen build and run tool, which will help us build and run our functions throughout the book.

In the next chapter, we'll take a look at Clojure's principles and core artifacts. We'll begin to apply these to our financial data structures and functions.