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

equal deleted inserted replaced

-:86a456f8cb92
+:135bf034ac30
 \lstset{escapeinside={/*!}{!*/}}
 \newcommand{\annotation}[1]{\hfill\footnotesize{}#1}
 \usepackage{menukeys}
+\usepackage{emoji}
 %cheat sheet
 %http://worldline.github.io/scala-cheatsheet/
 % case class, apply, unapply
 \begin{quote}
 \url{http://techcrunch.com/2016/06/14/scala-is-the-new-golden-child}
 \end{quote}
 \noindent
-The official Scala compiler can be downloaded from
+The official Scala web-page is here:
 \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
 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
 number does not matter. Note that this will be the first year I am
-using this version -- so some hiccups are bound to happen. Apologies
+using this newer version -- so some hiccups are bound to 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, rather
+than the ``plain'' Scala REPL. This is a batteries included version of
+Scala and is easier to use. In fact \texttt{scala-cli} will replace
+the ``plain'' Scala REPL in future versions. So why not using it now?
+It can be downloaded from:
+\begin{center}
+\url{https://scala-cli.virtuslab.org}
+\end{center}
+\end{tcolorbox}\medskip
 \noindent
 If you are interested, there are also experimental backend of Scala
 for generating JavaScript code (\url{https://www.scala-js.org}), and
 there is work under way to have a native Scala compiler generating
 \begin{figure}[t]
 \begin{boxedminipage}{\textwidth}
 \begin{center}
 \includegraphics[scale=0.15]{../pics/vscode.png}\\[-10mm]\mbox{}
 \end{center}
-\caption{My installation of VS Code includes the following
+\caption{My installation of VS Code / Codium includes the
-packages from Marketplace: \textbf{Scala Syntax (official)} 0.5.4,
+package  \textbf{Scala Syntax (official)} 0.5.7 from Marketplace.
-\textbf{Code Runner} 0.11.6, \textbf{Code Spell Checker} 2.0.12,
+I have also bound the keys \keys{Ctrl} \keys{Ret} to the
-\textbf{Rewrap} 1.14.0 and \textbf{Subtle Match
-Brackets} 3.0.0. I have also bound the keys \keys{Ctrl} \keys{Ret} to the
 action ``Run-Selected-Text-In-Active-Terminal'' in order to quickly
-evaluate small code snippets in the Scala REPL. I use the internal
+evaluate small code snippets in the Scala REPL. I use Codium's internal
-terminal to run Scala 2.13.6.\label{vscode}}
+terminal to run \texttt{scala-cli} version 1.0.5 which
+uses Scala 3.3.1.\label{vscode}}
 \end{boxedminipage}
 \end{figure}
 Actually \alert last year I switched to VS Codium, which is VS Code
 minus all the telemetry that is normally sent to Microsoft. Apart from
 \begin{quote}
 \url{https://vscodium.com}
 \end{quote}
-What I like most about VS Code/Codium is that it provides easy access to the
+What I like most about VS Code/Codium is that it provides easy access
-Scala REPL. But if you prefer another editor for coding, it is also
+to the Scala REPL. But if you prefer another editor for coding, it is
-painless to work with Scala completely on the command line (as you might
+also painless to work with Scala completely on the command line (as
-have done with \texttt{g++} in the earlier part of PEP). For the
+you might have done with \texttt{g++} in the earlier part of PEP). For
-lazybones among us, there are even online editors and environments for
+the lazybones among us, there are even online editors and environments
-developing and running Scala programs: \textit{ScalaFiddle}
+for developing and running Scala programs: \textit{Scastie} and
-and \textit{Scastie} are two of them. They require zero setup
+\textit{ScalaFiddle} are two of them. They require zero setup
 (assuming you have a browser handy). You can access them at
 \begin{quote}
-\url{https://scalafiddle.io}\\
+\url{https://scastie.scala-lang.org}\\
-\url{https://scastie.scala-lang.org}\medskip
+\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.
+are meant to play around, not really for serious work. Make
+sure your \texttt{scala-cli} works on your own machine ASAP!
 As one might expect, Scala can be used with the heavy-duty IDEs
-Eclipse and IntelliJ.  A ready-made Scala bundle for Eclipse is
+Eclipse and IntelliJ. For example IntelliJ includes plugins for
-available from
+Scala
 \begin{quote}
-\url{http://scala-ide.org/download/sdk.html}
+\url{https://scalacenter.github.io/bloop/docs/ides/intellij}
 \end{quote}
 \noindent
-Also IntelliJ includes plugins for Scala. \underline{\textbf{BUT}},
+\underline{\textbf{BUT}}, I do \textbf{not} recommend the usage of
-I do \textbf{not} recommend the usage of either Eclipse or IntelliJ for PEP: these IDEs
+either Eclipse or IntelliJ for PEP: these IDEs seem to make your life
-seem to make your life harder, rather than easier, for the small
+harder, rather than easier, for the small programs that we will write
-programs that we will write in this module. They are really meant to be used
+in this module. They are really meant to be used when you have a
-when you have a million-lines codebase instead of our small
+million-lines codebase instead of our small
-``toy-programs''\ldots{}for example why on earth am I required to create a
+``toy-programs''\ldots{}for example why on earth am I required to
-completely new project with several subdirectories when I just want to
+create a completely new project with several subdirectories when I
-try out 20-lines of Scala code? Your mileage may vary though.~\texttt{;o)}
+just want to try out 20-lines of Scala code? Your mileage may vary
+though.~\texttt{;o)}
 \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++\ldots{}the world should be your oyster, no? Well, matters are not as
+C++, possibly Python\ldots{} the world should be your oyster, no?
-simple as one might wish. We do require Scala in PEP, but actually we do
+Well, matters are not as simple as one might wish. We do require Scala
-not religiously care whether you learn Scala---after all it is just a
+in PEP, but actually we do not religiously care whether you learn
-programming language (albeit a nifty one IMHO). What we do care about is
+Scala---after all it is just a programming language (albeit a nifty
-that you learn about \textit{functional programming}. Scala is just the
+one IMHO). What we do care about is that you learn about
-vehicle for that. Still, you need to learn Scala well enough to get good
+\textit{functional programming}. Scala is just the vehicle for
-marks in PEP, but functional programming could perhaps equally be taught
+that. Still, you need to learn Scala well enough to get good marks in
-with Haskell, F\#, SML, Ocaml, Kotlin, Clojure, Scheme, Elm and many
+PEP, but functional programming could perhaps equally be taught with
-other functional programming languages.
+Haskell, F\#, SML, Ocaml, Kotlin, Clojure, 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.
 Very likely writing programs in a functional programming language is
 quite different from what you are used to in your study so far. It
 might even be totally alien to you. The reason is that functional
 programming seems to go against the core principles of
 \textit{imperative programming} (which is what you do in Java and
-C/C++ for example). The main idea of imperative programming is that
+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:
 programs. It is my preferred way of writing small Scala programs. Once
 you installed Scala, you can start the interpreter by typing on the
 command line:
 \begin{lstlisting}[language={},numbers=none,basicstyle=\ttfamily\small]
-$ scala
+$ scala-cli
 Welcome to Scala 3.3.1 (17.0.8.1, Java OpenJDK 64-Bit Server VM).
 Type in expressions for evaluation. Or try :help.
 scala>
 \end{lstlisting}%$
 \noindent The precise response may vary depending
 on the version and platform where you installed Scala. Make sure
-you have installed Scala version 3. At the Scala
+\texttt{scala-cli} uses Scala version 3. At the Scala
 prompt you can type things like \code{2 + 3}\;\keys{Ret} and
 the output will be
 \begin{lstlisting}[numbers=none,language={}]
 scala> 2 + 3
 \noindent
 Another classic example you can try out is
 \begin{lstlisting}[numbers=none,language={}]
-scala> print("hello world")
+scala> println("hello world")
 hello world
 \end{lstlisting}
 \noindent Note that in this case there is no result. The
-reason is that \code{print} does not actually produce a result
+reason is that \code{println} does not actually produce a result
 (there is no \code{resX} and no type), rather it is a
 function that causes the \emph{side-effect} of printing out a
 string. Once you are more familiar with the functional
 programming-style, you will know what the difference is
 between a function that returns a result, like addition, and a
-function that causes a side-effect, like \code{print}. We
+function that causes a side-effect, like \code{println}. We
 shall come back to this point later, but if you are curious
 now, the latter kind of functions always has \code{Unit} as
 return type. It is just not printed by Scala.
-You can try more examples with the Scala REPL, but feel free to
+You can try more examples with the \texttt{scala-cli} REPL, but feel free to
 first guess what the result is (not all answers by Scala are obvious):
-\begin{lstlisting}[numbers=none]
+\begin{lstlisting}[numbers=none,language={}]
 scala> 2 + 2
 scala> 1 / 2
 scala> 1.0 / 2
 scala> 1 / 2.0
 scala> 1 / 0
 able to ``play around'' with it!
 \subsection*{Standalone Scala Apps}
 If you want to write a standalone app in Scala, you can
-implement an object that is an instance of \code{App}. For example
+implement a function \texttt{hello} and annotate the tag
-write
+\texttt{@main}. For example write
 \begin{lstlisting}[numbers=none]
-object Hello extends App {
+@main
-println("hello world")
+def Hello() = println("hello world")
-}
+\end{lstlisting}
-\end{lstlisting}
+%object Hello extends App {
+%    println("hello world")
+%}
 \noindent save it in a file, say {\tt hello-world.scala}, and
-then run the compiler (\texttt{scalac}) and start the runtime
+then use \texttt{scala-cli run} (which internally compiles the
-environment (\texttt{scala}):
+scala file and runs it):
 \begin{lstlisting}[language={},numbers=none,basicstyle=\ttfamily\small]
-$ scalac hello-world.scala
+$ scala-cli run hello-world.scala
-$ scala Hello
 hello world
 \end{lstlisting}
 \noindent
 Like Java, Scala targets the JVM and consequently
 Scala programs can also be executed by the bog-standard Java
-Runtime. This only requires the inclusion of {\tt
+Runtime. This can be done as follows:
-scala-library.jar}, which on my computer can be done as
-follows:
 \begin{lstlisting}[language={},numbers=none,basicstyle=\ttfamily\small]
-$ scalac hello-world.scala
+$ scala-cli --power package --assembly hello-world.scala
-$ java -cp /usr/local/src/scala/lib/scala-library.jar:. Hello
+$ java -jar Hello.jar
 hello world
 \end{lstlisting}
-\noindent You might need to adapt the path to where you have
-installed Scala.
 \subsection*{Values}
 \begin{tcolorbox}[colback=red!5!white,colframe=red!75!black]
 Do not use \code{var} in your code for PEP! This declares a mutable variable.
 }
 \end{lstlisting}
 \noindent
 but this seems a bit overkill for a small function like \code{fact}.
-Notice that Scala does not have a \code{then}-keyword in an
+Notice that I did not use a \code{then}-keyword in the
-\code{if}-statement. Also important is that there should be always an
+\code{if}-statements and that I enclosed the condition inside
-\code{else}-branch. Never write an \code{if} without an \code{else},
+parentheses, like \code{(n == 0)}. Your eyes might hurt to not see an
-unless you know what you are doing! While \code{def} is the main
+\code{else} 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
+else n * fact(n - 1)
+}
+\end{lstlisting}
+\noindent
+I accept this might look a bit more familiar to beginners of Scala, if
+they come from other languages, like Java or C++. But that we also had
+to get rid in Scala 3 of the familiar \texttt{\{\}}-parentheses is
+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
+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
+\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
+the demands of Gen-Python is a step to far for my completely
+insignificant opinion. For me this is a bridge too far.
+I always assumed escaping Python's dependency hell
+is every software developers life goal---apparently not. ;o)}
+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
+on. Coming back to function definitions: While \code{def} is the main
 mechanism for defining functions, there are a few other ways for doing
 this. We will see some of them in the next sections.
 Before we go on, let me explain one tricky point in function
 definitions, especially in larger definitions. What does a Scala
 Unfortunately, unlike other functional programming languages, there is
 in Scala no easy way to find out the types of existing functions, except
 by looking into the documentation
 \begin{quote}
-\url{http://www.scala-lang.org/api/current/}
+\url{https://dotty.epfl.ch/api/index.html}
 \end{quote}
 The function arrow can also be iterated, as in
 \code{Int => String => Boolean}. This is the type for a function
 taking an integer as first argument and a string as second,
 Even if Scala has been a success in several high-profile companies,
 there is also a company (Yammer) that first used Scala in their
 production code, but then moved away from it. Allegedly they did not
 like the steep learning curve of Scala and also that new versions of
 Scala often introduced incompatibilities in old code. Also the Java
-language is lately developing at lightening speed (in comparison to the past)
+language is lately developing at lightening speed (in comparison to
-taking on many
+the past) taking on many features of Scala and other languages, and it
-features of Scala and other languages, and it seems it even introduces
+seems it even introduces new features on its own. So there is
-new features on its own. So there is seemingly even more incentive to
+seemingly even more incentive to stick with the old stuff you
-stick with the old stuff you know.
+know. Still, the goal of this part of PEP is to bend your mind about
+what programming is\ldots{}namely functional programming. I promise
+you, this will be useful no matter with which programming language you
+will work.
 Scala is deep: After many years, I still continue to learn new technique
 for writing more elegant code.
 %Unfortunately, I have not yet managed to
 \noindent
 He makes pretty much the same arguments about functional programming and
 immutability (one section is teasingly called \textit{``Where Did all
 the Bugs Go?''}). If you happen to moan about all the idiotic features
-of Scala, well, I guess this is part of the package according to this
+of Scala (3), well, I guess this is part of the package according to this
 quote:\bigskip
 %\begin{itemize}
 %\item no exceptions....there two kinds, one ``global'' exceptions, like
 %out of memory (not much can be done about this by the ``individual''

changeset 471	135bf034ac30
parent 470	86a456f8cb92
child 476	7550c816187a