pep-material: comparison handouts/pep-ho.tex

equal deleted inserted replaced

-:1a51207780e6
+:19b75e899d37
 \mbox{}\hfill\textit{ --- a joke(?) found on Twitter}\bigskip
 \mbox{}\hfill\textit{``Life is too short for \texttt{malloc}.''}\smallskip\\
 \mbox{}\hfill\textit{ --- said Neal Ford at Oscon'13}\;\hr{https://www.youtube.com/watch?v=7aYS9PcAITQ}\bigskip\\
+% In 1982, James or Jim Morris wrote:
+%
+% Functional languages are unnatural to use; but so are knives and
+% forks, diplomatic protocols, double-entry bookkeeping, and a host of
+% other things modern civilization has found useful.
+%
+% Real Programming in Functional Languages
+% Xerox PARC technical report
+% CSL·81·11 July 1,1981
 \subsection*{Introduction}
 \noindent
 Scala is a programming language that combines functional and
 object-oriented programming-styles. It has received quite a bit of
-attention in the last five or so years. One reason for this attention is
+attention in the last ten or so years. One reason for this attention is
 that, like the Java programming language, Scala compiles to the Java
 Virtual Machine (JVM) and therefore Scala programs can run under MacOSX,
 Linux and Windows. Because of this it has also access to
 the myriads of Java libraries. Unlike Java, however, Scala often allows
 programmers to write very concise and elegant code.  Some therefore say
 ``Scala is the better Java''.\footnote{from
 \url{https://www.slideshare.net/maximnovak/joy-of-scala}, though this might
 be outdated as latest versions of Java are catching up somewhat}
-A number of companies---the Guardian, Dualingo, Coursera, FourSquare,
+A number of companies---the Guardian, Duolingo, Coursera, FourSquare,
 Netflix, LinkedIn, ITV to name a few---either use Scala exclusively in
 production code, or at least to some substantial degree. Scala seems
 also useful in job-interviews (especially in data science) according to
 this anecdotal report
 \begin{quote}
 \url{http://www.scala-lang.org}\medskip
 \end{quote}
 \noindent\alert
-Just make sure you are using the version 3(!) of Scala. This is
+For PEP, make sure you are using the version 3(!) of Scala. This is
 the version I am going to use in the lectures and in the coursework. This
-can be any version of Scala 3.X where $X=\{1,2,3\}$. Also the minor
+can be any version of Scala 3.X where $X=\{3,4\}$. Also the minor
-number does not matter. Note that this will be the first year I am
+number does not matter. Note that this will be the second year I am
-using this newer version -- so some hiccups are bound to happen. Apologies
+using this newer version of Scala -- some hiccups can still happen. Apologies
 in advance!\bigskip
 \begin{tcolorbox}[colback=red!5!white,colframe=red!75!black]
 I will be using the \textbf{\texttt{scala-cli}} REPL for Scala 3, rather
 than the ``plain'' Scala REPL. This is a batteries included version of
 \end{center}
 \end{tcolorbox}\medskip
 \noindent
-If you are interested, there are also experimental backends of Scala
+If you are interested, there are also experimental backends for Scala
 for generating JavaScript code (\url{https://www.scala-js.org}), and
 there is work under way to have a native Scala compiler generating
 X86-code (\url{http://www.scala-native.org}). There are also some
 tricks for Scala programs to run as a native
 GraalVM~\hr{https://scala-cli.virtuslab.org/docs/cookbooks/native-images/}
 obviously Windows.\footnote{\ldots{}unlike \emph{Microsoft Visual Studio}---note
 the minuscule difference in the name---which is a heavy-duty,
 Windows-only IDE\ldots{}jeez, with all their money could they not have come
 up with a completely different name for a complete different project?
 For the pedantic, Microsoft Visual Studio is an IDE, whereas Visual
-Studio Code is considered to be a \emph{source code editor}. Anybody knows what the
+Studio Code is considered to be a \emph{source code editor}. Anybody
+out there knows what the
 difference is?} It can be downloaded for free from
 \begin{quote}
 \url{https://code.visualstudio.com}
 \end{quote}
 What I like most about VS Code/Codium is that it provides easy access
 to any Scala REPL. But if you prefer another editor for coding, it is
 also painless to work with Scala completely on the command line (as
-you might have done with \texttt{g++} in the earlier part of PEP). For
+you might do with \texttt{g++} in the second part of PEP). For
 the lazybones among us, there are even online editors and environments
-for developing and running Scala programs: \textit{Scastie} and
+for developing and running Scala programs: for example \textit{Scastie}
-\textit{ScalaFiddle} are two of them. They require zero setup
+is one of them. It requires zero setup
-(assuming you have a browser handy). You can access them at
+(assuming you have a browser handy). You can access it at
 \begin{quote}
-\url{https://scastie.scala-lang.org}\\
+\url{https://scastie.scala-lang.org}
-\url{https://scalafiddle.io}\medskip
 \end{quote}
 \noindent
 But you should be careful if you use them for your coursework: they
 are meant to play around, not really for serious work. Make
 \subsection*{Why Functional Programming?}
 Before we go on, let me explain a bit more why we want to inflict upon
 you another programming language. You hopefully have mastered Java and
-C++, possibly Python\ldots{} the world should be your oyster, no?
+soon will master C++ as well, you possibly know Python already\ldots{}
-Well, matters are not as simple as one might wish. We do require Scala
+the world should be your oyster, no?  Well, as usual matters are not as simple
-in PEP, but actually we do not religiously care whether you learn
+as one might wish. We do require Scala in PEP, but actually we do not
-Scala---after all it is just a programming language (albeit a nifty
+religiously care whether you learn Scala---after all it is just a
-one IMHO). What we do care about is that you learn about
+programming language (albeit a nifty one IMHO). What we do care about
-\textit{functional programming}. Scala is just the vehicle for
+is that you learn about \textit{functional programming}. Scala is just
-that. Still, you need to learn Scala well enough to get good marks in
+the vehicle for that. Still, you need to learn Scala well enough to
-PEP, but functional programming could perhaps equally be taught with
+get good marks in PEP, but functional programming could perhaps
-Haskell, F\#, SML, Ocaml, Kotlin, Clojure, Scheme, Elm and many other
+equally be taught with Haskell, F\#, SML, Ocaml, Kotlin, Clojure,
-functional programming languages.
+Scheme, Elm and many other functional programming languages.
 %Your friendly lecturer just
 %happens to like Scala and the Department agreed that it is a good idea
 %to inflict Scala upon you.
 C/C++). The main idea of imperative programming is that
 you have some form of \emph{state} in your program and you
 continuously change this state by issuing some commands---for example
 for updating a field in an array or for adding one to a variable
 stored in memory and so on. The classic example for this style of
-programming is a \texttt{for}-loop in C/C++.  Consider the snippet:
+programming is a \texttt{for}-loop in say Java and C/C++.  Consider the snippet:
 \begin{lstlisting}[language=C,numbers=none]
 for (int i = 10; i < 20; i++) {
 //...do something with i...
 }
 no dramatic increases are predicted for any time soon. So you are a bit
 stuck. This is unlike previous generations of developers who could rely
 upon the fact that approximately every 2 years their code would run
 twice as fast  because the clock-speed of their CPUs got twice as fast.
-Unfortunately this does not happen any more nowadays. To get you out of
+Unfortunately this does not happen any more nowadays. To get you out
-this dreadful situation, CPU producers pile more and more cores into
+of this dreadful situation, CPU producers pile more and more cores
-CPUs in order to make them more powerful and potentially make software
+into CPUs in order to make them more powerful and potentially make
-faster. The task for you as developer is to take somehow advantage of
+software faster. The task for you as developer is to take somehow
-these cores by running as much of your code as possible in parallel on
+advantage of these cores by running as much of your code as possible
-as many cores you have available (typically 4-8 or even more in modern laptops
+in parallel on as many cores you have available (typically 4-8 or even
-and sometimes much more on high-end machines). In this situation
+more in modern laptops and sometimes much more on high-end
-\textit{mutable} variables like \texttt{i} in the C-code above are evil,
+machines---and we conveniently ignore how many cores are on modern
-or at least a major nuisance: Because if you want to distribute some of
+GPUs). In this situation \textit{mutable} variables like \texttt{i} in
-the loop-iterations over several cores that are currently idle in your
+the for-loop above are evil, or at least a major nuisance: Because if
-system, you need to be extremely careful about who can read and
+you want to distribute some of the loop-iterations over several cores
-overwrite the variable \texttt{i}.\footnote{If you are of the mistaken
+that are currently idle in your system, you need to be extremely
-belief that nothing nasty can happen to \texttt{i} inside the
+careful about who can read and overwrite the variable
-\texttt{for}-loop, then you need to go back over the C++ material.}
+\texttt{i}.\footnote{If you are of the mistaken belief that nothing
+nasty can happen to \texttt{i} inside the \texttt{for}-loop, then
+you will have to be extra careful with the C++ material.}
 Especially the writing operation is critical because you do not want
 that conflicting writes mess about with \texttt{i}. Take my word: an
-untold amount of misery has arisen from this problem. The catch is that
+untold amount of misery has arisen from this problem. The catch is
-if you try to solve this problem in C/C++ or Java, and be as defensive
+that if you try to solve this problem in C/C++ or Java, and be as
-as possible about reads and writes to \texttt{i}, then you need to
+defensive as possible about reads and writes to \texttt{i}, then you
-synchronise access to it. The result is that very often your program
+need to synchronise access to it. The result is that very often your
-waits more than it runs, thereby defeating the point of trying to run
+program waits more than it runs, thereby defeating the point of trying
-the program in parallel in the first place. If you are less defensive,
+to run the program in parallel in the first place. If you are less
-then usually all hell breaks loose by seemingly obtaining random
+defensive, then usually all hell breaks loose by seemingly obtaining
-results. And forget the idea of being able to debug such code.
+random results. And forget the idea of being able to debug such
+code. If you want to watch a 5-minute video of horror stories, feel
+free to follow \ldots{}
+\hr{https://www.youtube.com/watch?v=LdLUgCJkiHY} (I love the fact, he
+says at 4:02 that he does not understand how the JVM really
+works\ldots{} I always assumed I am the only idiot who does not
+understand how threads work on the JVM. Apparently not. \raisebox{-0.7mm}{\emoji{rofl}})\bigskip
+\noindent
 The central idea of functional programming is to eliminate any state
-from programs---or at least from the ``interesting bits'' of the
+and mutable variables from programs---or at least from the ``interesting bits'' of the
 programs. Because then it is easy to parallelise the resulting
 programs: if you do not have any state, then once created, all memory
 content stays unchanged and reads to such memory are absolutely safe
 without the need of any synchronisation. An example is given in
 Figure~\ref{mand} where in the absence of the annoying state, Scala
 \centering\includegraphics[scale=0.5]{../pics/cpu2.png} &
 \centering\includegraphics[scale=0.5]{../pics/cpu1.png}
 \end{tabular}
 \end{center}
-\caption{The code of the ``main'' loops in my version of the mandelbrot program.
+\caption{The code of the two ``main'' loops in my version of the mandelbrot program.
 The parallel version differs only in \texttt{.par} being added to the
 ``ranges'' of the x and y coordinates. As can be seen from the CPU loads, in
 the sequential version there is a lower peak for an extended period,
 while in the parallel version there is a short sharp burst for
 essentially the same workload\ldots{}meaning you get more work done
 in a shorter amount of time. This easy \emph{parallelisation}
-only works reliably with an immutable program.
+only works reliably with immutable programs.
 \label{mand}}
 \end{boxedminipage}
 \end{figure}
 But remember this easy parallelisation of code requires that we have no
 you installed \texttt{scala-cli}, you can start the interpreter by typing on the
 command line:
 \begin{lstlisting}[language={},numbers=none,basicstyle=\ttfamily\small]
 $ scala-cli
-Welcome to Scala 3.3.1 (17.0.8.1, Java OpenJDK 64-Bit Server VM).
+Welcome to Scala 3.4.1 (21.0.2, Java OpenJDK 64-Bit Server VM).
 Type in expressions for evaluation. Or try :help.
 scala>
 \end{lstlisting}%$
 \noindent
 In the lectures I will try to avoid as much as possible the term
 \emph{variables} familiar from other programming languages. The reason
 is that Scala has \emph{values}, which can be seen as abbreviations of
-larger expressions. The keyword for defining values is \code{val}.
+potentially larger expressions. The keyword for defining values is \code{val}.
 For example
 \begin{lstlisting}[numbers=none]
 scala> val x = 42
 val x: Int = 42
 This function returns the value resulting from evaluating the expression
 \code{EXPR} (whatever is substituted for this). Since we declared
 \code{String}, the result of this function will be of type
 \code{String}. It is a good habit to always include this information
 about the return type, while it is only strictly necessary to give this
-type in recursive functions. Simple examples of Scala functions are:
+type in recursive functions (later more on that). Simple examples of Scala functions are:
 \begin{lstlisting}[numbers=none]
 def incr(x: Int) : Int = x + 1
 def double(x: Int) : Int = x + x
 def square(x: Int) : Int = x * x
 \end{lstlisting}
 \noindent
-The general scheme for a function is
+The general scheme for functions is
 \begin{lstlisting}[numbers=none]
 def fname(arg1: ty1, arg2: ty2,..., argn: tyn): rty = {
 ...BODY...
 }
 \noindent
 but this seems a bit overkill for a small function like \code{fact}.
 Notice that I did not use a \code{then}-keyword in the
 \code{if}-statements and that I enclosed the condition inside
 parentheses, like \code{(n == 0)}. Your eyes might hurt to not see an
-\code{else} with an \code{if}, but this has been long established
+\code{then} with an \code{if}, but this has been long established
 syntax for \code{if}-statements. Scala, to my knowledge, was pretty
 unique in that for nearly 20 years of its existence\ldots{}until Scala
 3 came along. While people like me have perfectly adapted to the sight
 of \code{if}s without \code{then}s, it seems the developers of Scala
 caved in to the special eyesight of Gen-Python people and now allow to
 write the same function also as
 \begin{lstlisting}[numbers=none]
 def fact(n: Int) : Int = {
-if n == 0 then 1
+if n == 0
+then 1
 else n * fact(n - 1)
 }
 \end{lstlisting}
 \noindent
 completely beyond me. So in Scala 3 the braces are optional and the
 \texttt{fact}-function can even be written as
 \begin{lstlisting}[numbers=none]
 def fact(n: Int) : Int =
-if n == 0 then 1
+if n == 0
+then 1
 else n * fact(n - 1)
 \end{lstlisting}
 \noindent on the condition that indents now become \emph{meaningful}
 (as in Python).\raisebox{-0.7mm}{\emoji{face-vomiting}} All versions are now permitted in Scala 3. While you
 are free to use any syntax version you want in PEP, or even mix them,
 I will \textbf{not} show you any of my code in the newfangled
 Pythonesque meaningful-indent-syntax. When necessary, I will always
 use braces to indicate the beginning and end of a code block, and I
-have not yet get used to the \code{if}s with
+have not yet get completely get used to the \code{if}s with
-\code{then}s.\footnote{Scala adopted some very fine features of Python, for example string interpolations, but that we had to completely cave in to
+\code{then}s. Please forgive me for being still inconsistent with this\footnote{Scala adopted some very fine features of Python, for example string interpolations, but that we had to completely cave in to
-the demands of Gen-Python is a step to far for my completely
+the demands of Gen-Python is a bridge too far for my completely
-insignificant opinion. For me this is a bridge too far.
+insignificant opinion.
 I always assumed escaping Python's dependency hell
-is every software developers life goal---apparently not. ;o)}
+is every software developers life goal---apparently not. \emoji{exploding-head}}
 However, no matter which syntax style you adopt for \code{if}s, never
 write an \code{if} without an \code{else}-branch! That has something
 to do with functional programming and you will see its purpose later

changeset 485	19b75e899d37
parent 483	1a51207780e6
child 492	4ffba2f72692