several improvements and more examples of exception handling

Author: thomasWeise

scripts/pdflatex.sh

@@ -121,8 +121,9 @@ echo "$(date +'%0Y-%0m-%0d %0R:%0S'): We will now perform runs of the tool chain
 watchFileContents=""
 oldWatchFileContents="old"
 cycle=0
+additional=1
 
-while [ "$watchFileContents" != "$oldWatchFileContents" ] ; do
+while (("$additional" >= 0))  ; do
   cycle=$((cycle+1))
   echo "$(date +'%0Y-%0m-%0d %0R:%0S'): Now beginning build cycle $cycle."
 
@@ -238,9 +239,17 @@ while [ "$watchFileContents" != "$oldWatchFileContents" ] ; do
     echo "$(date +'%0Y-%0m-%0d %0R:%0S'): Something odd is happening: We have performed $cycle cycles. That's too many. Let's quit."
     break
   fi
+
+  if [ "$watchFileContents" != "$oldWatchFileContents" ] ; then
+    echo "$(date +'%0Y-%0m-%0d %0R:%0S'): Auxiliary file contents changed. We need more cycles."
+    additional=1
+  else
+    echo "$(date +'%0Y-%0m-%0d %0R:%0S'): Auxiliary file contents did not change. We do $additional more cycle(s)."
+    additional=$(($additional-1))
+  fi
 done
 
-echo "$(date +'%0Y-%0m-%0d %0R:%0S'): The tool chain has been applied until nothing changed anymore. We now check for errors."
+echo "$(date +'%0Y-%0m-%0d %0R:%0S'): The tool chain has been applied until nothing changed anymore (after $cycle cycles). We now check for errors."
 
 latexWarningsCount=0
 latexWarningString=""

text/back/scripts.tex

@@ -61,7 +61,7 @@
 \Cref{lst:bash:pylint} offers exactly the same functionality for \pylint.
 It checks if this tool is installed and installs it if not.
 It then applies \pylint\ to a the selected set of files, using a reasonable default configuration.
-\Cref{exec:loops:for_loop_no_enumerate:pylint} is an example for the output of this \pgls{linter}.
+\Cref{exec:loops:for_loop_no_enumerate:pylint} is an example of the output of this \pgls{linter}.
 
 \Cref{lst:bash:pytest} is similarly structured, but instead of performing \emph{static} code analysis, it executes unit test cases.
 The directory and list of \python\ files with the test cases are provided as command line arguments.

text/main/basics/collections/dictionaries/dictionaries.tex

@@ -2,7 +2,7 @@
 \label{sec:dictionaries}%
 %
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{02_collections}{dicts_1.py}{--args format}{dicts:dicts_1}{%
-An example for using dictionaries in \python.}%
+An example of using dictionaries in \python.}%
 %
 Dictionaries in \python\ are containers that store key-value pairs.
 The value associated with a given key is accessed via the \pythonil{[...]}\pythonIdx{[\idxdots]}-based indexing.

text/main/basics/collections/lists/lists.tex

@@ -11,10 +11,10 @@
 A first example for using lists in \python: creating, indexing, printing of and appending elements and other lists to lists.}%
 %
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{02_collections}{lists_2.py}{--args format}{lists:lists_2}{%
-A second example for using lists in \python: inserting and deleting elements, sorting and reversing lists.}%
+A second example of using lists in \python: inserting and deleting elements, sorting and reversing lists.}%
 %
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{02_collections}{lists_3.py}{--args format}{lists:lists_3}{%
-A third example for using lists in \python: slicing, adding, and multiplying lists.}%
+A third example of using lists in \python: slicing, adding, and multiplying lists.}%
 %
 In \cref{lst:lists:lists_1}, we provide some first examples for using lists.
 A list can be defined by simply writing its contents, separated by~\pythonilIdx{,} inside square brackets~\pythonil{[...]}\pythonIdx{[\idxdots]}.
@@ -140,7 +140,7 @@
 \FloatBarrier%
 \endhsection%
 %
-\hsection{An Example for Errors and a new Tool}%
+\hsection{An Example of Errors and a new Tool}%
 \label{sec:listExampleForErrorsAndRuff}%
 %
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{02_collections}{lists_error.py}{--args format}{lists:lists_error}{%

text/main/basics/collections/sets/sets.tex

@@ -2,11 +2,11 @@
 \label{sec:sets}%
 %
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{02_collections}{sets_1.py}{--args format}{sets:sets_1}{%
-A first example for using sets in \python: creating, modifying, and converting sets. %
+A first example of using sets in \python: creating, modifying, and converting sets. %
 Since sets are unordered, printing them can yield a different result each time a program is executed (see \cref{bp:setsUnordered}).}%
 %
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{02_collections}{sets_2.py}{--args format}{sets:sets_2}{%
-A second example for using sets in \python: creating sets and set operations (as illustrated in \cref{fig:setOperations}). %
+A second example of using sets in \python: creating sets and set operations (as illustrated in \cref{fig:setOperations}). %
 Since sets are unordered, printing them can yield a different result each time a program is executed (see \cref{bp:setsUnordered}).}%
 %
 \begin{figure}%
@@ -50,7 +50,7 @@
 If we have more than just very few elements and/or need to perform set operations such as those discussed in the following text, sets are the way to go.%
 %
 \begin{sloppypar}%
-In \cref{lst:sets:sets_1}, we provide a first example for creating and working with sets.
+In \cref{lst:sets:sets_1}, we provide a first example of creating and working with sets.
 Sets can be created by using curly braces, i.e, \pythonil{\{...\}}\pythonIdx{\textbraceleft\idxdots\textbraceright!set}.
 They can be type-hinted using the notation \pythonil{set[elementType]}\pythonIdx{set!type hint} where \pythonil{elementType} is the type of elements to be stored in the set~\cite{PEP585}.
 The line \pythonil{upper: set[str] = \{"A", "G", "B", "T", "V"\}} creates the variable \pythonil{upper}, which points to a set of the five uppercase latin characters~\pythonil{"A"}, \pythonil{"G"}, \pythonil{"B"}, \pythonil{"T"}, and~\pythonil{"V"}.

text/main/basics/collections/tuples/tuples.tex

@@ -2,13 +2,13 @@
 \label{sec:tuples}%
 %
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{02_collections}{tuples_1.py}{--args format}{tuples:tuples_1}{%
-A first example for using tuples in \python: creating, indexing, and printing of tuples.}%
+A first example of using tuples in \python: creating, indexing, and printing of tuples.}%
 %
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{02_collections}{tuples_2.py}{--args format}{tuples:tuples_2}{%
-A second example for using tuples in \python: tuples with elements of different types and tuple unpacking.}%
+A second example of using tuples in \python: tuples with elements of different types and tuple unpacking.}%
 %
 \gitPythonAndErrorOutput{\programmingWithPythonCodeRepo}{02_collections}{tuples_3.py}{--args format}{tuples:tuples_3}{%
-A third example for using tuples in \python: testing the immutability property.}%
+A third example of using tuples in \python: testing the immutability property.}%
 %
 \gitOutputTool{\programmingWithPythonCodeRepo}{.}{scripts/mypy.sh 02_collections tuples_3.py}{tuples:tuples_3:mypy}{%
 The results of static type checking with \mypy\ of the program given in \cref{lst:tuples:tuples_3}.}%

text/main/basics/gettingStarted/pythonInTheTerminal/pythonInTheTerminal.tex

@@ -26,7 +26,7 @@
 \label{fig:terminalPython3result}%
 ]{\includegraphics[width=0.9\linewidth]{\currentDir/terminalPython3result}}%
 %
-\caption{Example for executing a \python\ program in a \pgls{terminal} (on \ubuntu).}%
+\caption{Example of executing a \python\ program in a \pgls{terminal} (on \ubuntu).}%
 \label{fig:terminalPython}%
 \end{figure}%
 %

text/main/basics/simpleDataTypesAndOperations/float/float.tex

@@ -134,7 +134,7 @@
 They are off by \emph{less than~$10^{-15}$} so for all practical concerns, they are close enough.
 Sometimes, we even get the accurate result, e.g., when computing $\ln(e^{10})$ by evaluating \pythonil{log(e ** 10)}\pythonIdx{log}, which results in~\pythonil{10.0}.
 
-As final example for floating point arithmetics, let us import the inverse trigonometric functions by doing \pythonil{from math import asin, acos, atan}\pythonIdx{math}\pythonIdx{asin}\pythonIdx{acos}\pythonIdx{atan}.
+As final example of floating point arithmetics, let us import the inverse trigonometric functions by doing \pythonil{from math import asin, acos, atan}\pythonIdx{math}\pythonIdx{asin}\pythonIdx{acos}\pythonIdx{atan}.
 Obviously, $\arcsin{\sin{0.925}}$ should be~$0.925$.
 Calculating \pythonil{asin(sin(0.925))}\pythonIdx{asin}\pythonIdx{sin} indeed yields~\pythonil{0.9250000000000002}.
 Due to the periodicity of the trigonometric functions, $\arccos{\cos{-0.3}}$ is~$0.3$ and \pythonil{acos(cos(-0.3))}\pythonIdx{acos}\pythonIdx{cos} results in~\pythonil{0.30000000000000016}.

text/main/basics/variables/assignment/assignment.tex

@@ -5,7 +5,7 @@
 You can define a variable and assign its value by writing \pythonil{name = value}.
 Here, \pythonil{name} is the name of the variable and \pythonil{value} be the value that we want to assign to that name.%
 %
-\hsection{A Simple Example for Variable Assignment and Comments in the Code}%
+\hsection{A Simple Example of Variable Assignment and Comments in the Code}%
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{01_variables}{assignment.py}{--args format}{variables:assignment}{%
 A \python\ program showing some examples for variable assignments.}%
 %

text/main/basics/variables/identity/identity.tex

@@ -21,10 +21,10 @@
 \end{figure}%
 %
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{01_variables}{identity_1.py}{--args format}{variables:identity_1}{%
-An example for the difference between equality and identity\pythonIdx{sqrt}.}%
+An example of the difference between equality and identity\pythonIdx{sqrt}.}%
 %
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{01_variables}{identity_2.py}{--args format}{variables:identity_2}{%
-An second example for the difference between equality and identity.}%
+An second example of the difference between equality and identity.}%
 %
 We use variables to references objects in memory.
 When we compare two variables, we actually compare the objects they reference.
@@ -51,7 +51,7 @@
 If I would declare a variable \pythonil{d = a}, then \pythonil{d} would point to exactly the same \pythonil{float} object as~\pythonil{a}.
 Now, both \pythonil{a == b} and \pythonil{a is b} are \pythonil{True}.
 
-A simple example for the difference between equality and identity is given in \cref{lst:variables:identity_1}.
+A simple example of the difference between equality and identity is given in \cref{lst:variables:identity_1}.
 Here, we declare a \pythonil{float} variable and store in it the value of~$\sqrt{2}$ (as exactly as it can be represented by a \python\ \pythonil{float}, that is), which just so happens to be \pythonil{1.4142135623730951}.
 We then import the function \pythonilIdx{sqrt} from the \pythonilIdx{math} module and compute~\pythonil{sqrt(2.0)}.
 We store the result of this in a second variable, namely \pythonil{sqrt_2_computed}.
@@ -66,7 +66,7 @@
 First-time readers are welcome to skip over the rest of this subsection.%
 }%
 %
-A slightly more involved example for the issue of object equality and identity is given in \cref{lst:variables:identity_2}.
+A slightly more involved example of the issue of object equality and identity is given in \cref{lst:variables:identity_2}.
 You see, when the \python\ interpreter parses the program code file, it will allocate the memory and store the values of constants and literals.
 \cref{lst:variables:identity_2}, we declare \pythonil{a = "Hello World!"} and then \pythonil{b = "Hello World!"}.
 In other words, \pythonil{a} and \pythonil{b} will receive the same value.

text/main/basics/variables/typesAndTypeHints/typesAndTypeHints.tex

@@ -3,7 +3,7 @@
 %
 \hsection{Variable Types}%
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{01_variables}{variable_types.py}{--args format}{variables:types}{%
-An example for the types of variables.}%
+An example of the types of variables.}%
 %
 A variable is basically a name pointing to an object.
 Each object has a type and we already learned about several of these datatypes in \cref{sec:simplyDataTypesAndOperations}.
@@ -16,7 +16,7 @@
 \hsection{Types and Confusion}%
 \label{sec:typesAndConfusion}%
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{01_variables}{variable_types_wrong.py}{--args format}{variables:types_wrong}{%
-An example for the confusing variable types.}
+An example of the confusing variable types.}
 
 Well, actually, there is.
 You see, when you declare a variable in a language like \pgls{C}, you have to specify its \emph{type}.

text/main/controlFlow/conditionals/conditionals.tex

@@ -23,7 +23,7 @@
 %
 \FloatBarrier%
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{03_conditionals}{if_example.py}{--args format}{conditionals:if}{%
-An example for using the \pythonilIdx{if} statement.}%
+An example of using the \pythonilIdx{if} statement.}%
 %
 The first line begins with \pythonilIdx{if}~statement, followed by a Boolean expression, followed by a colon~(\pythonilIdx{:}).
 If -- and only if -- the Boolean expression evaluates to~\pythonilIdx{True}, then the \emph{indented} block of statements below the \pythonil{if} are executed.
@@ -66,10 +66,10 @@
 \hsection{The \texttt{if}\idxdots\texttt{else} Statement}%
 %
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{03_conditionals}{if_else_example.py}{--args format}{conditionals:if_else}{%
-An example for using the \pythonil{if ... else}\pythonIdx{if{\idxdots}else} statement.}%
+An example of using the \pythonil{if ... else}\pythonIdx{if{\idxdots}else} statement.}%
 %
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{03_conditionals}{if_else_nested.py}{--args format}{conditionals:if_else_nested}{%
-An example for using nested \pythonil{if ... else}\pythonIdx{if{\idxdots}else!nested} statements.}%
+An example of using nested \pythonil{if ... else}\pythonIdx{if{\idxdots}else!nested} statements.}%
 %
 The ability to perform some action if a given expression evaluates to \pythonil{True} is already nice.
 However, often we want to perform some action if the expression evaluates to \pythonil{True} and another action otherwise.
@@ -136,13 +136,13 @@
 \hsection{The \texttt{if}\idxdots\texttt{elif}\idxdots\texttt{else} Statement}%
 %
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{03_conditionals}{if_elif_example.py}{--args format}{conditionals:if_elif}{%
-An example for using the \pythonil{if ... elif}\pythonIdx{if{\idxdots}elif{\idxdots}else} statement.}%
+An example of using the \pythonil{if ... elif}\pythonIdx{if{\idxdots}elif{\idxdots}else} statement.}%
 %
 \gitOutputTool{\programmingWithPythonCodeRepo}{.}{scripts/ruff.sh 03_conditionals if_else_nested.py}{conditionals:if_else_nested:ruff}{%
 The results of linting with \ruff\ of the program given in \cref{lst:conditionals:if_else_nested}.}%
 %
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{03_conditionals}{if_elif_nested.py}{--args format}{conditionals:if_elif_nested}{%
-An example for using the nested \pythonil{if ... elif}\pythonIdx{if{\idxdots}elif{\idxdots}else!nested} statement based on the recommendations of the \ruff\ \pgls{linter} applied to \cref{lst:conditionals:if_else_nested}.}%
+An example of using the nested \pythonil{if ... elif}\pythonIdx{if{\idxdots}elif{\idxdots}else!nested} statement based on the recommendations of the \ruff\ \pgls{linter} applied to \cref{lst:conditionals:if_else_nested}.}%
 %
 %
 In some cases, we need to query a sequence of alternatives in such a way that \pythonilIdx{else}~blocks would be nested over \pythonilIdx{else}~blocks over \pythonilIdx{else}~blocks, and so on.
@@ -218,14 +218,14 @@
 \label{sec:inlineIfThenElse}%
 %
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{03_conditionals}{if_else_could_be_inline.py}{--args format}{conditionals:if_else_could_be_inline}{%
-An example for using the nested \pythonil{if ... else}\pythonIdx{if{\idxdots}elif{\idxdots}else} statements that could be inlined. %
+An example of using the nested \pythonil{if ... else}\pythonIdx{if{\idxdots}elif{\idxdots}else} statements that could be inlined. %
 See \cref{lst:conditionals:inline_if_else} for the more compact inlined variant.}%
 %
 \gitOutputTool{\programmingWithPythonCodeRepo}{.}{scripts/ruff.sh 03_conditionals if_else_could_be_inline.py}{conditionals:if_else_could_be_inline:ruff}{%
 The results of linting with \ruff\ of the program given in \cref{lst:conditionals:if_else_could_be_inline}.}%
 %
 \gitPythonAndOutput{\programmingWithPythonCodeRepo}{03_conditionals}{inline_if_else.py}{--args format}{conditionals:inline_if_else}{%
-An example for using the inline \pythonil{if ... else}\pythonIdx{if{\idxdots}else!inline} expression to shorten \cref{lst:conditionals:if_else_could_be_inline}, which incorporates the suggestion by \ruff\ in \cref{exec:conditionals:if_else_could_be_inline:ruff}.}%
+An example of using the inline \pythonil{if ... else}\pythonIdx{if{\idxdots}else!inline} expression to shorten \cref{lst:conditionals:if_else_could_be_inline}, which incorporates the suggestion by \ruff\ in \cref{exec:conditionals:if_else_could_be_inline:ruff}.}%
 %
 A very common use case of \pythonil{if...else}~statements is to assign values to variables.
 In \cref{lst:conditionals:if_else_could_be_inline} we display such a situation.
@@ -269,7 +269,7 @@
 Before this, we could only perform straightforward computations and calculate the results of simple functions.
 Now our variables can receive the result of a function~$A$ if the input meets a condition~$B$ and otherwise the result of a function~$C$.
 This is already quite nice.
-For example, we can now implement and hard-code decision trees~\cite{RN2022AIAMA,SSBD2014UMLFTTA} and \cref{lst:conditionals:if_elif} is basically an example for that.
+For example, we can now implement and hard-code decision trees~\cite{RN2022AIAMA,SSBD2014UMLFTTA} and \cref{lst:conditionals:if_elif} is basically an example of that.
 Still, the instructions in our programs are still executed in the sequence in which we wrote them down.
 While our control flow can now branch, it cannot perform anything more fancy and advanced {\dots} like looping back upon itself\dots%
 \endhsection%