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

equal deleted inserted replaced

-:c50b074b3047
+:c3e39fdeea3b
+% !TEX program = xelatex
 \documentclass{article}
 \usepackage{../style}
 \usepackage{../langs}
 \usepackage{marvosym}
 \usepackage{boxedminipage}
 % https://www.youtube.com/watch?v=QdVFvsCWXrA
 % functional programming in Scala
 %https://www.amazon.com/gp/product/1449311032/ref=as_li_ss_tl?ie=UTF8&tag=aleottshompag-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1449311032
-% functional programmming in C
+% functional programming in C
 %https://www.amazon.com/gp/product/0201419505/ref=as_li_ss_tl?ie=UTF8&camp=1789&creative=390957&creativeASIN=0201419505&linkCode=as2&tag=aleottshompag-20
 %speeding through haskell
 %https://openlibra.com/en/book/download/speeding-through-haskell
 \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
+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
 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 a source code editor. Anybody knows the what the
+Studio Code is considered as a source code editor. Anybody knows the 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 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 are even online editors and environments for
-developing and running Scala programs called \textit{ScalaFiddle}
+developing and running Scala programs: \textit{ScalaFiddle}
-and \textit{Scastie}, which
+and \textit{Scastie} are two of them. They require zero setup
-require zero setup (assuming you have a browser handy). You can access
+(assuming you have a browser handy). You can access them at
-them from:
 \begin{quote}
 \url{https://scalafiddle.io}\\
 \url{https://scastie.scala-lang.org}\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.
 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}
 programming seems to go against the core principles of
 \textit{imperative programming} (which is what you do in Java and C++
 for example). 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 object, or for adding one to a variable and so on. The classic
+array or for adding one to a variable and so on. The classic
-example for this style of programming are \texttt{for}-loops, like
+example for this style of programming are \texttt{for}-loops in C:
 \begin{lstlisting}[language=C,numbers=none]
 for (int i = 10; i < 20; i++) {
 //...Do something interesting with i...
 }
 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
+implement an object that is an instance of \code{App}. For example
+write
 \begin{lstlisting}[numbers=none]
 object Hello extends App {
 println("hello world")
 }
 \end{lstlisting}
-\noindent save it in a file, for example {\tt hello-world.scala}, and
+\noindent save it in a file, say {\tt hello-world.scala}, and
 then run the compiler (\texttt{scalac}) and start the runtime
 environment (\texttt{scala}):
 \begin{lstlisting}[language={},numbers=none,basicstyle=\ttfamily\small]
 $ scalac hello-world.scala
 \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 habit to include this information
+of type \code{String}. It is a good habit to always include this information
-about the return type always. Simple examples of Scala functions are:
+about the return type. 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
 BODY
 }
 \end{lstlisting}
 \noindent
-where each argument requires its type and the result type of the
+where each argument, \texttt{arg1}, \texttt{arg2} and so on, requires
-function, \code{rty}, should be given. If the body of the function is
+its type and the result type of the
+function, \code{rty}, should also 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 (that is call themselves),
 like the venerable factorial function:
 \begin{lstlisting}[numbers=none]
 scala> (1 to 8).toList
 res1: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8)
 \end{lstlisting}
-\noindent Generating from this list, the list of squares in a
+\noindent Generating from this list the list of corresponding
-programming language such as Java, you would assume the list
+squares in a programming language such as Java, you would assume
-is given as a kind of array. You would then iterate, or loop,
+the list is given as a kind of array. You would then iterate, or loop,
 an index over this array and replace each entry in the array
 by the square. Right? In Scala, and in other functional
 programming languages, you use maps to achieve the same.
 A map essentially takes a function that describes how each
 res2: List[Int] = List(1, 4, 9, 16, 25, 36, 49, 64)
 \end{lstlisting}
 \noindent The important keywords are \code{for} and
 \code{yield}. This for-comprehension roughly states that from
-the list of numbers we draw \code{n}s and compute the result
+the list of numbers we draw elements that are given the name
-of \code{n * n}. As you can see, we specified the list where
+\code{n} and compute the result
+of \code{n * n}. This is a simple example---what comes after
+\code{yield} can be a complex expression enclosed in \texttt{\{...\}}.
+As you can see, we specified the list where
 each \code{n} comes from, namely \code{(1 to 8).toList}, and
 how each element needs to be transformed. This can also be
 expressed in a second way in Scala by using directly
 \code{map}s as follows:
 reminders modulo 3). What happens if we just want to print out
 a list of integers? Then actually the for-comprehension
 needs to be modified. The reason is that \code{print}, you
 guessed it, does not produce any result, but only produces
 what is in the functional-programming-lingo called a
-side-effect. Printing out the list of numbers from 1 to 5
+\emph{side-effect}. Printing out the list of numbers from 1 to 5
 would look as follows
 \begin{lstlisting}[numbers=none]
 scala> for (n <- (1 to 5).toList) print(n)
 12345
 where you need to omit the keyword \code{yield}. You can
 also do more elaborate calculations such as
 \begin{lstlisting}[numbers=none]
 scala> for (n <- (1 to 5).toList) {
-val square_n = n * n
+val square = n * n
-println(s"$n * $n = $square_n")
+println(s"$n * $n = $square")
 }
 1 * 1 = 1
 2 * 2 = 4
 3 * 3 = 9
 4 * 4 = 16
 5 * 5 = 25
 \end{lstlisting}%$
 \noindent In this code I use a variable assignment (\code{val
-square_n = ...} ) and also what is called in Scala a
+square = ...} ) and also what is called in Scala a
 \emph{string interpolation}, written \code{s"..."}. The latter
 is for printing out an equation. It allows me to refer to the
 integer values \code{n} and \code{square\_n} inside a string.
 This is very convenient for printing out ``things''.
 You might ask: Apart from silly functions like above, what is
 the point of having functions as input arguments to other
 functions? In Java there is indeed no need of this kind of
 feature: at least in the past it did not allow such
-constructions. I think, the point of Java 8 is to lift this
+constructions. I think, the point of Java 8 and successors was to lift this
 restriction. But in all functional programming languages,
 including Scala, it is really essential to allow functions as
 input argument. Above you already seen \code{map} and
 \code{foreach} which need this. Consider the functions
 \code{print} and \code{println}, which both print out strings,
 % \noindent Again I leave it to you to find out how much this
 % simplifies the regular expression in comparison with if I had
 % to write this by hand using only the ``plain'' regular
 % expressions from the inductive datatype.
-\bigskip\noindent
+%\bigskip\noindent
-\textit{More TBD.}
+%\textit{More TBD.}
-\subsection*{Coursework}
+%\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
+this document and teach in the lectures. Fortunately there are a
+number of free books
 about Scala and of course lots of help online. For example
 \begin{itemize}
 \item \url{http://www.scala-lang.org/docu/files/ScalaByExample.pdf}
 \item \url{http://www.scala-lang.org/docu/files/ScalaTutorial.pdf}
 \item \url{http://docs.scala-lang.org/tutorials}
 \item \url{https://www.scala-exercises.org}
 \item \url{https://twitter.github.io/scala_school}
 \end{itemize}
-\noindent There is also a course at Coursera on Functional
+\noindent There is also an online course at Coursera on Functional
 Programming Principles in Scala by Martin Odersky, the main
 developer of the Scala language. And a document that explains
 Scala for Java programmers
 \begin{itemize}
 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 taking on many
+language is lately developing at lightening speed (in comparison to the past)
+taking on many
 features of Scala and other languages, and it seems even it introduces
 new features on its own.
 %So all in all, Scala might not be a great teaching language,
 %but I hope this is mitigated by the fact that I never require
 %with.
 \subsection*{Conclusion}
-\begin{itemize}
+I hope you like the short journey in the Scala World: remember we
-\item no exceptions....there two kinds, one ``global'' exceptions, like
+like you to take on board the functional programming point of view,
-out of memory (not much can be done about this by the ``individual''
+rather than just learning another language. If you moan about all the
-programmer); and ``local one'' open a file that might not exists - in
+idiotic features of Scala, well that is part of the packaged according
-the latter you do not want to use exceptions, but Options
+to this quote:\bigskip
-\end{itemize}
+%\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''
+%programmer); and ``local one'' open a file that might not exists - in
+%the latter you do not want to use exceptions, but Options
+%\end{itemize}
 \begin{flushright}\it
 There are only two kinds of languages: the ones people complain
 about\\ and the ones nobody uses.\smallskip\\
 \mbox{}\hfill\small{}---Bjarne Stroustrup (the inventor of C++)

changeset 197	c3e39fdeea3b
parent 195	fc3ac7b70a06
child 198	d59c7995bcb2