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

equal deleted inserted replaced

-:35b4dc785a40
+:31ba76ce016d
 \usepackage{marvosym}
 %cheat sheet
 %http://worldline.github.io/scala-cheatsheet/
-% case class, apply, unappy
+% case class, apply, unapply
 % see https://medium.com/@thejasbabu/scala-pattern-matching-9c9e73ba9a8a
 \begin{document}
 \fnote{\copyright{} Christian Urban, King's College London, 2017, 2018}
 \section*{A Crash-Course in Scala}
-\mbox{}\hfill\textit{``Scala --- Slowly Compiled Academic LAnguage''}\\
+\mbox{}\hfill\textit{``Scala --- \underline{S}lowly \underline{C}ompiled
+\underline{A}cademic \underline{LA}nguage''}\smallskip\\
 \mbox{}\hfill\textit{ --- a joke read on Twitter}\bigskip
 \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
+attention in the last five or so years. One reason for this attention is
-is that, like the Java programming language, Scala compiles to the
+that, like the Java programming language, Scala compiles to the Java
-Java Virtual Machine (JVM) and therefore Scala programs can run under
+Virtual Machine (JVM) and therefore Scala programs can run under MacOSX,
-MacOSX, Linux and Windows.\footnote{There are also experimental
+Linux and Windows.\footnote{There are also experimental backends for
-backends for Android and JavaScript; and also work is under way to
+producing code under Android (\url{http://scala-android.org}); and also
-have a native compiler, see
+for generating JavaScript code to build browser applications
-\url{https://github.com/scala-native/scala-native}.} Unlike Java,
+\url{(https://www.scala-js.org)}. Moreover there is work under way to
-however, Scala often allows programmers to write very concise and
+have a native Scala compiler generating X86-code
-elegant code.  Some therefore say: ``Scala is the better
+(\url{http://www.scala-native.org}).} It therefore has also access to
-Java''.\footnote{\url{https://www.slideshare.net/maximnovak/joy-of-scala}}
+the myriads of Java libraries. Unlike Java, however, Scala often allows
-Also a number of companies (the Guardian, Twitter, Coursera,
+programmers to write very concise and elegant code.  Some therefore say:
-FourSquare, LinkedIn to name a few) either use Scala exclusively in
+``Scala is the better Java''.\footnote{form
-production code, or at least to some substantial degree. Scala seems
+\url{https://www.slideshare.net/maximnovak/joy-of-scala}} Also a number
-also to be useful in job-interviews (in Data Science) according to
+of companies---the Guardian, Twitter, Coursera, FourSquare, LinkedIn,
-this anecdotal report
+Netflix to name a few---either use Scala exclusively in production code,
+or at least to some substantial degree. Scala seems also to be useful in
-\begin{quote}\small
+job-interviews (especially in Data Science) according to this anecdotal
-\url{https://techcrunch.com/2016/06/14/scala-is-the-new-golden-child/}
+report
+\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
 \begin{quote}
 \url{http://www.scala-lang.org}
 \end{quote}
 \noindent
-A ready-made bundle with the Eclipse IDE is at
+I found a convenient IDE for Scala programming is Microsoft's
+\textit{Visual Studio Code} (VS Code) which runs under MacOSX, Linux and
+obviously Windows. It can be downloaded for free from
 \begin{quote}
-\url{http://scala-ide.org/download/sdk.html}
+\url{https://code.visualstudio.com}
 \end{quote}
 \noindent
-When developing Scala programs, I personally prefer to use Emacs
+and should already come pre-installed in the Department (together with
-or Sublime as my environment, since they provide an easy access
+the Scala compiler). VS Code includes a \textit{Marketplace} from which
-to the Scala REPL (see below).  But it is also possible to work
+a multitude of extensions can be downloaded that make editing and
-completely on the command line and also with heavy-duty IDEs
+running Scala code easier (see Figure~\ref{vscode}).
-like Eclipse of IntelliJ. There is even an online editor and
-environment for developing Scala programs called ScalaFiddle
+\begin{figure}[t]
+\begin{center}
+\includegraphics[scale=0.15]{../pics/vscode.png}\\[-10mm]\mbox{}
+\end{center}
+\caption{My personal installation of VS Code includes the following packages
+from Marketplace: Scala Syntax (official), Code Runner, Code Spell Checker,
+Rewrap and Subtle Match Brackets. I have also bound keys \keys{\^{}} \keys{Ret}
+to the action ``Run-Selected-Text-In-Active-Terminal'' in order to
+quickly evaluate small code snippets in the Scala REPL.\label{vscode}}
+\end{figure}
+What I like most about VS Code is that it provides an easy access to the
+Scala REPL. But if you prefer your own editor for coding, it
+is also easy to work with Scala completely on the command line (like 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
+developing and running Scala programs called \textit{ScalaFiddle}, which
+requires zero setup (assuming you have a browser handy)
 \begin{quote}
 \url{https://scalafiddle.io}
 \end{quote}
+Scala can also be used with the heavy-duty IDEs Eclipse and IntelliJ.
+A ready-made Scala bundle for Eclipse is available at
+\begin{quote}
+\url{http://scala-ide.org/download/sdk.html}
+\end{quote}
+\noindent
+Also IntelliJ includes plugins for Scala. \textbf{BUT}, I do not
+recommend the usage of Eclipse or IntelliJ for PEP: these IDEs seem to
+make your life harder, rather than easier, for the small programs we
+will write in this module. They are really meant to be used when you
+have a million-lines codebase, rather than our ``toy-programs''\ldots{}why
+on earth am I required to create a completely new project with
+several subdirectories when I just want to try out 20-lines of Scala
+code? ;o)
 \subsection*{The Very Basics}
 One advantage of Scala over Java is that it includes an interpreter (a
 REPL, or
 \underline{R}ead-\underline{E}val-\underline{P}rint-\underline{L}oop)
-with which you can run and test small code-snippets without the need
+with which you can run and test small code snippets without the need
 of a compiler. This helps a lot with interactively developing
-programs. This is really the preferred way of writing small Scala
+programs. This is really 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
-Welcome to Scala 2.12.4 (Java HotSpot(TM) 64-Bit Server VM, Java 9).
+Welcome to Scala 2.12.6 (Java HotSpot(TM) 64-Bit Server VM, Java 9).
 Type in expressions for evaluation. Or try :help.
 scala>
 \end{lstlisting}%$
 \end{lstlisting}
 \noindent indicating that the result of the addition is of type
 \code{Int} and the actual result is 5; \code{res0} is a name that
 Scala gives automatically to the result. You can reuse this name later
-on. Another classic example you can try out is
+on.
+\begin{lstlisting}[numbers=none]
+scala> res0 + 4
+res1: Int = 9
+\end{lstlisting}
+\noindent
+Another classic example you can try out is
 \begin{lstlisting}[numbers=none]
 scala> print("hello world")
 hello world
 \end{lstlisting}
 function that causes a side-effect, like \code{print}. 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.
-You can try more examples with the Scala interpreter, but try
+You can try more examples with the Scala REPL, but feel free to
-first to guess what the result is (not all answers by Scala are obvious):
+first guess what the result is (not all answers by Scala are obvious):
 \begin{lstlisting}[numbers=none]
 scala> 2 + 2
 scala> 1 / 2
 scala> 1.0 / 2
 scala> 1.0 / 0.0
 scala> true == false
 scala> true && false
 scala> 1 > 1.0
 scala> "12345".length
-\end{lstlisting}
+scala> List(1,2,1).size
+scala> Set(1,2,1).size
-\subsection*{Stand-Alone Scala Apps}
+\end{lstlisting}\smallskip
+\noindent
+Please take the Scala REPL seriously: If you want to take advantage of my
+reference implementation for the assignments, you will need to be
+able to ``play around'' with it!
+\subsection*{Standalone Scala Apps}
 If you want to write a stand-alone app in Scala, you can
 implement an object that is an instance of \code{App}, say
 \begin{lstlisting}[numbers=none]
 println("hello world")
 }
 \end{lstlisting}
 \noindent save it in a file, for example {\tt hello-world.scala}, and
-then run the compiler and runtime environment:
+then run the compiler (\texttt{scalac}) and followed by the runtime
+environment (\texttt{scala}):
 \begin{lstlisting}[language={},numbers=none,basicstyle=\ttfamily\small]
 $ scalac hello-world.scala
 $ scala Hello
 hello world
 scala> val z = x / y
 z: Int = 6
 \end{lstlisting}
 \noindent
-Why the kerfuffle about values? Well, values are \emph{immutable}. You cannot
+Why the kerfuffle about values? Well, values are \emph{immutable}. You
-change their value after you defined them. If you try to reassign
+cannot change their value after you defined them. If you try to reassign
 \code{z} above, Scala will yell at you:
 \begin{lstlisting}[numbers=none]
 scala> z = 9
 error: reassignment to val
 ^
 \end{lstlisting}
 \noindent
 So it would be a bit absurd to call values as variables...you cannot
-change them. You might think you can re-assign them like
+change them; they cannot vary. You might think you can re-assign them like
 \begin{lstlisting}[numbers=none]
 scala> val x = 42
 scala> val z = x / 7
 scala> val x = 70
 lower case, like \code{x}, \code{y}, \code{foo41} and so on.
 \subsection*{Function Definitions}
-We do functional programming. So defining functions will be our main occupation.
+We do functional programming! So defining functions will be our main occupation.
-A function \code{f} taking a single argument of type \code{Int} can be defined in Scala
+A function named, lets say, \code{f} taking a single argument of type
-as follows:
+\code{Int} can be defined in Scala as follows:
 \begin{lstlisting}[numbers=none]
-def f(x: Int) : String = EXPR
+def f(x: Int) : String = ...EXPR...
 \end{lstlisting}
 \noindent
 This function returns the value resulting from evaluating the expression
 \code{EXPR} (whatever is substituted for this). The result will be
-of type \code{String}. It is a good habbit to include this information
+of type \code{String}. It is a good habit to include this information
 about the return type always. Simple examples of Scala functions are:
 \begin{lstlisting}[numbers=none]
 def incr(x: Int) : Int = x + 1
 def double(x: Int) : Int = x + x
 requires that the generic traversal functions can cope with
 any kind of function (not just functions that, for example,
 take as input an integer and produce a string like above).
 This means we cannot fix the type of the generic traversal
 functions, but have to keep them
-\emph{polymorphic}.\footnote{Another interestic topic about
+\emph{polymorphic}.\footnote{Another interesting topic about
 types, but we omit it here for the sake of brevity.}
 There is one more type constructor that is rather special. It
 is called \code{Unit}. Recall that \code{Boolean} has two
 values, namely \code{true} and \code{false}. This can be used,
 % expressions from the inductive datatype.
 \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 181	31ba76ce016d
parent 180	35b4dc785a40
child 182	d3d912d7e17f