1.1 Programming Paradigms

Welcome to my course on function
programming principles in Scala. As the name implies we’re going to do
quite a bit of scala programming, but that’s not the primary objective of the
course. The primary objective is to teach you
functional programming from first principles.
You’re going to see function programs, methods to construct them, and ways to
reason about them. You’re gonna find that functional
programming is a paradigm that’s quite different from the classical imperative
paradigm that you know from languages such as Java or C.
In fact, you can combine the two paradigms, and it’s one of Scala’s
strengths, that it provides a gradual migration path from a more concise
travel-light language to full-functional programming.
But in this course we’re not going to be gradual, we’re going to take a clean
break. I’d like to, you to suspend for the time
being most of what you know about programming and look at programs with
fresh eyes. That way, I believe you’ll be better able
to absorb this new way of thinking, that’s function programming, and once you’ve done
that you’ll also be able to integrate that back into your daily programming practice.
In face, Scala is a great tool both to learn function programming from first
principles and later on to integrate it with classical object oriented
programming. So let’s get started.
So I have talked about functional programming as a different paradigm.
If we go back to the meaning of the word, in science, a paradigm describes distant
concepts or thought patterns in some scientific discipline.
In programming we can distinguish three main paradigms.
There is imperative programming. That’s what you probably know from
languages such as Java or C. There’s functional programming.
And there is a lesser known one called logic programming.
Some people call object oriented programming a paradigm.
But in my mind, it’s really something that’s orthogonal to the three paradigms
here. In the sense that it can be combined well
with both imperative programming. That’s what you, essentially the current
state of the art. But also with functional programming or
even logic programming. So let’s review what imperative
programming is as a paradigm. Imperative programming is really about
modifying mutable variables using assignments.
And those will be composed with control structures such if then L’s, loops, right
continue, return, and so on. The most common informal way to understand
imperative programs is as instruction sequences for a Von Neumann computer.
Von Neuman was one of the pioneers of the computer, built the first computer around
1945. So a Von Neumann computer, it consists
essentially of a processor and memory, and then there’s a bus that reads both
instructions and data. From the memory into the processor.
And what’s important is this, that the width of that bus is about one machine
word so 32 bits or 64 bits nowadays. Now it turns out that, that model of a
computer has shaped programming to no small degree.
There’s a very strong correspondence between the memory cells of a Von Neumann
computer and the mutable variables in a programming language.
Variable de-references correspond them to load instructions in the computer.
Variable assignments relate to store instructions.
Controlled structures all translate into a sequence of loops.
So that’s all very well, but the scaling is getting up.
We want to avoid conceptualizing programs just word by word.
We want to reason in larger structures. That was the argument made by John Backus,
in his Turing award lecture, titled Can Programming Be Liberated From the Von
Neumann Style. It’s noteworthy that John Backus was in
fact the inventor of the first high level language at all.
It was Fortran in the 1950’s, so more than twenty years later he found that the
traditional course of action of imperative programming had run it’s course, was
running out of steam, and that something new was needed.
And the new thing that he was proposing then was function programming.
So John Backus argued that in the end pure imperative program it is limited by the
Von Neumann bottleneck, which means, which means that we conceptualize data
structures word by word. If you want to scale up, we’ll need to
define higher level abstractions such as collections, polynomials, geometric
shapes, strings, documents, and so on. And to be thorough, we need to have
theories of these higher level abstractions, collections, shapes, and so
on so that we are able to reason about them.
So what is a theory? In mathematics, a theory consists of one
or more data types, operations on these types, and laws that describe the
relationships between the values and the operations.
So what’s important is that a theory mathematics does not describe mutations.
A mutation means that I have changed something while keeping the identity of
the thing the same. So for instance the theory of polynomials
describes the sum of two polynomials by laws such as this one here.
Here we say to sum two polynomial of degree one, we Take the two coefficient of
the same degree and the sum of those coefficients, and there would be laws of
all the other useful operators for polynomials.
But one thing the theory does not do is define an operator to change a coefficient
while keeping the polynomial the same. Whereas if we look at programming,
imperative programming, one can do precisely that.
One can write a class polynomial that would have an array of tables containing
the coefficients. One can then define a concrete polynomial
p and one can set the coefficient zero of that polynomial to 42.
When one does that the polynomial p is still the same.
That in mathematics simply is not available.
It would detract from the theory of, in mathematics and in fact would, could
damage this theory by breaking laws. Let’s look at another example.
Strings. So most programming languages have
strings. And they would also define a concatenation
operator. Let’s wite that ++ here.
And one of the laws for concatenation is that it’s associative.
So, a++b with parents to the left, ++c is the same as, as a++ b ++ c, with parents
to the right. But again, the theory does not define an
operator to change a sequence element, while keeping the sequence the same.
This one actually, some languages do get right.
For instance, in Java, the type of strings is immutable.
It also does not give you an operator to change a character in the string while
keeping the string the same. So these were observations about theories
in mathematics. What are the consequences for programming?
Well, if you want to implement high level concepts following the mathematical
theories, you find that there’s really no place for mutation.
First the theories do not admit they don’t have a mutation operator, and second if
you add it, then it could. In fact, destroy useful laws in the
theory. And that leads to a new style of
programming, where we say, well, we want to concentrate in defining these theories.
So, operators, which quote in the mp, expressed as functions.
We want to avoid mutations. And if we are going to do without
something, we want to gain something else. The things we gain is to get powerful race
traps, tracked and compose functions. So, a start of function programming means
avoid mutations. Get new ways to abstract and compose
functions. In fact, there are two ways to look at
functional programming, a restricted one and a more general one.
In the restricted sense, functional programming just means programming without
mutable variables, without assignments to those variables, without loops and the
other imperative control structures. So it takes a lot of things away.
In the more general sense, functional programming means focusing on the
functions in the program. So, in a sense, it gives you new
capabilities to work with these functions. In particular, functions can be values
that are produced, consumed and composed. All this can be done in any programming
language. But it becomes much easier in a functional
language. So then we can also look at functual
languages in a restricted sense or in a more general sense.
In the restricted sense then a functual programming language is one which does not
have an immutable variables assignments or imperative control structure and in the
wider sense the functual programming language is one with that enables the
construction of elegant programs that focus on the functions.
In particular functions in a functual programming language or first class
citizens. What does it mean?
It means that essentially you can do with a function that you could do with any
other piece of data so. You can define a string anywhere you
should be able to define a function anywhere including inside other functions.
Like any other value, you should be able to pass a function as a parameter to
another function and return it f-, as a result from a function.
And as for other values, there will be a set of operators to compose functions into
greater functions. So what are some functional programming
languages? In the restricted sense, there are not
many. There are some subsets, such as Pure Lisp
or Haskell without the IO monad, or unsafe perform IO.
There’s an experimental language FP. That was the one that Backus proposed.
And there are some domain specific languages, mostly in the XML domain.
So examples are XSLT, XPath, or XQuery. In the wider sense, we will see the Lisp
family of languages, starting with Lisp with prominent dialect Scheme, Record and
Clojure. The ML family that has SML or Caml, F#,
has the most popular variants, Haskell. The full language, Scala.
And also Smalltalk or Ruby, so you might be surprised to see the last ones in the
list of, of functional languages because they generally count as object oriented
languages. But since both of these languages have a
construct of blocks, which are essentially first class function values that we can
pass around, I think it’s fair to also adopt them in the functional family.
Another example of that would be Java Script, which has, is similar
capabilities. So if you look at the history of
functional programming languages, we find that they date back to almost the
beginning of programming languages in general.
The first functional language was LISP, invented by McCarthy at the end of the
1950s. Then there was a lot of activities in the
1970’s and’80s with, ML, FP, Scheme, Small Talk, Standard ML.
Reaching into the’90s with Haskell and Erlang.
Later languages include OCML, 2000, Scala, 2003.
F sharp 2005 and Clojure, 2007. So, to find out more about function
programming, I recommend this book, Structure and Interpretation of Computer
Programs, by Harold Ibelson and Gerald Susman.
The second edition appeared at MIT Press in’96.
That book is an absolute classic when it comes to function programming.
Many parts of our course and also the quizzes are based on it.
But we change the language from Scheme to Scala.
If you want to find out more about Scala then I have to recommend my own book of
course. It’s called Programming in Scala by
myself, Lex Spoon, and Bill Venners. Its also appears in second edition at
Artima Press 2010. And that’s in a sense the standard
language introduction for Scala and standard language reference.
So then, many other books published about functional programming in general, and
scala in particular. I only pick out three to recommend.
But there would be many other choices as well.
First recommendation is Scala For The Impatient, by Cay Horstmann.
That gives a fast paced introduction for people who already know Java well.
The second one is the O’Reilly book, Programming in Scala.
And the third one is called Scullah in Depth by Josureth.
That’s the name. Implies that book goes quite a bit further
than the other introductory text. You can find links to all of these books
on the course site. So if I open up the course site, and go to
additional resources. And I see the text, the links for all the
books here, and quite a few of them are actually available online, either as the
full text or in parts. Now I’ve given you a quick introduction to
functional programming, and why it matters.
I’ve stressed that there are simpler reasoning principles, and better
modularity. But there’s actually a third reason why
functional programming is becoming increasingly popular.
And that’s because it’s very good for exploiting parallelism on multi call and
cloud computing. To find out more about this third aspect,
there’s actually a video that I gave last year at the OSCON Java conference.
The video’s called, Working Hard to Keep it Simple.
And you get that also from the site. So, you find the slides of the video here.
And, and to talk. You find here.
I recommend that you go now to that talk to find out a little bit more about Scala
what its role is, what its purpose is, and why functional programming is important
for parallelism and concurrency. After you’ve done that, you can come to
the next lecture, where we are going to do some Scala programming.

Leave a Reply

Your email address will not be published. Required fields are marked *