Functional programming is becoming increasingly widespread in industry. This trend is driven by the adoption of Scala as the main programming language for many applications. Scala fuses functional and object-oriented programming in a practical package. It interoperates seamlessly with both Java and Javascript. Scala is the implementation language of many important frameworks, including Apache Spark, Kafka, and Akka. It provides the core infrastructure for sites such as Twitter, Tumblr and also Coursera. In this course you will discover the elements of the functional programming style and learn how to apply them usefully in your daily programming tasks. You will also develop a solid foundation for reasoning about functional programs, by touching upon proofs of invariants and the tracing of execution symbolically. The course is hands on; most units introduce short programs that serve as illustrations of important concepts and invite you to play with them, modifying and improving them. The course is complemented by a series programming projects as homework assignments. Recommended background: You should have at least one year programming experience. Proficiency with Java or C# is ideal, but experience with other languages such as C/C++, Python, Javascript or Ruby is also sufficient. You should have some familiarity using the command line.
Lecture 1.1 - Programming Paradigms
Loading...
Aus dem Kurs von École Polytechnique Fédérale de Lausanne
Functional Programming Principles in Scala
6195 Bewertungen
École Polytechnique Fédérale de Lausanne
6195 Bewertungen
Kurs 1 von 5 in Specialization Functional Programming in Scala
Aus der Unterrichtseinheit
Getting Started + Functions & Evaluation
Get up and running with Scala on your computer. Complete an example assignment to familiarize yourself with our unique way of submitting assignments. In this week, we'll learn the difference between functional imperative programming. We step through the basics of Scala; covering expressions, evaluation, conditionals, functions, and recursion
Treffen Sie die Kursleiter
Martin OderskyProfessor
Computer Science
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.
Durchsuchen Sie unseren Katalog
Melden Sie sich kostenlos an und erhalten Sie individuelle Empfehlungen, Aktualisierungen und Angebote.
Coursera arbeitet mit erstklassigen Universitäten und Organisationen zusammen, um Online-Kurse anzubieten und dadurch universellen Zugriff auf die weltweit beste Ausbildung zu ermöglichen.
© 2019 Coursera Inc. Alle Rechte vorbehalten.
