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

equal deleted inserted replaced

-:060b081523de
+:fc3ac7b70a06
 \section*{A Crash-Course in Scala}
 \mbox{}\hfill\textit{``Scala --- \underline{S}lowly \underline{c}ompiled
 \underline{a}cademic \underline{la}nguage''}\smallskip\\
 \mbox{}\hfill\textit{ --- a joke(?) found on Twitter}\bigskip
+\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
 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.\footnote{There are also experimental backends of
+Linux and Windows. Because of this it has also access to
-Scala for producing code under Android (\url{http://scala-android.org});
-for generating JavaScript code to build browser applications
-\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}).} 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}}
 \noindent
 The official Scala compiler can be downloaded from
 \begin{quote}
-\url{http://www.scala-lang.org}
+\url{http://www.scala-lang.org}\medskip
 \end{quote}
 \noindent
+If you are interested there are also experimental backends of Scala
+for producing code under Android (\url{http://scala-android.org}); 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}). Though be warned these backends
+are still rather beta or even alpha.
+\subsection*{VS Code and Scala}
 I found a convenient IDE for writing Scala programs is Microsoft's
 \textit{Visual Studio Code} (VS Code) which runs under MacOSX, Linux and
 obviously Windows.\footnote{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 come
 \url{https://code.visualstudio.com}
 \end{quote}
 \noindent
 and should already come pre-installed in the Department (together with
-the Scala compiler). Being a project started in 2015, VS Code is
+the Scala compiler). Being a project that just started in 2015, VS Code is
 relatively new and thus far from perfect. However it includes a
 \textit{Marketplace} from which a multitude of extensions can be
 downloaded that make editing and running Scala code a little easier (see
 Figure~\ref{vscode} for my setup).
 \begin{figure}[t]
 \begin{boxedminipage}{\textwidth}
 \begin{center}
 \includegraphics[scale=0.15]{../pics/vscode.png}\\[-10mm]\mbox{}
 \end{center}
-\caption{My personal installation of VS Code includes the following
+\caption{My installation of VS Code includes the following
-packages from Marketplace: Scala Syntax (official), Code Runner, Code
+packages from Marketplace: \textbf{Scala Syntax (official)} 0.2.0,
-Spell Checker, Rewrap and Subtle Match Brackets. I have also bound
+\textbf{Code Runner} 0.9.5, \textbf{Code Spell Checker} 1.6.10,
-the keys \keys{Ctrl} \keys{Ret} to the action
+\textbf{Rewrap} 1.9.1 and \textbf{Subtle Match
-``Run-Selected-Text-In-Active-Terminal'' in order to quickly evaluate
+Brackets} 3.0.0. I have also bound the keys \keys{Ctrl} \keys{Ret} to the
-small code snippets in the Scala REPL.\label{vscode}}
+action ``Run-Selected-Text-In-Active-Terminal'' in order to quickly
+evaluate small code snippets in the Scala REPL.\label{vscode}}
 \end{boxedminipage}
 \end{figure}
 What I like most about VS Code is that it provides easy access to the
 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 the
-lazybones among us, there is even an online editor and environment for
+lazybones among us, there are even online editors and environments for
-developing and running Scala programs called \textit{ScalaFiddle}, which
+developing and running Scala programs called \textit{ScalaFiddle}
-requires zero setup (assuming you have a browser handy). You can access
+and \textit{Scastie}, which
-it from:
+require zero setup (assuming you have a browser handy). You can access
+them from:
 \begin{quote}
-\url{https://scalafiddle.io}\medskip
+\url{https://scalafiddle.io}\\
+\url{https://scastie.scala-lang.org}\medskip
 \end{quote}
+\noindent
 Scala can be used with the heavy-duty IDEs Eclipse and IntelliJ.
 A ready-made Scala bundle for Eclipse is available from
 \begin{quote}
 \url{http://scala-ide.org/download/sdk.html}
 first place. If you are less defensive, then usually all hell breaks
 loose by seemingly obtaining random results. And forget the idea of
 being able to debug such code.
 The central idea of functional programming is to eliminate any state
-from programs---or at least from the ``interesting bits''. Because then
+from programs---or at least from the ``interesting bits'' of the
-it is easy to parallelise the resulting programs: if you do not have any
+programs. Because then it is easy to parallelise the resulting
-state, then once created, all memory content stays unchanged and reads
+programs: if you do not have any state, then once created, all memory
-to such memory are absolutely safe without the need of any
+content stays unchanged and reads to such memory are absolutely safe
-synchronisation. An example is given in Figure~\ref{mand} where in the
+without the need of any synchronisation. An example is given in
-absence of the annoying state, Scala makes it very easy to calculate the
+Figure~\ref{mand} where in the absence of the annoying state, Scala
-Mandelbrot set on as many cores of your CPU as possible. Why is it so
+makes it very easy to calculate the Mandelbrot set on as many cores of
-easy in this example? Because each pixel in the Mandelbrot set can be
+your CPU as possible. Why is it so easy in this example? Because each
-calculated independently and the calculation does not need to update any
+pixel in the Mandelbrot set can be calculated independently and the
-variable. It is so easy in fact that going from the sequential version
+calculation does not need to update any variable. It is so easy in
-of the Mandelbrot program to the parallel version can be achieved by
+fact that going from the sequential version of the Mandelbrot program
-adding just eight characters---in two places you have to add
+to the parallel version can be achieved by adding just eight
-\texttt{.par}. Try the same in C++ or Java!
+characters---in two places you have to add \texttt{.par}. Try the same
+in C++ or Java!
 \begin{figure}[p]
 \begin{boxedminipage}{\textwidth}
 A Scala program for generating pretty pictures of the Mandelbrot set.\smallskip\\
 \centering\includegraphics[scale=0.5]{../pics/cpu2.png} &
 \centering\includegraphics[scale=0.5]{../pics/cpu1.png}
 \end{tabular}
 \end{center}
-\caption{The ``main'' loops in the Mandelbrot program.
+\caption{The code of the ``main'' loops in my Mandelbrot program.
 The parallel version differs only in \texttt{.par} being added to the
-``ranges'' of the x-y-coordinates. As can be seen from the CPU loads, in
+``ranges'' of the x and y coordinates. As can be seen from the CPU loads, in
-the sequential versions there is a lower peak for an extended period,
+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 \emph{parallelisation}
+in a shorter amount of time. This easy \emph{parallelisation}
-only works reliably in an immutable program.
+only works reliably with an immutable program.
 \label{mand}}
 \end{boxedminipage}
 \end{figure}
 But remember this easy parallelisation of code requires that we
 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
-Welcome to Scala 2.12.6 (Java HotSpot(TM) 64-Bit Server VM, Java 9).
+Welcome to Scala 2.12.7 (Java HotSpot(TM) 64-Bit Server VM, Java 9).
 Type in expressions for evaluation. Or try :help.
 scala>
 \end{lstlisting}%$
 ^
 \end{lstlisting}
 \noindent
 So it would be a bit absurd to call values as variables...you cannot
-change them; they cannot vary. You might think you can re-assign them like
+change them; they cannot vary. You might think you can reassign them like
 \begin{lstlisting}[numbers=none]
 scala> val x = 42
 scala> val z = x / 7
 scala> val x = 70
 \noindent
 where each argument requires its type and the result type of the
 function, \code{rty}, should be given. If the body of the function is
 more complex, then it can be enclosed in braces, like above. If it it
 is just a simple expression, like \code{x + 1}, you can omit the
-braces. Very often functions are recursive (call themselves) like
+braces. Very often functions are recursive (that is call themselves),
-the venerable factorial function:
+like the venerable factorial function:
 \begin{lstlisting}[numbers=none]
 def fact(n: Int): Int =
 if (n == 0) 1 else n * fact(n - 1)
 \end{lstlisting}
 In most functional programming languages, types play an
 important role. Scala is such a language. You have already
 seen built-in types, like \code{Int}, \code{Boolean},
 \code{String} and \code{BigInt}, but also user-defined ones,
-like \code{Rexp}. Unfortunately, types can be a thorny
+like \code{Rexp} (see coursework). Unfortunately, types can be a thorny
 subject, especially in Scala. For example, why do we need to
 give the type to \code{toSet[Int]}, but not to \code{toList}?
 The reason is the power of Scala, which sometimes means it
 cannot infer all necessary typing information. At the
-beginning while getting familiar with Scala, I recommend a
+beginning, while getting familiar with Scala, I recommend a
 ``play-it-by-ear-approach'' to types. Fully understanding
 type-systems, especially complicated ones like in Scala, can
 take a module on their own.\footnote{Still, such a study can
 be a rewarding training: If you are in the business of
 designing new programming languages, you will not be able to
 \bigskip\noindent
 \textit{More TBD.}
 \subsection*{Coursework}
 \subsection*{More Info}
 There is much more to Scala than I can possibly describe in
 this document. Fortunately there are a number of free books
 about Scala and of course lots of help online. For example

changeset 195	fc3ac7b70a06
parent 193	ae307c3de4ee
child 197	c3e39fdeea3b