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

equal deleted inserted replaced

-:2f989951d147
+:f78b18c4c886
 %cheat sheet
 %http://worldline.github.io/scala-cheatsheet/
 % case class, apply, unapply
 % see https://medium.com/@thejasbabu/scala-pattern-matching-9c9e73ba9a8a
+% the art of programming
+% 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
+%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
+% fp books --- ocaml
+% http://courses.cms.caltech.edu/cs134/cs134b/book.pdf
+% http://alexott.net/en/fp/books/
 \begin{document}
 \fnote{\copyright{} Christian Urban, King's College London, 2017, 2018}
 \section*{A Crash-Course in Scala}
 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}}
-A number of companies---the Guardian, Twitter, Coursera, FourSquare, Netflix,
+A number of companies---the Guardian, Twitter, Coursera, FourSquare,
-LinkedIn to name a few---either use Scala exclusively in
+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}
 \end{quote}
 \noindent
 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}, which
+obviously Windows.\footnote{Unlike \emph{Microsoft Visual Studio}---note
-is a heavy-duty, Windows-only IDE\ldots{}jeez, could they have not just
+the minuscule difference in the name---which is a heavy-duty,
-made up some different name for a complete different project? For the
+Windows-only IDE\ldots{}jeez, with all their money could they not come
-pedantic, Microsoft Visual Studio is an IDE, whereas Visual Studio Code
+up with a completely different name for a complete different project?
-is a source code editor. Anybody knows the what the difference is?} It
+For the pedantic, Microsoft Visual Studio is an IDE, whereas Visual
-can be downloaded for free from
+Studio Code is 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}
 \begin{quote}
 \url{http://scala-ide.org/download/sdk.html}
 \end{quote}
 \noindent
-Also IntelliJ includes plugins for Scala. \textbf{BUT}, I do \textbf{not}
+Also IntelliJ includes plugins for Scala. \underline{\textbf{BUT}},
-recommend the usage of either Eclipse or IntelliJ for PEP: these IDEs
+I do \textbf{not} recommend the usage of either 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{}for example why on earth am I required to create a
 completely new project with several subdirectories when I just want to
 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++
 for example). The main idea of imperative programming  is that you have
-some form of ``state'' in your program and you continuously change this
+some form of \emph{state} in your program and you continuously change this
-state by issuing some commands (e.g.~updating a field in an array or
+state by issuing some commands---for example for updating a field in an
-object, adding one to a variable and so on). The classic example for
+array or object, or for adding one to a variable and so on. The classic
-this style of programming are \texttt{for}-loops, for example
+example for this style of programming are \texttt{for}-loops, like
 \begin{lstlisting}[language=C,numbers=none]
 for (int i = 10; i < 20; i++) {
 //...Do something interesting with i...
 }
 is first set to \texttt{10} and then increased by one in each
 loop-iteration until it reaches \texttt{20} at which point the loop
 exits. When this code is compiled and actually runs, there will be some
 dedicated space reserved for \texttt{i} in memory. This space of
 typically 32 bits contains \texttt{i}'s current value\ldots\texttt{10}
-at the beginning, and then the content will be updated by, or
+at the beginning, and then the content will be overwritten with some
-overwritten with, some new content in every iteration. The main point
+new content in every iteration. The main point here is that this kind of
-here is that this kind of updating, or manipulating, memory is
+updating, or manipulating, memory is 25.806\ldots or \textbf{THE ROOT OF
-25.806\ldots or \textbf{THE ROOT OF ALL EVIL}!!
+ALL EVIL}!!
 \begin{center}
 \includegraphics[scale=0.25]{../pics/root-of-all-evil.png}
 \end{center}
 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
-it is easy to parallelize the resulting programs: if you do not have any
+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 makes it very easy to calculate the
 Mandelbrot set on as many cores of your CPU as possible. Why is it so
 \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
+A Scala program for generating pretty pictures of the Mandelbrot set.\smallskip\\
-(\url{https://en.wikipedia.org/wiki/Mandelbrot_set},
+(See \url{https://en.wikipedia.org/wiki/Mandelbrot_set} or\\
-\url{https://www.youtube.com/watch?v=aSg2Db3jF_4}):
+\phantom{(See }\url{https://www.youtube.com/watch?v=aSg2Db3jF_4}):
 \begin{center}
 \begin{tabular}{c}
-\includegraphics[scale=0.12]{../pics/mand1.png}
+\includegraphics[scale=0.11]{../pics/mand1.png}\\[-8mm]\mbox{}
 \end{tabular}
 \end{center}
 \begin{center}
 \begin{tabular}{@{}p{0.45\textwidth}|p{0.45\textwidth}@{}}
-\bf sequential version: & \bf parallel version (on 4 cores):\smallskip\\
+\bf sequential version: & \bf parallel version on 4 cores:\smallskip\\
-{\hfill\includegraphics[scale=0.12]{../pics/mand4.png}\hfill} &
+{\hfill\includegraphics[scale=0.11]{../pics/mand4.png}\hfill} &
-{\hfill\includegraphics[scale=0.12]{../pics/mand3.png}\hfill} \\
+{\hfill\includegraphics[scale=0.11]{../pics/mand3.png}\hfill} \\
 {\footnotesize\begin{lstlisting}[xleftmargin=-1mm]
 for (y <- (0 until H)) {
 for (x <- (0 until W)) {
 val c = start +
 (x * d_x + y * d_y * i)
 val iters = iterations(c, max)
-val col =
+val colour =
 if (iters == max) black
 else colours(iters % 16)
-pixel(x, y, col)
+pixel(x, y, colour)
 }
 viewer.updateUI()
 }
 \end{lstlisting}}
 &
 for (x <- (0 until W)/*@\keys{\texttt{.par}}@*/) {
 val c = start +
 (x * d_x + y * d_y * i)
 val iters = iterations(c, max)
-val col =
+val colour =
 if (iters == max) black
 else colours(iters % 16)
-pixel(x, y, col)
+pixel(x, y, colour)
 }
 viewer.updateUI()
 }
-\end{lstlisting}}\\
+\end{lstlisting}}\\[-2mm]
 \centering\includegraphics[scale=0.5]{../pics/cpu2.png} &
 \centering\includegraphics[scale=0.5]{../pics/cpu1.png}
 \end{tabular}
 \end{center}
-\caption{The main ``loops'' creating the picture of the Mandelbrot set. The parallel version
+\caption{The ``main'' loops in the Mandelbrot program.
-only differs in \texttt{.par} added to the ``ranges'' of the x-y-coordinates. As can be
+The parallel version differs only in \texttt{.par} being added to the
-seen from the CPU loads: in the sequential versions there is a lower peak for an
+``ranges'' of the x-y-coordinates. As can be seen from the CPU loads, in
-extended period, while in the parallel version there is a short sharp burst for
+the sequential versions there is a lower peak for an extended period,
-essentially the same workload.
+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}
+only works reliably in an immutable program.
 \label{mand}}
 \end{boxedminipage}
 \end{figure}
 But remember this easy parallelisation of code requires that we
 often than not easier to understand). So have fun with
 Scala!\footnote{If you are still not convinced about the function
 programming ``thing'', there are a few more arguments: a lot of research
 in programming languages happens to take place in functional programming
 languages. This has resulted in ultra-useful features such as
-pattern-matching, strong type-systems, lazyness, implicits, algebraic
+pattern-matching, strong type-systems, laziness, implicits, algebraic
 datatypes  to name a few. Imperative languages seem to often lag behind
 in adopting them: I know, for example, that Java will at some point in
-the future support pattern-matching, which has been used in SML for at
+the future support pattern-matching, which has been used for example
+in SML for at
 least 40(!) years. See
 \url{http://cr.openjdk.java.net/~briangoetz/amber/pattern-match.html}.
 Also Rust, a C-like programming language that has been developed since
 2010 and is gaining quite some interest, borrows many ideas from
 functional programming from yesteryear.}
 \begin{center}
 \url{http://scalapuzzlers.com} and
 \url{http://latkin.org/blog/2017/05/02/when-the-scala-compiler-doesnt-help/}
 \end{center}
-Even if Scala has been a success in several high-profile
+Even if Scala has been a success in several high-profile companies,
-companies, there is also a company (Yammer) that first used
+there is also a company (Yammer) that first used Scala in their
-Scala in their production code, but then moved away from it.
+production code, but then moved away from it. Allegedly they did not
-Allegedly they did not like the steep learning curve of Scala
+like the steep learning curve of Scala and also that new versions of
-and also that new versions of Scala often introduced
+Scala often introduced incompatibilities in old code. Also the Java
-incompatibilities in old code. In the past two months
+language is lately developing at lightening speed taking on many
-there have also been two forks of the Scala compiler.
+features of Scala and other languages, and it seems even it introduces
-It needs to be seen what the future brings for Scala.
+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
 %you to write any Scala code. You only need to be able to read
 %it. In the coursework you can use any programming language you
 %like. If you want to use Scala for this, then be my guest; if
 %you do not want, stick with the language you are most familiar
 %with.
+\subsection*{Conclusion}
+\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 191	f78b18c4c886
parent 190	2f989951d147
child 193	ae307c3de4ee