Merge pull request #2 from josphstar/main

Übungschef für Woche 3

docs/exercises/code-reading.md

@@ -60,7 +60,7 @@ Fügen Sie Ihrem Projekt eine neue Datei ```docs/BuildInstructions.md``` hinzu.
 3. Testen ob der Code der Unit-Tests den Stilvorgaben entspricht
 4. Erstellen eines Zip Files, welches nach dem Entpacken eine lauffähige Version von JabRef enthält.
 
-Beschreiben Sie auch, was die Task ```generateSource``` macht.
+Beschreiben Sie auch, was der Task ```generateSource``` macht.
 
 *Tip: Mit ```gradlew tasks --all``` erhalten Sie einen Überblick über alle Gradle tasks die in JabRef zur Verfügung stehen.*
 
@@ -94,7 +94,7 @@ repositories {
 zusätzlich als *Required Dependency* deklarieren. Dies machen Sie, indem Sie in der Datei ```module-info.java``` den Eintrag ```requires swenglib;``` hinzufügen.
 
 
-Wenn das hinzufügen funktioniert hat sollten Sie in der main Methode (wie finden Sie die?) folgenden Code zu JabRef hinzufügen können und das Projekt sollte entsprechend kompilieren
+Wenn das Hinzufügen funktioniert hat sollten Sie in der main Methode (wie finden Sie die?) folgenden Code zu JabRef hinzufügen können und das Projekt sollte entsprechend kompilieren.
 ```
 import ch.unibas.informatik.sweng.HelloSweng;
 String greeting = HelloSweng.greeting();
@@ -104,7 +104,7 @@ System.out.println(greeting);
 Überprüfen Sie auch, dass sie mit ```CTRL + LeftMouseClick``` auf ```HelloSweng```, zum
 Source Code der Bibliothek kommen.
 
-#### 1.3 Maven central
+#### 1.3 Maven Central
 
 In der Java-Welt werden viele frei verfügbare Bibliotheken auf [Maven Central](https://search.maven.org) publiziert. 
 Suchen Sie da nach dem Paket `opencsv`. Auf der Seite wird Ihnen auch angezeigt, wie Sie das Paket in Gradle als Abhängigkeit hinzufügen 
@@ -114,17 +114,16 @@ können. Finden Sie heraus wo und wie? Fügen Sie auch dieses Paket hinzu. Sie m
 Fügen Sie das Plugin [Gradle-License-Report](https://github.com/jk1/Gradle-License-Report) durch anpassen der Datei ```build.gradle```zum Projekt hinzu. Die entsprechenden Instruktionen finden Sie auf
 der Github Seite vom [Gradle-License-Report](https://github.com/jk1/Gradle-License-Report).
 
-Testen Sie das Plugin und schauen Sie sich den generierte Report an.
+Testen Sie das Plugin und schauen Sie sich den generierten Report an.
 Fügen Sie einen Kommentar in der Datei ```build.gradle``` hinzu. Dieser soll ganz kurz (in Ihren eigenen Worten) dokumentieren, was das Plugin macht und wozu wir es brauchen.
 
 ## 2. Code lesen
 
-In diesem Teil der Übung geht es darum, dass sie sich einen Grobüberblick über die Struktur des Jabref Codes erarbeiten sowie auch lernen, fremden Code zu lesen und zu verstehen. Ein gute Vorgehensweise ist Teile des Codes bei dieser Gelegenheit gerade zu
-Dokumentieren.
+In diesem Teil der Übung geht es darum, dass sie sich einen Grobüberblick über die Struktur des Jabref Codes erarbeiten sowie auch lernen, fremden Code zu lesen und zu verstehen. Ein gute Vorgehensweise ist Teile des Codes bei dieser Gelegenheit gerade zu dokumentieren.
 
 #### Dokumentieren von Packages
 
-Lesen Sie den [Auszug aus dem Buch](https://adam.unibas.ch/goto_adam_file_1467339.html) Java By Comparison zum Thema API Doc.
+Lesen Sie den [Auszug aus dem Buch](https://adam.unibas.ch/goto_adam_file_1629485.html) Java By Comparison zum Thema API Doc.
 
 
 Dokumentieren Sie dann die zwei folgenden Packages.
@@ -153,7 +152,7 @@ Schauen Sie sich die Klasse
 ```org.jabref.logic.protectedterms.ProtectedTermsLoader``` an. Dokumentieren Sie die Klasse selbst und die Methoden `addNewProtectedTermsList` und `getInternalLists` mit Javadoc. Folgen Sie dabei auch hier den im Buch beschriebenen Prinzipien.
 
 
-Orientieren Sie sich auch hier an den Leitlinien im Buch [Java by Comparison](https://adam.unibas.ch/goto_adam_file_1467339.html). 
+Orientieren Sie sich auch hier an den Leitlinien im Buch [Java by Comparison](https://adam.unibas.ch/goto_adam_file_1629485.html). 
 
 *Hinweis:* Nutzen Sie den Debugger um herauszufinden, welche Werte die einzelnen Felder/Variablen in der Klasse annehmen. Dies kann Ihnen wichtige Informationen geben. 
 

docs/exercises/jabref-setup.md

@@ -91,7 +91,7 @@ export JAVA_HOME=PFAD_ZU_IHRER_JAVA_19_INSTALLATION
 export “PATH=$JAVA_HOME/bin:$PATH”
 ```
 
-Danach geben Sie folgendes Kommando ein:
+Danach starten Sie ein neues Terminal und geben folgendes Kommando ein:
 ```
  java -version
 ```
@@ -101,7 +101,9 @@ openjdk version "19.0.2" 2023-01-17
 OpenJDK Runtime Environment Temurin-19.0.2+7 (build 19.0.2+7)
 OpenJDK 64-Bit Server VM Temurin-19.0.2+7 (build 19.0.2+7, mixed mode, sharing)
 ```
-*Anmerkung:* Das Buildsystem Gradle, welches wir für das kompilieren und ausführen von JabRef verwenden, nutzt die Umgebungsvariable ```JAVA_HOME``` um das JDK zu finden. Diese Umgebungsvariable muss also immer richtig gesetzt sein, wenn Sie JabRef aus einem Terminal kompilieren oder ausführen wollen.
+*Anmerkung:* Das Buildsystem Gradle, welches wir für das Kompilieren und Ausführen von JabRef verwenden, nutzt die Umgebungsvariable ```JAVA_HOME``` um das JDK zu finden. Diese Umgebungsvariable muss also immer richtig gesetzt sein, wenn Sie JabRef aus einem Terminal kompilieren oder ausführen wollen.
+
+*Anmerkung 2:* Beim Setzen der Umgebungsvariable wird diese für laufende Prozesse nicht unmittelbar aktualisiert, deshalb müssen Sie Prozesse wie zum Beispiel die PowerShell neu starten um Änderungen in der Java-Version zu sehen. 
 
 ## JabRef
 

docs/week3/index.md

@@ -6,7 +6,7 @@ title : Woche 3
 # Woche 3: Prinzipien des Software Engineerings / Modulbeziehungen
 
 In dieser Woche besprechen wir wichtige Prinzipien des Software Engineerings, welche allen klassischen wie auch 
-modernen Softwareentwicklungsmethoden zugrunde liegen. Insbesondere werden wir uns das Prinzip Modularität genauer anschauen und das Konzept der Modulgraphen kennenlernen. Wir werden auch lernen, weshalb software altert, obwohl es sich dabei um ein digitales Konstrukt handelt.
+modernen Softwareentwicklungsmethoden zugrunde liegen. Insbesondere werden wir uns das Prinzip Modularität genauer anschauen und das Konzept der Modulgraphen kennenlernen. Wir werden auch lernen, weshalb Software altert, obwohl es sich dabei um ein digitales Konstrukt handelt.
 
 
 ## Theorie
@@ -15,23 +15,23 @@ modernen Softwareentwicklungsmethoden zugrunde liegen. Insbesondere werden wir u
 
 Als Vorbereitung für die Präsenzveranstaltung in dieser Woche bearbeiten Sie bitte folgende Schritte:
 
-* Schritt 1: Schauen Sie das Video "Prinzipien des Software Engineerings" ([Video](https://unibas.cloud.panopto.eu/Panopto/Pages/Viewer.aspx?id=1cd060e4-f680-4ca1-80a4-b062006f4a7a), [Slides](./slides/Prinzipien.pdf))
-* Schritt 2: Lesen Sie den Artikel "Weitere Prinzipien des Software Engineerings" ([Artikel](./software-engineering-principles))
-* Schritt 3: Schauen Sie das Video zum Thema "Modularität".([Video](https://unibas.cloud.panopto.eu/Panopto/Pages/Viewer.aspx?id=a8b08565-64b0-43a1-96f1-b062006f4a84), [Slides](./slides/Modularität.pdf))
+* Schritt 1: Schauen Sie das Video "Prinzipien des Software Engineerings". ([Video](https://unibas.cloud.panopto.eu/Panopto/Pages/Viewer.aspx?id=1cd060e4-f680-4ca1-80a4-b062006f4a7a), [Slides](./slides/Prinzipien.pdf))
+* Schritt 2: Lesen Sie den Artikel "Weitere Prinzipien des Software Engineerings". ([Artikel](./software-engineering-principles))
+* Schritt 3: Schauen Sie das Video zum Thema "Modularität". ([Video](https://unibas.cloud.panopto.eu/Panopto/Pages/Viewer.aspx?id=a8b08565-64b0-43a1-96f1-b062006f4a84), [Slides](./slides/Modularität.pdf))
 * Schritt 4: Lesen Sie den Artikel "Formale Aspekte von Modulbeziehungen". ([Artikel](.//module-structure))
 * Schritt 5: Lesen Sie den Artikel "Software Aging" von David L. Parnas. ([Paper](http://www.inf.ed.ac.uk/teaching/courses/seoc/2004_2005/resources/bullet11.pdf))
-* Schritt 6: Bearbeiten Sie den Test. [(Adam)](https://adam.unibas.ch/goto_adam_tst_1629493.html).
+* Schritt 6: Bearbeiten Sie den Test. ([Adam](https://adam.unibas.ch/goto_adam_tst_1629493.html))
 
 
 ####  Präsenzveranstaltung vom 4. Oktober
 
-In der Präsenzveranstaltung werden wir die im Selbststudium bearbeiten Themen in Diskussionen und Gruppenarbeiten vertiefen. 
+In der Präsenzveranstaltung werden wir die im Selbststudium bearbeiteten Themen in Diskussionen und Gruppenarbeiten vertiefen. 
 Wir werden auch praktische Anwendungen von Modulgraphen kennenlernen.
 
 ## Praxis
 
  Im praktischen Teil der Veranstaltung geben wir eine kurze Einführung in Buildsysteme, und gehen dabei insbesondere
- auf das Buildsystem Gradle ein. Danach arbeiten Sie selbständig am Übung 3. Das Ziel dieser Übung ist, dass Sie sich einen 
+ auf das Buildsystem Gradle ein. Danach arbeiten Sie selbständig an Übung 3. Das Ziel dieser Übung ist, dass Sie sich einen 
  Überblick über die Strukturierung von JabRef verschaffen und lernen, wie Sie Code verstehen lernen können. 
 
 * [Übungsblatt 3](../exercises/code-reading). 

docs/week3/software-engineering-principles.md

@@ -11,23 +11,23 @@ layout: default
 ## Genauigkeit und formales Vorgehen 
 
 Softwareentwicklung ist ein kreativer Prozess. Trotzdem ist es unerlässlich, dass wir dabei ingenieurmässig, also systematisch, exakt und wenn möglich auch formal arbeiten. 
-Nur durch dieses systematisch und exakte Arbeiten wird es möglich, zuverlässig Software von hoher Qualität zu entwickeln. 
-Exaktes und auch formales Arbeiten steht keineswegs im Kontrast zu kreativem arbeiten. Im Gegenteil: Klare Regeln und klar definierte Komponenten können eine wichtige 
+Nur durch dieses systematische und exakte Arbeiten wird es möglich, zuverlässig Software von hoher Qualität zu entwickeln. 
+Exaktes und auch formales Arbeiten steht keineswegs im Kontrast zu kreativem Arbeiten. Im Gegenteil: Klare Regeln und klar definierte Komponenten können eine wichtige 
 Voraussetzung für das Erschaffen von kreativen Werken sein. So würde niemand auf die Idee kommen, Johann Sebastian Bach als nicht kreativ zu bezeichnen, weil er sich 
 an die starren Regeln der Musik und Harmonielehre gehalten hat. 
 
-Es gibt ganz verschiedene Stufen von Exaktheit. Die höchste Form ist dabei das (mathematisch) formale Vorgehen. Obwohl im Bereich Softwareengineering viel Forschungsarbeit im Gebiet der formalen Verifikation geleistet wurden, werden die wenigsten Softwareingenieure in ihrer Karriere ein Programm komplett formal spezifizieren können. 
+Es gibt ganz verschiedene Stufen von Exaktheit. Die höchste Form ist dabei das (mathematisch) formale Vorgehen. Obwohl im Bereich Softwareengineering viel Forschungsarbeit im Gebiet der formalen Verifikation geleistet wurde, werden die wenigsten Softwareingenieure in ihrer Karriere ein Programm komplett formal spezifizieren können. 
 Genaues und systematisches Arbeiten ist aber trotzdem während dem gesamten Entwicklungsprozess gefragt. So ist es zum Beispiel wichtig, dass ein Programm rigoros getestet wird, oder, dass der Entwicklungsprozess exakt und systematisch dokumentiert wird. 
 
 Ein Bereich, in dem sogar auch in der Praxis formal gearbeitet wird, ist die Spezifikation von Typsignaturen in Code.
-Die Typsignaturen in folgendem Code geben uns bereits starke hinweise darauf, was die funktion macht. 
+Die Typsignaturen in folgendem Code geben uns bereits starke hinweise darauf, was die Funktion macht. 
 ```java
 int foo(String bar) { ??? }
 ```
 Wir wissen, es wird ein Argument vom Typ String entgegengenommen, und darauf wird eine Ganzzahl erzeugt. 
 Beide diese Objekte, `int` und `String` sind genau formal definiert und wir wissen, welche Werte sie annehmen können und welche Operationen auf ihnen definiert sind. Dank solcher Typannotationen kann uns auch der Compiler unterstützen. Er überprüft anhand der Regeln der mathematischen Logik, dass unsere Verwendung der Funktionen im Programm aus Typsicht korrekt ist.
 
-Moderne Typensysteme lassen und hier auch immer komplexere Sachverhalte spezifizieren. Die folgende Typsignatur stammt aus der Java Standardbibliothek. Diese Typsignatur besagt, dass die Methode ```map```, auf 
+Moderne Typensysteme lassen uns hier auch immer komplexere Sachverhalte spezifizieren. Die folgende Typsignatur stammt aus der Java Standardbibliothek. Diese Typsignatur besagt, dass die Methode ```map```, auf 
 einen Stream vom Typ ```Stream<T>``` angewendet, einen Stream vom Typ ```Stream<R>``` zurückgibt, wenn die Funktion ```mapper``` ein Argument von Typ ```T``` in einen Wert von Typ  ```R``` abbildet. 
 ```java 
 interface Stream<T> extends BaseStream<T, Stream<T> > {
@@ -45,7 +45,7 @@ Die Fähigkeit von Software sich Veränderungen anpassen zu können passiert nic
 
 Ein gutes Beispiel für ein Design, welches Veränderungen vorausgesehen hat ist das Design von Java. 
 Ein Designziel von Java war, das Java Programme portabel sind, also auf verschiedenen Plattformen laufen können. 
-Es wurde vorausgesehen, dass sich aber Hardware und Betriebssystemfunktionalitäten laufend ändern würde und es somit mit grossen Aufwand verbunden wäre, die Java Umgebung laufend anzupassen. Die Lösung, die das Java Entwicklungsteam gewählt hat ist, dass Java Programme nicht direkt auf dem Betriebssystem laufen, sondern auf einer Virtuellen Maschine. Ändert sich nun die Funktionalität vom Betriebssystem, muss nur die Virtuelle Maschine angepasst werden. Die Java Software kann jedoch unverändert weiterlaufen. Damit muss nur ein kleiner, wohldefinierter Teil der Software angepasst werden, was viel weniger Aufwand bedeutet.
+Es wurde vorausgesehen, dass sich aber Hardware und Betriebssystemfunktionalitäten laufend ändern würden und es somit mit grossen Aufwand verbunden wäre, die Java Umgebung laufend anzupassen. Die Lösung, die das Java Entwicklungsteam gewählt hat ist, dass Java Programme nicht direkt auf dem Betriebssystem laufen, sondern auf einer Virtuellen Maschine. Ändert sich nun die Funktionalität vom Betriebssystem, muss nur die Virtuelle Maschine angepasst werden. Die Java Software kann jedoch unverändert weiterlaufen. Damit muss nur ein kleiner, wohldefinierter Teil der Software angepasst werden, was viel weniger Aufwand bedeutet.
 
 
 ## Allgemeinheit
@@ -82,12 +82,12 @@ Die verallgemeinerte Variante:
         }
     }    
 ```
-Wir sehen, dass hier die Implementation nicht schwieriger ist. Jedoch ist die verallgemeinerte Variante auf viel mehr Problem anwendbar. 
+Wir sehen, dass hier die Implementation nicht schwieriger ist. Jedoch ist die verallgemeinerte Variante auf viel mehr Probleme anwendbar. 
 Wir sehen jedoch auch, dass die Verallgemeinerung nicht ganz gratis kommt. Die Typsignaturen sind hier deutlich schwieriger zu lesen. 
 Häufig dauert auch die Entwicklung einer allgemeinen Version deutlich länger. Es ist also immer gut abzuwägen, wie allgemein man werden will. 
 
 
-## Schrittweises entwickeln
+## Schrittweises Entwickeln
 
 Anstatt dass wir ein Problem auf einmal lösen, können wir versuchen die Lösung inkrementell zu entwickeln. 
 Die erste Lösung ist dabei vielleicht nur eine grobe Approximation der endgültigen Lösung. In weiteren Schritten wird diese Approximation dann