From a7a3014c3ba68b510e3f7aca3511ed3d7816dc8b Mon Sep 17 00:00:00 2001
From: Noah Peeters <noah.peeters@icloud.com>
Date: Wed, 17 Jan 2018 00:34:13 +0100
Subject: [PATCH 01/11] Small fixes

---
 src/DiskreteMathematik/BoolescheAlgebra.tex  |  2 +-
 src/DiskreteMathematik/FormaleGrundlagen.tex | 14 +++++++-------
 src/Informatik/EinfuehrungProgrammierung.tex |  2 +-
 src/Informatik/InformatikGesellschaft.tex    |  2 +-
 src/Informatik/TechnischeGrundlagen.tex      |  2 +-
 src/Seminare/RhetorikI.tex                   |  5 ++---
 src/Seminare/WissenschaftlichesArbeiten.tex  |  2 +-
 src/Sprachen/Englisch.tex                    |  2 +-
 src/Wirtschaft/ABWL.tex                      |  2 +-
 9 files changed, 16 insertions(+), 17 deletions(-)

diff --git a/src/DiskreteMathematik/BoolescheAlgebra.tex b/src/DiskreteMathematik/BoolescheAlgebra.tex
index b119741..e309c48 100644
--- a/src/DiskreteMathematik/BoolescheAlgebra.tex
+++ b/src/DiskreteMathematik/BoolescheAlgebra.tex
@@ -252,4 +252,4 @@
             \begin{equation}
                 (A \rightarrow B) \cdot (B \rightarrow C) \models (A \rightarrow C)
             \end{equation}
-\end{document}
\ No newline at end of file
+\end{document}
diff --git a/src/DiskreteMathematik/FormaleGrundlagen.tex b/src/DiskreteMathematik/FormaleGrundlagen.tex
index 6bb0a85..c16a229 100644
--- a/src/DiskreteMathematik/FormaleGrundlagen.tex
+++ b/src/DiskreteMathematik/FormaleGrundlagen.tex
@@ -8,7 +8,7 @@
     	\subsection{Naive Mengenlehre}
     	    In der naiven Mengenlehre ist eine Menge durch die Elemente, die sie umschließt, definiert.
             Eine einfache Menge kann mit $A = \{a, b, c\}$ beschrieben werden. Dabei ist $A$ der Name der Menge und $a, b, c$ sind die Urelemente der Menge. Dabei sind die Elemente atomar, also nicht weiter zerlegbar und divers bzw. wohlverschieden. Es gilt also $\{a, a, b, c\} = \{a, b, c\}$.
-            \\
+            
             Eine Methode zur Beschreibung einer Menge $B$, welche alle durch zwei teilbaren natürlichen Zahlen enthält, ist:
             
             \begin{equation}
@@ -143,15 +143,15 @@
                     \end{equation}
                     
                 \paragraph{Linkseindeutig oder Injektiv}
-                    Eine Relation ist genau dann linkseindeutig, wenn jedem Element aus $B$ höchstens ein Element aus $A$ zugeordnet wird.
+	                Eine Relation ist genau dann linkseindeutig, wenn jedem Element aus $B$ höchstens ein Element aus $A$ zugeordnet wird.
                     \begin{equation}
-                        \forall b \in B\; \forall a,c \in A\colon \left(a, b\right) \in R \wedge \left(c, b\right) \in R \rightarrow a = c
+                        \forall b \in B\; \forall a, c \in A\colon \left(a, b\right) \in R \wedge \left(c, b\right) \in R \rightarrow a = c
                     \end{equation}
                     
                 \paragraph{Rechtseindeutig}
                     Eine Relation ist genau dann rechtseindeutig, wenn jedem Element aus $A$ höchstens ein Element aus $B$.
                     \begin{equation}
-                        \forall a \in A\; \forall b,d \in B\colon \left(a, b\right) \in R \wedge \left(a, d\right) \in R \rightarrow b = d
+                        \forall a \in A\; \forall b, d \in B\colon \left(a, b\right) \in R \wedge \left(a, d\right) \in R \rightarrow b = d
                     \end{equation}
                     
                 \paragraph{Bitotal}
@@ -271,6 +271,8 @@
                     
                     Die Funktion $\delta^*\colon S \times \Sigma^*$ kann ganze Wörter verarbeiten.
                     
+                
+                    
                 \paragraph{Startzustand}
                     Ein Element $S_0 \in S$ wird als Startzustand festgelegt.
                 
@@ -301,6 +303,4 @@
                 
             \paragraph{Typ 3}
                 Typ 3 Sprachen sind reguläre Sprachen mit einer regulären Grammatik und sind eine Teilmenge der Typ 2 Sprachen.
-        
-        
-\end{document}
\ No newline at end of file
+\end{document}
diff --git a/src/Informatik/EinfuehrungProgrammierung.tex b/src/Informatik/EinfuehrungProgrammierung.tex
index 847ab55..a2333b0 100644
--- a/src/Informatik/EinfuehrungProgrammierung.tex
+++ b/src/Informatik/EinfuehrungProgrammierung.tex
@@ -28,4 +28,4 @@
                 
             \paragraph{Quellprogramm}
                 Quellprogramm\footnote{Auch: Sourcecode} ist ein Programm in einer Hochsprache.
-\end{document}
\ No newline at end of file
+\end{document}
diff --git a/src/Informatik/InformatikGesellschaft.tex b/src/Informatik/InformatikGesellschaft.tex
index dc85dd8..364d592 100644
--- a/src/Informatik/InformatikGesellschaft.tex
+++ b/src/Informatik/InformatikGesellschaft.tex
@@ -12,4 +12,4 @@
         TODO: Content
         
         Bisher war der gesamte Inhalt nur Grundlagen, die im Kursübergreifenden Teil gefunden werden können.
-\end{document}
\ No newline at end of file
+\end{document}
diff --git a/src/Informatik/TechnischeGrundlagen.tex b/src/Informatik/TechnischeGrundlagen.tex
index b63f37d..b958748 100644
--- a/src/Informatik/TechnischeGrundlagen.tex
+++ b/src/Informatik/TechnischeGrundlagen.tex
@@ -88,4 +88,4 @@
             \paragraph{Vektorgrafiken}
                 Vektorgrafiken speichern das Bild mithilfe von primitiven Objekten wie Linien und Kurven. Die eigentlichen Bildinformationen, die auf gerasterten Bildschirmen angezeigt werden können, werden erst berechnet, wenn die Auflößung bekannt ist. Auf diese Weise kann verlustfrei an Bilder gezoomt werden. Vektorgrafiken eignet sich damit sehr für am Computer erstellte Bilder.
             
-\end{document}
\ No newline at end of file
+\end{document}
diff --git a/src/Seminare/RhetorikI.tex b/src/Seminare/RhetorikI.tex
index c304f87..301deed 100644
--- a/src/Seminare/RhetorikI.tex
+++ b/src/Seminare/RhetorikI.tex
@@ -44,7 +44,7 @@
                 \\
                 Nun steht man auf um die Präsentation zu beginnen. Hier kommt es häufig vor, dass unterbewusst die Hände zur Hilfe genommen werden, was im besten Fall vermieden werden sollte. Sobald man aufgerichtet ist entsteht der natürliche Reflex die Kleidung zurecht zu rücken. Dies wirkt unprofessionell und in den allermeisten Fällen sitzt diese bereits angemessen.
                 
-            \subsubsection{erster Blickkontakt}
+            \subsubsection{Erster Blickkontakt}
                 Der unterbewusste, erste Eindruck ist geschaffen und das Publikum bildet sich eine bewusste, zweite Meinung über den Präsentierenden. An dieser Stelle kommt Blickkontakt ins Spiel. Nicht sofort Richtung Bühne los sprinten sondern einen Moment verweilen. Ruhe und Gelassenheit ausstrahlen und diese wertvollen Momente benutzen um einen Blick in die Runde zu wagen. Einen schnellen Blick über die Zuhörerschaft schweifen lassen, kurzzeitig mit den Augen auf bestimmten Personen verweilen und dann die Reise zur Präsentationsfläche antreten.
                 
                 \paragraph{Aufgang} Der Weg zur Bühne sollte auf keinen Fall dafür verwendet werden den Boden genauer zu inspizieren sondern stattdessen dazu verwendet werden einen langsamen Blick in die Runde zu werfen und sich Sympathie-Inseln zu suchen (dazu mehr in Abschnitt \ref{section:Seminar:RhetorikI:SympathieInsel}), während man idealerweise und sofern möglich in einem Halbkreis auf die Bühne schreitet.
@@ -84,5 +84,4 @@
     
     \section*{Danksagung}
         % TODO Thank Jan and the whole crew from Adventure Learning for the weekend and recommend it to the reader.
-    
-\end{document}
\ No newline at end of file
+\end{document}
diff --git a/src/Seminare/WissenschaftlichesArbeiten.tex b/src/Seminare/WissenschaftlichesArbeiten.tex
index 859cc48..5712ab2 100644
--- a/src/Seminare/WissenschaftlichesArbeiten.tex
+++ b/src/Seminare/WissenschaftlichesArbeiten.tex
@@ -50,4 +50,4 @@
                 \item Beobachtungen
             \end{itemize}
     
-\end{document}
\ No newline at end of file
+\end{document}
diff --git a/src/Sprachen/Englisch.tex b/src/Sprachen/Englisch.tex
index 28ecaf3..de0601d 100644
--- a/src/Sprachen/Englisch.tex
+++ b/src/Sprachen/Englisch.tex
@@ -6,4 +6,4 @@
 
     \section{Content}
         No content yet...
-\end{document}
\ No newline at end of file
+\end{document}
diff --git a/src/Wirtschaft/ABWL.tex b/src/Wirtschaft/ABWL.tex
index f3a27e4..209d9ca 100644
--- a/src/Wirtschaft/ABWL.tex
+++ b/src/Wirtschaft/ABWL.tex
@@ -6,4 +6,4 @@
 
     \section{Content}
         No content yet...
-\end{document}
\ No newline at end of file
+\end{document}

From b4d6c761d03fabfe690712424f79a0b7a8432289 Mon Sep 17 00:00:00 2001
From: Noah Peeters <noah.peeters@icloud.com>
Date: Wed, 17 Jan 2018 00:34:42 +0100
Subject: [PATCH 02/11] Added Einfuehrung Programmierung 16.01.2018

---
 src/Informatik/EinfuehrungProgrammierung.tex | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/Informatik/EinfuehrungProgrammierung.tex b/src/Informatik/EinfuehrungProgrammierung.tex
index a2333b0..d33feb6 100644
--- a/src/Informatik/EinfuehrungProgrammierung.tex
+++ b/src/Informatik/EinfuehrungProgrammierung.tex
@@ -28,4 +28,20 @@
                 
             \paragraph{Quellprogramm}
                 Quellprogramm\footnote{Auch: Sourcecode} ist ein Programm in einer Hochsprache.
+                
+    \section{Auswertungsregeln}
+        \paragraph{Syntax}
+            Die Syntax einer Programmiersprache legt zulässige Elemente und Struktur fest.
+            
+        \paragraph{Semantik}
+            Die Semantik einer Programmiersprache legt die Bedeutung von syntaktisch korrekten Ausdrücken fest. Die Semantik funktionaler Programmiersprachen orientiert sich an der Semantik der Mathematik.
+            
+        \paragraph{Ersetzungen}
+            Um die Bedeutung eines Ausdrucks zu bestimmen, werden nacheinander semantisch äquivalente Umformungen mit dem \emph{Ersetzungsmodell für Funktionsanwendungen} durchgeführt. Die Reihenfolge der Auswertung von Teilausdrücken in funktionalen Sprachen hat dabei keine Auswirkung auf das Endergebnis.
+            
+        \paragraph{Self Evaluating Expressions}
+            \emph{Self Evaluating Expressions} sind Ausdrücke, die zu sich selbst ausgewertet werden. In Racket gehören Zahlen zu den \emph{Self Evaluating Expressions}. Die Auswertung eines Ausdrucks ist beendet, wenn eine \emph{Self Evaluating Expressions} erreicht wurde.
+            
+        \paragraph{Funktionsaufruf}
+            Bei strikter Auswertung werden erst alle Argumente eines Funktionsaufrufs berechnet. Diese Verfahren kommt bei Racket zum Einsatz. Diesem Verfahren steht die lazy Auswertung gegenüber, die zum Beispiel in Haskel verwendet wird, bei dem auch die Argumente erst berechnet werden, wenn sie benötigt werden.         
 \end{document}

From 09230d64da9cdf17c71e89d707d8a3fe4fc29894 Mon Sep 17 00:00:00 2001
From: Noah Peeters <noah.peeters@icloud.com>
Date: Wed, 17 Jan 2018 09:33:05 +0100
Subject: [PATCH 03/11] Added transitive, reflxive and symmetric relations

---
 src/Abbildungen/Reflexivitaet_Graph.png      | Bin 0 -> 3757 bytes
 src/Abbildungen/Symmetrie_Graph.png          | Bin 0 -> 4778 bytes
 src/Abbildungen/Transitivitaet_Graph.png     | Bin 0 -> 3495 bytes
 src/DiskreteMathematik/FormaleGrundlagen.tex |  43 +++++++++++++++++++
 4 files changed, 43 insertions(+)
 create mode 100644 src/Abbildungen/Reflexivitaet_Graph.png
 create mode 100644 src/Abbildungen/Symmetrie_Graph.png
 create mode 100644 src/Abbildungen/Transitivitaet_Graph.png

diff --git a/src/Abbildungen/Reflexivitaet_Graph.png b/src/Abbildungen/Reflexivitaet_Graph.png
new file mode 100644
index 0000000000000000000000000000000000000000..3fa30425c4e43b810a0b1c79f3483439f8c5c978
GIT binary patch
literal 3757
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

literal 0
HcmV?d00001

diff --git a/src/Abbildungen/Symmetrie_Graph.png b/src/Abbildungen/Symmetrie_Graph.png
new file mode 100644
index 0000000000000000000000000000000000000000..4cd581d55c3241a495c12fce03ffe0fd9df8e227
GIT binary patch
literal 4778
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

literal 0
HcmV?d00001

diff --git a/src/Abbildungen/Transitivitaet_Graph.png b/src/Abbildungen/Transitivitaet_Graph.png
new file mode 100644
index 0000000000000000000000000000000000000000..576f3ac988412d1ff4a25679bbac75c2b8fa04ef
GIT binary patch
literal 3495
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
VbIgyvxBHSnOpPoIYsgMf{|6voY6buR

literal 0
HcmV?d00001

diff --git a/src/DiskreteMathematik/FormaleGrundlagen.tex b/src/DiskreteMathematik/FormaleGrundlagen.tex
index c16a229..02ab37f 100644
--- a/src/DiskreteMathematik/FormaleGrundlagen.tex
+++ b/src/DiskreteMathematik/FormaleGrundlagen.tex
@@ -173,6 +173,49 @@
                         \forall a \in A\; \exists! b \in B\colon \left(a, b\right) \in R
                     \end{equation}
                     
+                \paragraph{Transitivität}
+                    Auf einer Menge $M$ ist eine zweistellige Relation $R \subseteq M \times M$ transitiv, wenn für beliebige Elemente $x, y, z \in M$ aus $xRy$ und $yRz$ stets $xRz$ folgt. Der Graph einer transitiven Funktion ist in Abbildung \ref{figure:Mathematik:FormaleGrundlagen:Transitivitaet_Graph} dargestellt.
+                    
+                    Ein Beispiel für eine transitive Relation ist die Kleiner-Relation auf den Reellen Zahlen:
+                    
+                    \begin{equation}
+                        \forall x, y, z \in \mathbb{R}\colon x < y \land y < z \rightarrow x < z
+                    \end{equation}
+                    
+                    \begin{figure}
+                         \centering
+                         \includegraphics[width=0.5\textwidth]{Abbildungen/Transitivitaet_Graph.png}
+                         \caption{Eine transitive Relation als Graph dargestellt.}
+                         \label{figure:Mathematik:FormaleGrundlagen:Transitivitaet_Graph}
+                    \end{figure}
+                    
+                \paragraph{Reflexivität}
+                    Eine zweistellige Relation $R$ auf einer Menge $M$ ist genau dann reflexiv, wenn $\forall x\colon xRx$ gilt. Wenn kein Element diese Anforderung erfüllt, dass wird die Relation irreflexiv genannt. Der Graph einer reflexiven Funktion ist in Abbildung \ref{figure:Mathematik:FormaleGrundlagen:Reflexivitaet_Graph} dargestellt.
+                    
+                    Eine reflexive Relation ist zum Beispiel die Kleiner-Gleich-Relation auf den Reellen Zahlen.
+                    
+                    \begin{figure}
+                         \centering
+                         \includegraphics[width=0.5\textwidth]{Abbildungen/Reflexivitaet_Graph.png}
+                         \caption{Eine reflexive Relation als Graph dargestellt.}
+                         \label{figure:Mathematik:FormaleGrundlagen:Reflexivitaet_Graph}
+                    \end{figure}
+                    
+                \paragraph{Symmetrie}
+                    Eine zweistellige Relation $R$ auf einer Menge $M$ ist genau dann symmetrisch, wenn für alle $x, y \in M$ aus $xRy$ stets $yRx$ folgt. Der Graph einer symmetrischen Funktion ist in Abbildung \ref{figure:Mathematik:FormaleGrundlagen:Symmetrie_Graph} dargestellt.
+                    
+                    Gibt es kein Paar $x, y \in M$ bei dem aus $xRy$ $yRx$ folgt, so nennt man die Relation asymmetrisch.
+                    
+                    Gibt es nur Paare $x, y \in M$, für die entweder aus $xRy$ nich $yRx$ folgt oder $x = y$, so nennt man die Relation antisymmetrisch.
+                    
+                    
+                    \begin{figure}
+                         \centering
+                         \includegraphics[width=0.5\textwidth]{Abbildungen/Symmetrie_Graph.png}
+                         \caption{Eine symmetrische Relation als Graph dargestellt.}
+                         \label{figure:Mathematik:FormaleGrundlagen:Symmetrie_Graph}
+                    \end{figure}
+                    
             \subsubsection{Inversion oder Umkehrung}
                 Wenn man eine Relation $r\colon A \rightarrow B$ hat, dann ist die Inversion $r^{-1}\colon B \rightarrow A$. Eine Funktion ist als Relation immer umkehrbar, als Funktion ist sie dagegen genau dann umkehrbar, wenn ihre Umkehrrelation auch wieder eine Funktion ist, also wenn es eine Umkehrfunktion von ihr gibt.                
                     

From ea145b0477a6ad8dfa35609ae6179bb11544809f Mon Sep 17 00:00:00 2001
From: Noah Peeters <noah.peeters@icloud.com>
Date: Wed, 17 Jan 2018 11:00:46 +0100
Subject: [PATCH 04/11] IuG 16.01.2017

---
 src/Informatik/InformatikGesellschaft.tex | 61 +++++++++++++++++++++--
 1 file changed, 58 insertions(+), 3 deletions(-)

diff --git a/src/Informatik/InformatikGesellschaft.tex b/src/Informatik/InformatikGesellschaft.tex
index 364d592..6f0d76a 100644
--- a/src/Informatik/InformatikGesellschaft.tex
+++ b/src/Informatik/InformatikGesellschaft.tex
@@ -8,8 +8,63 @@
     \end{quote}
     \clearpage
 
-    \section{Content}
-        TODO: Content
+    \section{Programmierung und Software Engineering}
+        Für den Unterschied zwischen Programmierung und Software Engineering spielt die Geschichte der Programmierung eine entscheidende Role.
         
-        Bisher war der gesamte Inhalt nur Grundlagen, die im Kursübergreifenden Teil gefunden werden können.
+        \subsection{Geschichte der Programmierung}
+        
+            \paragraph{40er und 50er Jahren}
+                In den 40er und 50er Jahren war die Hardware teuer und hatte keine Betriebssysteme, sodass Computer nur von Experten für den Eigengebrauch programmiert wurden. Die so erstellten Programme hatten meistens nur genau eine Aufgabe und wurden danach nicht weiter verwendet.
+                
+            \paragraph{Ab den 60er Jahren}
+                In den 60er Jahren gab es eine Wende da Hardware bezahlbar wurde, sodass auch normale Anwender Programme brauchten. Software hat sich unüberschaubar ausgeweitet und die Lebensdauer von Software war nun länger als von der Hardware.
+            
+        \subsection{Die Softwarekrise}
+            Aufgrund des abrupten Wandels von Software, die nur von den Entwicklern bedient wurde, zu Software, die für jeden war, und die damit verbundenen Probleme ist es zu der sogenannten Software Krise gekommen. Die NATO SE-Konferenz prägte diesen Begriff 1968 mit folgenden Eigenschaften
+            
+            \begin{itemize}
+                \item Software erfüllt nicht die Wünsche der Kunden.
+                \item Software ist nicht zuverlässig.
+                \item Softwareentwicklung und -wartung ist zu Zeit und Kostenintensive.
+                \item Die Kosten für Software übersteigt die Kosten für Hardware.
+                \item Nur 34\% der Softwareprojekte wurden erfolgreich abgeschlossen.
+            \end{itemize}
+            
+            \subsubsection{Ursachen}
+                \begin{itemize}
+                    \item Software ist ein immaterielles Gut und hat damit keinen Materialwert.
+                    \item Software ist schwer verständlich, sodass es zu Kommunikationsproblemen zwischen Auftraggeber und Entwickler kommt.
+                    \item Software ist nur in den Wirkungen beim Ablauf auf Computern beobachtbar.
+                    \item Software verschleißt nicht, sodass nur Erweiterungen angebaut werden. Dennoch kann Software altern, wie es beim 2000 Problem sichtbar geworden ist.
+                    \item Software Fehler sind schwer zu erkennen.
+                    \item Software ist scheinbar leicht zu verändern.
+                    \item Kleinste Änderungen in einer Software können massive Änderungen im Verhalten der Software zur folge haben.
+                    \item Nachweiß der wunschgemäßen Verhaltens ist schwierig.
+                \end{itemize}
+                
+            \subsection{Schlussfolgerung}
+                Aufgrund der Softwarekrise soll die Erstellung von Software nicht mehr eine kreative Kunst bleiben sondern eine Ingenieurwissenschaft mit wohldefinierten Vorgehensweisen werden. Deshalb wurde der Begriff des Software Engineering geprägt.
+                
+        \subsection{Software Engineering}
+            Unter Software Engineering versteht man
+            
+            \begin{itemize}
+                \item die Entwicklung,
+                \item die Pflege und
+                \item den Einsatz
+            \end{itemize}
+            von \emph{qualitativ hochwertiger} Software unter Einsatz von
+            
+            \begin{itemize}
+                \item wissenschaftlichen Methoden,
+                \item wirtschaftlichen Prinzipien,
+                \item geplanten Vorgehensmodellen,
+                \item Werkzeugen und
+                \item quantifizierbaren Zielen.
+            \end{itemize}
+            
+        \subsection{Usability Engineering}
+            Eine Erweiterung des Software Engineering ist das Usability Engineering. Mit dem Aufkommen des \emph{Apple Lisa} in den 80ern merkte man, dass interaktive, technische System nicht unabhängig von der Arbeitswelt betrachtet werden können, sondern die Aufgaben und das Umfeld entscheidend für die Gestaltung des Systems ist. Seit den 90er Jahren ist es deshalb ein strategisches Ziel aller Unternehmen eine intuitive Benutzerschnittstelle zu haben.
+                
+            Verschärft wird der Druck durch das Konzept von \emph{Software as a service}, da die Konkurrenz nur ein Klick entfernt ist und ein Produkt auf den ersten Blick überzeugen muss.
 \end{document}

From 8ea218204c656342645d59af9249cbe8a8f8d52a Mon Sep 17 00:00:00 2001
From: Til Blechschmidt <til@blechschmidt.de>
Date: Mon, 22 Jan 2018 12:37:54 +0100
Subject: [PATCH 05/11] Fixes for review by Til Blechschmidt

---
 src/DiskreteMathematik/FormaleGrundlagen.tex | 2 +-
 src/Informatik/EinfuehrungProgrammierung.tex | 2 +-
 src/Informatik/InformatikGesellschaft.tex    | 8 ++++----
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/DiskreteMathematik/FormaleGrundlagen.tex b/src/DiskreteMathematik/FormaleGrundlagen.tex
index 02ab37f..82f4d89 100644
--- a/src/DiskreteMathematik/FormaleGrundlagen.tex
+++ b/src/DiskreteMathematik/FormaleGrundlagen.tex
@@ -206,7 +206,7 @@
                     
                     Gibt es kein Paar $x, y \in M$ bei dem aus $xRy$ $yRx$ folgt, so nennt man die Relation asymmetrisch.
                     
-                    Gibt es nur Paare $x, y \in M$, für die entweder aus $xRy$ nich $yRx$ folgt oder $x = y$, so nennt man die Relation antisymmetrisch.
+                    Gibt es nur Paare $x, y \in M$, für die entweder aus $xRy$ nicht $yRx$ folgt oder $x = y$, so nennt man die Relation antisymmetrisch.
                     
                     
                     \begin{figure}
diff --git a/src/Informatik/EinfuehrungProgrammierung.tex b/src/Informatik/EinfuehrungProgrammierung.tex
index d33feb6..3c5ecf2 100644
--- a/src/Informatik/EinfuehrungProgrammierung.tex
+++ b/src/Informatik/EinfuehrungProgrammierung.tex
@@ -43,5 +43,5 @@
             \emph{Self Evaluating Expressions} sind Ausdrücke, die zu sich selbst ausgewertet werden. In Racket gehören Zahlen zu den \emph{Self Evaluating Expressions}. Die Auswertung eines Ausdrucks ist beendet, wenn eine \emph{Self Evaluating Expressions} erreicht wurde.
             
         \paragraph{Funktionsaufruf}
-            Bei strikter Auswertung werden erst alle Argumente eines Funktionsaufrufs berechnet. Diese Verfahren kommt bei Racket zum Einsatz. Diesem Verfahren steht die lazy Auswertung gegenüber, die zum Beispiel in Haskel verwendet wird, bei dem auch die Argumente erst berechnet werden, wenn sie benötigt werden.         
+            Bei strikter Auswertung werden erst alle Argumente eines Funktionsaufrufs berechnet. Dieses Verfahren kommt bei Racket zum Einsatz. Diesem Verfahren steht die lazy Auswertung gegenüber, die zum Beispiel in Haskel verwendet wird, bei dem auch die Argumente erst berechnet werden, wenn sie benötigt werden.         
 \end{document}
diff --git a/src/Informatik/InformatikGesellschaft.tex b/src/Informatik/InformatikGesellschaft.tex
index 6f0d76a..c624113 100644
--- a/src/Informatik/InformatikGesellschaft.tex
+++ b/src/Informatik/InformatikGesellschaft.tex
@@ -35,11 +35,11 @@
                     \item Software ist ein immaterielles Gut und hat damit keinen Materialwert.
                     \item Software ist schwer verständlich, sodass es zu Kommunikationsproblemen zwischen Auftraggeber und Entwickler kommt.
                     \item Software ist nur in den Wirkungen beim Ablauf auf Computern beobachtbar.
-                    \item Software verschleißt nicht, sodass nur Erweiterungen angebaut werden. Dennoch kann Software altern, wie es beim 2000 Problem sichtbar geworden ist.
+                    \item Software verschleißt nicht, sodass nur Erweiterungen angebaut werden. Dennoch kann Software altern, wie es beim Millenium Bug sichtbar geworden ist.
                     \item Software Fehler sind schwer zu erkennen.
                     \item Software ist scheinbar leicht zu verändern.
-                    \item Kleinste Änderungen in einer Software können massive Änderungen im Verhalten der Software zur folge haben.
-                    \item Nachweiß der wunschgemäßen Verhaltens ist schwierig.
+                    \item Kleinste Änderungen in einer Software können massive Änderungen im Verhalten der Software zur Folge haben.
+                    \item Nachweiß des wunschgemäßen Verhaltens ist schwierig.
                 \end{itemize}
                 
             \subsection{Schlussfolgerung}
@@ -66,5 +66,5 @@
         \subsection{Usability Engineering}
             Eine Erweiterung des Software Engineering ist das Usability Engineering. Mit dem Aufkommen des \emph{Apple Lisa} in den 80ern merkte man, dass interaktive, technische System nicht unabhängig von der Arbeitswelt betrachtet werden können, sondern die Aufgaben und das Umfeld entscheidend für die Gestaltung des Systems ist. Seit den 90er Jahren ist es deshalb ein strategisches Ziel aller Unternehmen eine intuitive Benutzerschnittstelle zu haben.
                 
-            Verschärft wird der Druck durch das Konzept von \emph{Software as a service}, da die Konkurrenz nur ein Klick entfernt ist und ein Produkt auf den ersten Blick überzeugen muss.
+            Verschärft wird der Druck durch das Konzept von \emph{Software as a service} (SaaS), da die Konkurrenz nur ein Klick entfernt ist und ein Produkt auf den ersten Blick überzeugen muss.
 \end{document}

From 0a9853ea22d52520bb6b56d20dce512ca3a7cca7 Mon Sep 17 00:00:00 2001
From: Noah Peeters <noah.peeters@icloud.com>
Date: Tue, 30 Jan 2018 09:19:26 +0100
Subject: [PATCH 06/11] Completed Auswertungsregelen

---
 src/Informatik/EinfuehrungProgrammierung.tex | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/Informatik/EinfuehrungProgrammierung.tex b/src/Informatik/EinfuehrungProgrammierung.tex
index 3c5ecf2..30ab7c3 100644
--- a/src/Informatik/EinfuehrungProgrammierung.tex
+++ b/src/Informatik/EinfuehrungProgrammierung.tex
@@ -39,8 +39,13 @@
         \paragraph{Ersetzungen}
             Um die Bedeutung eines Ausdrucks zu bestimmen, werden nacheinander semantisch äquivalente Umformungen mit dem \emph{Ersetzungsmodell für Funktionsanwendungen} durchgeführt. Die Reihenfolge der Auswertung von Teilausdrücken in funktionalen Sprachen hat dabei keine Auswirkung auf das Endergebnis.
             
+            Beim Ersetzen von Variablen mit Konstanten wird dieser Prozess als Auswertung bezeichnet. Die Reihenfolge der Auswertungen spielt dabei in funktionalen Programmiersprachen keine Rolle.
+            
+        \paragraph{Ersetzungsmodell für Funktionsanwendungen}
+            Eine Funktion wird ausgewertet, in dem jeder formale Parameter im Funktionsrumpf durch das korrespondierende ausgewertete Argument ersetzt wird.
+            
         \paragraph{Self Evaluating Expressions}
-            \emph{Self Evaluating Expressions} sind Ausdrücke, die zu sich selbst ausgewertet werden. In Racket gehören Zahlen zu den \emph{Self Evaluating Expressions}. Die Auswertung eines Ausdrucks ist beendet, wenn eine \emph{Self Evaluating Expressions} erreicht wurde.
+            \emph{Self Evaluating Expressions} sind Ausdrücke, die zu sich selbst ausgewertet werden. In Racket gehören Zahlen zu den Self Evaluating Expressions. Die Auswertung eines Ausdrucks ist beendet, wenn eine Self Evaluating Expressions erreicht wurde. Beispiele für Self Evaluating Expressions sind Zahlen und die Wahrheitswerte $\#t$ und $\#f$.
             
         \paragraph{Funktionsaufruf}
             Bei strikter Auswertung werden erst alle Argumente eines Funktionsaufrufs berechnet. Dieses Verfahren kommt bei Racket zum Einsatz. Diesem Verfahren steht die lazy Auswertung gegenüber, die zum Beispiel in Haskel verwendet wird, bei dem auch die Argumente erst berechnet werden, wenn sie benötigt werden.         

From 2b403cac294b2c591cfe50ea2e467ad1def02a0f Mon Sep 17 00:00:00 2001
From: Noah Peeters <noah.peeters@icloud.com>
Date: Tue, 30 Jan 2018 10:05:42 +0100
Subject: [PATCH 07/11] Add Aufschreibregeln

---
 src/Informatik/EinfuehrungProgrammierung.tex | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/src/Informatik/EinfuehrungProgrammierung.tex b/src/Informatik/EinfuehrungProgrammierung.tex
index 30ab7c3..e27974d 100644
--- a/src/Informatik/EinfuehrungProgrammierung.tex
+++ b/src/Informatik/EinfuehrungProgrammierung.tex
@@ -48,5 +48,22 @@
             \emph{Self Evaluating Expressions} sind Ausdrücke, die zu sich selbst ausgewertet werden. In Racket gehören Zahlen zu den Self Evaluating Expressions. Die Auswertung eines Ausdrucks ist beendet, wenn eine Self Evaluating Expressions erreicht wurde. Beispiele für Self Evaluating Expressions sind Zahlen und die Wahrheitswerte $\#t$ und $\#f$.
             
         \paragraph{Funktionsaufruf}
-            Bei strikter Auswertung werden erst alle Argumente eines Funktionsaufrufs berechnet. Dieses Verfahren kommt bei Racket zum Einsatz. Diesem Verfahren steht die lazy Auswertung gegenüber, die zum Beispiel in Haskel verwendet wird, bei dem auch die Argumente erst berechnet werden, wenn sie benötigt werden.         
+            Bei strikter Auswertung werden erst alle Argumente eines Funktionsaufrufs berechnet. Dieses Verfahren kommt bei Racket zum Einsatz. Diesem Verfahren steht die lazy Auswertung gegenüber, die zum Beispiel in Haskel verwendet wird, bei dem auch die Argumente erst berechnet werden, wenn sie benötigt werden.   
+            
+    \section{Aufschreibregeln für Funktionen}
+        \paragraph{Regel 1}
+            Verwende aussagekräftige Namen für Funktionen und deren Parameter.
+        
+        \paragraph{Regel 2}
+            Beschreibe den Zweck der Funktion in einem Satz mithilfe eines Kommentars in der Zeile vor der Funktionsdefinition. Der Satz sollte das Resultat der Funktion in Abhängigkeit von den Parametern beschreiben.
+            
+        \paragraph{Regel 3}
+            Füge unter der Funktion Tests hinzu, die die Richtigkeit der Funktion auch in Zukunft sicherstellen. Dazu müssen Test für alle Randbereiche vorhanden sein.
+            
+        \paragraph{Regel 4}
+            Definiere für jeden Zusammenhang zwischen Größen, die sich aus der Problemstellung ergeben,  eine Funktion.
+            
+        \paragraph{Regel 5}
+            Ersetze jede Konstante, deren Bedeutung sich nicht aus dem Kontext ergibt, durch einen sprechenden Variablennamen.
+
 \end{document}

From b6c42df70b79f2b1b2f14e515b4e9630fdf58486 Mon Sep 17 00:00:00 2001
From: Til Blechschmidt <til@blechschmidt.de>
Date: Tue, 30 Jan 2018 10:30:38 +0100
Subject: [PATCH 08/11] Reduced repetition of `Self Evaluating Expression`

The term SEE was used way too much and the example of a number was given twice.
---
 src/Informatik/EinfuehrungProgrammierung.tex | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Informatik/EinfuehrungProgrammierung.tex b/src/Informatik/EinfuehrungProgrammierung.tex
index e27974d..ce79617 100644
--- a/src/Informatik/EinfuehrungProgrammierung.tex
+++ b/src/Informatik/EinfuehrungProgrammierung.tex
@@ -45,7 +45,7 @@
             Eine Funktion wird ausgewertet, in dem jeder formale Parameter im Funktionsrumpf durch das korrespondierende ausgewertete Argument ersetzt wird.
             
         \paragraph{Self Evaluating Expressions}
-            \emph{Self Evaluating Expressions} sind Ausdrücke, die zu sich selbst ausgewertet werden. In Racket gehören Zahlen zu den Self Evaluating Expressions. Die Auswertung eines Ausdrucks ist beendet, wenn eine Self Evaluating Expressions erreicht wurde. Beispiele für Self Evaluating Expressions sind Zahlen und die Wahrheitswerte $\#t$ und $\#f$.
+            \emph{Self Evaluating Expressions} sind Ausdrücke, die zu sich selbst ausgewertet werden. Die Auswertung eines Ausdrucks ist beendet, wenn eine solche Expressions erreicht wurde. Beispiele sind Zahlen sowie die Wahrheitswerte $\#t$ und $\#f$.
             
         \paragraph{Funktionsaufruf}
             Bei strikter Auswertung werden erst alle Argumente eines Funktionsaufrufs berechnet. Dieses Verfahren kommt bei Racket zum Einsatz. Diesem Verfahren steht die lazy Auswertung gegenüber, die zum Beispiel in Haskel verwendet wird, bei dem auch die Argumente erst berechnet werden, wenn sie benötigt werden.   

From e63feb5567eb7494c81fb46ca6e31e855d01f6df Mon Sep 17 00:00:00 2001
From: Til Blechschmidt <til@blechschmidt.de>
Date: Tue, 30 Jan 2018 10:33:15 +0100
Subject: [PATCH 09/11] Removed redundant whitespace

---
 src/Informatik/EinfuehrungProgrammierung.tex | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Informatik/EinfuehrungProgrammierung.tex b/src/Informatik/EinfuehrungProgrammierung.tex
index ce79617..ed075da 100644
--- a/src/Informatik/EinfuehrungProgrammierung.tex
+++ b/src/Informatik/EinfuehrungProgrammierung.tex
@@ -61,7 +61,7 @@
             Füge unter der Funktion Tests hinzu, die die Richtigkeit der Funktion auch in Zukunft sicherstellen. Dazu müssen Test für alle Randbereiche vorhanden sein.
             
         \paragraph{Regel 4}
-            Definiere für jeden Zusammenhang zwischen Größen, die sich aus der Problemstellung ergeben,  eine Funktion.
+            Definiere für jeden Zusammenhang zwischen Größen, die sich aus der Problemstellung ergeben, eine Funktion.
             
         \paragraph{Regel 5}
             Ersetze jede Konstante, deren Bedeutung sich nicht aus dem Kontext ergibt, durch einen sprechenden Variablennamen.

From 0b0ff7c7840692a33451f505f2e9ba92861117d2 Mon Sep 17 00:00:00 2001
From: Til Blechschmidt <til@blechschmidt.de>
Date: Tue, 30 Jan 2018 10:38:36 +0100
Subject: [PATCH 10/11] Replaced conjunction

---
 src/Informatik/EinfuehrungProgrammierung.tex | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Informatik/EinfuehrungProgrammierung.tex b/src/Informatik/EinfuehrungProgrammierung.tex
index ed075da..45f1ffb 100644
--- a/src/Informatik/EinfuehrungProgrammierung.tex
+++ b/src/Informatik/EinfuehrungProgrammierung.tex
@@ -48,7 +48,7 @@
             \emph{Self Evaluating Expressions} sind Ausdrücke, die zu sich selbst ausgewertet werden. Die Auswertung eines Ausdrucks ist beendet, wenn eine solche Expressions erreicht wurde. Beispiele sind Zahlen sowie die Wahrheitswerte $\#t$ und $\#f$.
             
         \paragraph{Funktionsaufruf}
-            Bei strikter Auswertung werden erst alle Argumente eines Funktionsaufrufs berechnet. Dieses Verfahren kommt bei Racket zum Einsatz. Diesem Verfahren steht die lazy Auswertung gegenüber, die zum Beispiel in Haskel verwendet wird, bei dem auch die Argumente erst berechnet werden, wenn sie benötigt werden.   
+            Bei strikter Auswertung werden erst alle Argumente eines Funktionsaufrufs berechnet. Dieses Verfahren kommt bei Racket zum Einsatz. Diesem Verfahren steht die lazy Auswertung gegenüber, welche zum Beispiel in Haskel verwendet wird, bei dem auch die Argumente erst berechnet werden, wenn sie benötigt werden.   
             
     \section{Aufschreibregeln für Funktionen}
         \paragraph{Regel 1}

From 063a71d9c14c31ada8139bcd917b05836cdf564d Mon Sep 17 00:00:00 2001
From: Til Blechschmidt <til@blechschmidt.de>
Date: Tue, 30 Jan 2018 11:06:57 +0100
Subject: [PATCH 11/11] =?UTF-8?q?Added=20reference=20to=20Ersetzungsmodell?=
 =?UTF-8?q?=20f=C3=BCr=20Funktionsanwendung?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/Informatik/EinfuehrungProgrammierung.tex | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/Informatik/EinfuehrungProgrammierung.tex b/src/Informatik/EinfuehrungProgrammierung.tex
index 45f1ffb..7faac3e 100644
--- a/src/Informatik/EinfuehrungProgrammierung.tex
+++ b/src/Informatik/EinfuehrungProgrammierung.tex
@@ -37,12 +37,13 @@
             Die Semantik einer Programmiersprache legt die Bedeutung von syntaktisch korrekten Ausdrücken fest. Die Semantik funktionaler Programmiersprachen orientiert sich an der Semantik der Mathematik.
             
         \paragraph{Ersetzungen}
-            Um die Bedeutung eines Ausdrucks zu bestimmen, werden nacheinander semantisch äquivalente Umformungen mit dem \emph{Ersetzungsmodell für Funktionsanwendungen} durchgeführt. Die Reihenfolge der Auswertung von Teilausdrücken in funktionalen Sprachen hat dabei keine Auswirkung auf das Endergebnis.
+            Um die Bedeutung eines Ausdrucks zu bestimmen, werden nacheinander semantisch äquivalente Umformungen mit dem \hyperref[section:Programmierung:Auswertungsregeln:ErsetzungsmodellFunktionsanwendungen]{\emph{Ersetzungsmodell für Funktionsanwendungen}} durchgeführt. Die Reihenfolge der Auswertung von Teilausdrücken in funktionalen Sprachen hat dabei keine Auswirkung auf das Endergebnis.
             
             Beim Ersetzen von Variablen mit Konstanten wird dieser Prozess als Auswertung bezeichnet. Die Reihenfolge der Auswertungen spielt dabei in funktionalen Programmiersprachen keine Rolle.
             
         \paragraph{Ersetzungsmodell für Funktionsanwendungen}
-            Eine Funktion wird ausgewertet, in dem jeder formale Parameter im Funktionsrumpf durch das korrespondierende ausgewertete Argument ersetzt wird.
+		\label{section:Programmierung:Auswertungsregeln:ErsetzungsmodellFunktionsanwendungen}
+			Eine Funktion wird ausgewertet, in dem jeder formale Parameter im Funktionsrumpf durch das korrespondierende ausgewertete Argument ersetzt wird.
             
         \paragraph{Self Evaluating Expressions}
             \emph{Self Evaluating Expressions} sind Ausdrücke, die zu sich selbst ausgewertet werden. Die Auswertung eines Ausdrucks ist beendet, wenn eine solche Expressions erreicht wurde. Beispiele sind Zahlen sowie die Wahrheitswerte $\#t$ und $\#f$.