You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

302 lines
16 KiB

2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
  1. # Mein Lerntagebuch für Programmiermethoden und -werkzeuge
  2. ### Julia Kunze
  3. ### Open Source
  4. - Pull-Request 1: https://git.spidermilk.ddnsfree.com/BeenToPrague/Java-Challenge/pulls/16
  5. - Pull-Request 2: https://git.spidermilk.ddnsfree.com/BeenToPrague/Java-Challenge/pulls/17
  6. - Pull-Request 3: https://git.spidermilk.ddnsfree.com/BeenToPrague/Java-Challenge/pulls/18
  7. - Pull-Request 4: https://git.spidermilk.ddnsfree.com/BeenToPrague/Java-Challenge/pulls/19
  8. - Pull-Request 5: https://git.spidermilk.ddnsfree.com/BeenToPrague/Java-Challenge/pulls/20
  9. ## SU 11 (18-01-2023)
  10. ### Lernziele
  11. Die Vorlesung dieser Woche behandelt die Besonderheiten von Objektorientierter Programmierung:
  12. - Motivation
  13. - Klassen
  14. - Verebung
  15. - Objektorientierte Algorithmen
  16. ### Erkenntnisse
  17. Objektorientierte Programmierung erfordert als ein eigenständiger Ansatz der Problemlösung eine andere Denkweise. Hauptsächlich soll Code wiederverwendet werden und prozeduale Algorithmen angewendet werden. Allerdings wird OOP oft auf Vererbung reduziert.
  18. ### Wiederholung
  19. Klassen weisen Attributen Eigenschaften und Zustände zu. Es gibt private und öffentliche Methoden der Implementierung.
  20. Wenn eine Klasse von einer anderen Klasse Eigenschaften erbt, so erweitert die abgleitete Klasse die Basisklasse und hat ein geändertes Verhalten.
  21. ### Kritik
  22. ## SU 10 (11-01-2023)
  23. ### Lernziele
  24. Das Thema der Vorlesung von dieser Woche ist Continous Integration:
  25. - Relevanz im Softwareentwicklungsprozess
  26. - Aufbau eines CI/CD-Systems
  27. - Ablauf des Prozesses
  28. - Bedeutung von automatisierten Tests
  29. ### Erkenntnisse
  30. Continous Integration ist im Softwareentwicklungsprozess relevant, das zeigt sich vor allem in komplexen Projekten mit mehreren Entwicklern, die ihre Einzelleistungen zusammenführen wollen.
  31. Der Vorteil von CI-Systemen liegt darin, dass das Konfliktpotential durch formale Prozesse und der Aufwand durch automatisierte Prozesse verringert werden.
  32. ### Wiederholung
  33. Ein CI-System besteht aus einer Entwicklungsumgebung (IDE), die das Programmieren vereinfacht und einem Source Code Management (SCM), die Zusammenarbeit ermöglicht und die Arbeit Einzelner sichert sowie zusammenführen kann.
  34. Die CI selbst kann übersetzen, Liefer-Artefakte erzeugen, Abhängigkeiten organisieren, automatisierte Tests ausführen, die SCM überwachen, den build Prozess starten und Ergebnisse berichten.
  35. ### Kritik
  36. ## SU 09 (21-12-2022)
  37. ### Lernziele
  38. Die Vorlesung dieser Woche behandelt Test Driven Developement.
  39. ### Erkenntnis
  40. Test Driven Development ist die geeignetste Vorgehensweise zu der Erstellung von den in der letzten Woche behandelten Unit Tests. Dabei entstehen der Test und der verifizierte Code gleichzeitig.
  41. Es ist eine sehr gute Vorgehensweise, sehr sinnvoll und zeiteffektiv.
  42. ### Wiederholung
  43. Der Entwicklungsprozess erfolgt inkrementell in "Baby Steps" und verhindert so den Flow.
  44. Dabei schreibt man einen neuen Test, der gerade so nicht kompliert werden kann und ein Minimum an Produktivcode, dass der Test erfüllt ist. Dabei wird der Code so simpel wie möglich gehalten. Anschließend wird der Code, d.h. Produktion und Test verbessert.
  45. ### Kritik
  46. ## SU 08 (14-12-2022)
  47. ### Lernziele
  48. Thema der Vorlesung: Automatisiertes Testen von Software
  49. - Motivation
  50. - Grundlagen
  51. - Unit Tests
  52. - Anforderungen an zu testenden Code
  53. ### Erkenntnisse
  54. Automatisierte Tests sind vorteilhaft gegenüber manuellem Testen. Sie können mit gleicher Präzesion und Qualität
  55. wiederholt werden, der Aufwand wird minimiert und die Schnelligkeit erhöht. Dabei ist das Erstellen von automatisierten Tests eine Fertigkeit, die geübt werden muss, zeitgleich
  56. müssen alle technischen Voraussetzungen sichergestellt sein. Tests mit häufiger Wiederholung, hoher Anzahl, hoher Kritikatiltät und hoher Stabilität sollten automatisiert werden.
  57. ### Wiederholung
  58. Was sind Unit Tests? Unit Tests haben einen hohe Testqualität, hohe Stabilität
  59. und niedrige Kosten (einfache API), jedoch dauern sehr lange und testen keinen Code. Sie werden im Entwicklungsprozess eingesetzt und zeigen die nicht erfüllten Anforderungen auf sowie den Fehler
  60. und unter welchen Bedingungen er auffzufinden ist. Desweiteren verhindern sie ungewollte Änderungen.
  61. Es wird sehr kleinschrittig getestet, ein einzelner Test prüft eine Erwartung an die Unit. Der Test kann nach jedem Speichern ausgeführt werden und ist wiederholbar.
  62. ### Kritik
  63. ## SU 07 (07-12-2022)
  64. ### Lernziele
  65. Thema der Vorlesung: Testen von Software
  66. - Grundlagen
  67. - Testmethodologie
  68. - Testprozess
  69. - pyschologische Aspekte
  70. ### Erkenntnisse
  71. Testen von Software ist wichtig, um zu beurteilen, da unerwünschtes Verhalten von Software zu teuren
  72. Fehlen führen kann. Dabei wird geprüft mit einer geeigneten Methode und Testumgebung (Infrastruktur), ob das Objekt
  73. den Erwartungen entspricht und die Forderungen erfüllt. Dabei können Fehler latenter, maskierter und kaskadierter Art auftreten:
  74. - latent: entsteht durch unerwartete Daten, die durch den Anwender gelöst werden
  75. - maskiert: wird von latenten Fehlern überdeckt
  76. - kaskadiert: Folgefehler an anderer Stelle
  77. ### Wiederholung
  78. Testmethodologie:
  79. Bestandteile eines Tests sind: eine Stichprobe mithilfe von Testfällen und Daten, das Testobjekt, die Testumgebung,
  80. das Testziel und ein Soll-/Ist- Wertvergleich. Dabei ist immer das Ziel eines Tests, die Qualität zu erfassen und
  81. Fehler aufzuzeigen, um das Vertrauen der Funktionalität der Software zu erhöhen. Es wird auf verschiedenen Ebenen getestet:
  82. Anwedungsebene, Modulebene und Codeebene.
  83. ### Kritik
  84. ## SU 06 (30-11-2022)
  85. ### Lernziele
  86. - Grundlagen und Begriffe des Projektmanagements
  87. - Rollen im Projektmanagement
  88. - Modelle des Projektmanagements
  89. - Aufwandsschätzung und Beispiele
  90. ### Erkenntnisse
  91. Bei einem Projekt geht es um die Zusammenarbeit von Menschen, in der jeder seine Aufgabe hat. Es gibt einen Auftraggeber, der die Prioritäten, Rahmenbedingungen und Inhalt vorgibt, desweiteren gibt es Projektmitarbeiter, die Teilaufgaben umsetzen und den Projektleiter, der das Projekt koordiniert.
  92. - Projekte müssen geplant und organisiert sein.
  93. - Nein sagen ist legitim.
  94. - Dokumentation der einzelnen Fortschritte des Projektes ist sehr hilfreich für eine bessere Übersicht der bisher umgesetzten Aufgaben und um den weiteren Aufwand des Projektes einzuschätzen
  95. ### Wiederholung
  96. Bezüglich des Projektmanagements gibt es verschiedene Modelle:
  97. - Wasserfall Modell: lineare Abarbeitung der Prozessschritte, die einmal durchlaufen werden
  98. - V-Modell als Erweiterung des Wasserfallmodells, es gibt parallel zu den Entwicklungsschritten Testebenen
  99. - Agile Modell: Fokus liegt auf funktionierender Software, weniger auf der Dokumentation und des Festhalten an einem Plan. Hierbei kann man flexibel auf Veränderungen und die Kunden eingehen.
  100. Dabei gibt es zusätzlich zu den Modellen verschiedene Techniken der Organisation des Projektes:
  101. - Kanban: Mithilfe einer Workflow-Darstellung werden die Teilaufgaben definiert und vergeben
  102. - Burn-Down-Chart: Fokus liegt auf Aufwands- und Zeiteinschätzung bereits bekannter, fixer Arbeitspakete, Projektfortschritt über Zeit einsichtbar
  103. - Scrum: Absprache und Austausch durch regelmäßige Meetings und tracking der story points
  104. ### Kritik
  105. ## SU 05 (23-11-2022)
  106. ### Lernziele
  107. - Softwareentwicklung im Team: Prozess und Organisation
  108. - automatisierte Tests
  109. - Vorgehensmodelle
  110. ### Erkenntnisse
  111. Eine Kooperation im Softwareprozess kann von Vorteil sein, wenn die Komplexität und der Aufwand des Projektes steigt. Dabei können jedoch, da jeder eigenständig an seinen Ideen arbeitet, Codekonflikte entstehen. Daher ist ein Source Code Management System (SCM) von Vorteil, da zwischen Entwicklungsständen gewechselt werden kann, parallele Arbeit möglich ist und Codekonflikte automatisiert oder per Hand behoben werden können.
  112. ### Wiederholung
  113. Ein Softwareentwicklungsprozess ist abgebaut aus den Bestandteilen: Code schreiben, Abhängigkeitsverwaltung, Code veröffentlichen, Integration, build-Prozess mit Kompilieren und Testen und die Bereitstellung.
  114. Modelle der Kooperation liegen einerseits dem "gemeinsamen remote repository" zugrunde, dabei arbeiten alle Entwickler gegen ein remote repository, wo jeder Schreibzugriff hat und gepushte Zwischenstände leicht sichtbar sind.
  115. Anderseits beschreibt das zweite Modell "privater fork" das es ein zentrales remote repository (master) gibt, und jeder Entwickler hat sein separates (fork), dabei unterscheiden sich die Zugriffsrechte: bei master nur lesend und beim fork schreibend.
  116. ### Kritik
  117. ## SU 04 (16-11-2022)
  118. ### Lernziele
  119. - Was ist Git?
  120. - Vorteile von Git
  121. - Kennenlernen von Branching, Merging
  122. ### Erkenntnisse
  123. Git ist sehr vorteilhaft für Gruppenprojekte und erleichtert die Zusammenarbeit für Entwickler.
  124. Als Versionsverwaltungssystem vereinfacht Git das gesamte Management von
  125. einem Projekt, indem Entwickler dezentral mit der Kopie des Hauptrepositorys bzw. dem eigenen Branch entwickeln können.
  126. Der Projektverantwortliche kann über "merge" oder "cherry-pick" (Nutzen einzelner
  127. Commits) Commits in den Hauptzweig übernehmen.
  128. Dabei werden Commits, also Änderungen, die an dem Projekt durchgeführt werden,
  129. kommentiert, was die Zuordnung und die Übersicht erleicht, vor allem bei Fehlern,
  130. wo auf alte Commits zurücknavigiert werden kann, um Fehler zu beheben.
  131. Daher sollten Commits kleinschrittig gemacht werden, um Konflikte durch Git oder
  132. manuell einfacher zu lösen.
  133. ### Wiederholung
  134. Was ist Git?
  135. Git ist eine Software für die Versionsverwaltung von Projekten.
  136. Versionsverwaltunssystem bedeutet, das man jederzeit auf alte Versionen des
  137. Projektes zugreifen und Commits einfach
  138. zurücksetzen und zu einem früheren Stand des Projektes navigieren kann.
  139. Jedes Projekt hat einen Hauptentwicklungszweig, den sog. master Branch,
  140. dabei können weitere Nebenzweige erstellt werden, um parallel zum Hauptzweig
  141. zu entwickeln, ohne den Hauptentwicklungszweig zu beeinflussen.
  142. Dabei können die Zweige wieder zusammengeführt werden, das nennt sich "mergen".
  143. #### Nützliche Git Befehle
  144. - Lokales Repository anlegen: `git init`
  145. - Status des Repositorys: `git status`
  146. - Datei zur Stage hinzufügen: `git add "Dateiname"` oder `git add .`
  147. - Änderungen commiten: `git commit -m "Nachricht"`
  148. - Historie der Commits anzeigen: `git log`
  149. - Historie der Commits in allen Branch anzeigen (mit Graph): `git log --oneline --all --graph`
  150. - Nicht committete Veränderungen anzeigen: `git diff`
  151. - Auf einen früheren Commit zurücksetzen: `git reset --hard "hash"`
  152. - Neunen Branch erstellen: `git branch name`
  153. - Branch wechseln: `git switch name`
  154. - Alle Branches anzeigen lassen: `git branch`
  155. - In aktuellen Branch mergen: `git merge "name"`
  156. - Den Merge abbrechen: `git merge --abort`
  157. - Markierung setzen: `git tag "name"`
  158. - Ins Remote Repository pushen: `git push`
  159. ### Kritik
  160. ## SU 03 (09-11-2022)
  161. ### Lernziele
  162. - Entwurfsmuster
  163. - IDE
  164. ### Erkenntnisse
  165. Es ist sehr sinnvoll, Quellcode mithilfe einer integrierte Entwicklungsumgebung (IDE) zu schreiben, denn IDEs haben viele nützliche Vorteile, die das Programmieren vereinfachen.
  166. Sie verfügen über einen Editor, mit dessen Hilfe man den Programmcode schreiben kann.
  167. Überdies ist ein Compiler integriert, der den Code in Maschinensprache übersetzt und ihn zu einem ausführbarem Programm zusammensetzt und haben zusätzlich auch Debugger, der bei der Fehlersuche hilft.
  168. Ein weiterer Vorteil, um die Arbeit zu erleichtern, ist die Syntax-Highlighting, das die Elemente farblich hervorhebt.
  169. ### Wiederholung
  170. Was sind Entwurfsmuster? Entwurfsmuster sind Lösungsvorlagen für wiederkehrende Entwurfsprobleme in der Softwarearchitektur und -entwicklung. Es beschreibt eine Lösung für eine bestimmte Klasse von Entwurfsproblemen, die in einem bestimmten Zusammenhang wiederverwendet werden kann.
  171. Es gibt unterschiedliche Arten: Erzeugungsmuster, Strukturmuster, Verhaltensmuster, Muster für objektrelationale Abbildung und Nachrichtenübermittlungsmuster. Dabei sind die Anforderungen an jedes Muster gleich, es soll:
  172. - ein oder mehrere Probleme lösen
  173. - ein erprobtes Konzept basierend auf realen Designs bieten
  174. - den Benutzer in den Entwurfsprozess einbinden
  175. - tiefergehende Strukturen und Mechanismen eines Systems umfassen
  176. - Referenzen zu anderen Mustern beinhalten
  177. ### Kritik
  178. ## SU 02 (03-11-2022)
  179. ### Lernziele
  180. Inhalte: unterschiedliche Programmierparadigmen
  181. 1. Imperative Programmierung: ein Programm bestehend aus einer Folge
  182. von Anweisungen, die sequenziell von der Maschine ausgeführt werden
  183. 2. Prozedurale Programmierung: Erweiterung der Imperativen Programmierung mit dem Unterschied,
  184. Algorithmen werden in übersichtliche Teile (Unterprogramm/Routine/Prozedur/Funktion) zerlegt
  185. 3. Declarative Programmierung: grundlegend ist die Beschreibung eines Problems/Funktion eines Programms,
  186. nicht die Umsetzung
  187. 4. Funktionale Programmierung: Erweiterung der declarativen Programmierung, Deklarierung von Funktionen und Verknüpfung von Daten,
  188. Computerprogamme = Funktionen, die zu einer Eingabe eine Ausgabe liefern
  189. 5. Objektorientierte Programmierung: Struktur einer Software ist an realtitätsnahe Anwendung angelehnt,
  190. unterstützt Klassen, Objekte und Vererbung
  191. 6. typisierte Programmiersprachen: für Variablen/Parameter/Rückgabewerte ist der Datentyp implizit/explizit definiert, Vervollständigungsvorschläge durch IDE
  192. 7. typenlose Programmiersprachen: Datentyp für Variablen/Parameter/Rückgabewerte ist nicht deklariert
  193. 8. Prinzipien der Programmierung: STUPID vs. SOLID
  194. ### Erkenntnisse
  195. Programmieren liegt bestimmten Prinzipien zugrunde,
  196. dabei sollte die Software so komplex wie nötig, aber so einfach wie möglich sein.
  197. Das bedeutet, das jede Klasse nur eine einizige Verantwortung zugeordnet werden soll,
  198. um Fehler zu vermeiden. Ein Code sollte zudem offen für Erweiterungen (z.B. Vererbungen), aber geschlossen für Änderungen sein.
  199. Zudem sollten große Schnittstellen (Interfaces) vermieden werden und diese in kleinere aufgeteilt, um die Anforderungen besser zu erfüllen.
  200. Das Solid Prinzip an sich ist somit ein Prinzip, um einen sauberen, guten Code zu programmieren und das im Gruppenprojekt evtl. von Vorteil sein kann.
  201. ### Wiederholung
  202. Programmierparadigmen beschreiben grundlegend den Stil, in dem ein Programm entworfen wird.
  203. Es gibt verschiedene, unterschiedliche Programmierparadigmen, die sich darin unterscheiden,
  204. dass sie unterschiedlichen Prinzipien und Herangehensweisen zugrundeliegen. Ein Beispiel ist die Imperative Programmierung,
  205. hierbei besteht das Programm aus einer bestimmten Reihenfolge von Anweisungen, die Schritt für Schritt von der Maschine ausgeführt wird.
  206. Es ist analog wie ein Kochrezept zu verstehen und sehr hardwarenahe.
  207. ### Kritik
  208. Für mich persönlich wäre es angenehmer gewesen, da ich noch sehr wenig Programmiererfahrung habe und
  209. das ganze Thema für mich sehr komplex war,
  210. die Programmierparadigmen anhand von konkreten bildlichen Beispielen erklärt zu bekommen.
  211. Beispielsweise direkt an einem Code in dem jeweiligen Programm, sodass man diese gegenüberstellen und verlgeichen kann.
  212. ## SU 01 (26-10-2022)
  213. ### Lernziele
  214. - Organisatiorisches
  215. - Eigenschaften eines Softwareentwicklers - sowohl Künstler als auch Handwerker
  216. - Abgrenzung des Laien vom Profi mithilfe Fachwissen, Werkzeuge und Prinzipien
  217. - Folgen von Unprofessionalität
  218. - Anlegen eines Vorlesung-Repository
  219. - Kennenlernen von GOGS/GitLab, Git Befehle und markdown
  220. ### Erkenntnisse
  221. Ich habe gelernt, wie ich auf GOGS ein Repository anlege, als auch wie man dort einen Eintrag hochladen kann.
  222. Über das Terminal kann man mithilfe von Git Befehlen eine Datei pushen und so wird ein Commit hochgeladen.
  223. Die Erkenntnis kann ich später beim Gruppenprojekt nutzen, das wir durch Commits erstellen und weiterentwickeln können.
  224. Außerdem habe ich gelernt, das Softwarefehler teuer werden können :).
  225. ### Wiederholung
  226. Was sind Git Befehle und wie kann ich einen Commit machen?
  227. Git Befehle nutzt man, um mit Git interagieren zu können. Um dort Änderungen hochzuladen,
  228. nutzt man die Befehle:
  229. - git status
  230. - git add file (die markdown Datei zum tracken hinzufügen)
  231. - git commit (um die Änderung beschreiben)
  232. - git push -u origin master (somit wird der Commit hochgeladen)
  233. - git init (Ordner wird im Git erkannt)
  234. - git log (Sehen des Commits)
  235. ### Kritik
  236. Bisher noch nichts.