Aufgaben für das Programmierpraktikum (k-fach-Bachelor-/Masterarbeit)
ist bereits in Bearbeitung durch mehrere Studierende, aber es gibt so viel zu tun, dass weitere willkommen sind.
Im Bachelorstudiengang Informatik wird es ab Sommersemester 2024 ein Programmierpraktikum (5 LP, kurz genannt "!ProPra") geben, das das Modul "Softwaretechnik" ergänzt und für die handwerklichen Grundlagen einer
professionellen Softwareentwicklung für Einzelpersonen (nicht Teams) sorgen soll: Kenntnis der Programmiersprache, Umgang mit Bibliotheken, mit automatisierten Tests, mit Bestandscode, mit den wichtigsten Werkzeugen, etc. Zusammen liefern die beiden Module die Voraussetzungen für das Modul "Softwareprojekt",
in dem die Arbeit im Team im Mittelpunkt steht.
Auch in anderen Studiengängen wird das ProPra angeboten und zwar auf Basis des 30-LP-Modulangebots Informatik. Dann hat es andere Umfänge (6 LP oder 9 LP). Diese Studierenden bringen weniger Vorkenntnisse in Informatik mit als die Mono-Bachelors.
Wir entwickeln das Gesamtkonzept für das Programmierpraktikum und die zahlreichen Einzelaufgaben gemeinsam als Team, aber durch Abgrenzung gewisser Themenbereiche entstehen dabei separate Abschlussarbeiten.
Prinzipien des Programmierpraktikums (ProPra)
- Motivationsprinzip: Das ProPra lebt vom Lernwillen und der Eigenmotivation der Studierenden, weil das erstens didaktisch wünschenswert ist und zweitens praktisch anders gar nicht machbar wäre. Deshalb sind die Aufgaben vorwiegend als Lernaufgaben konzipiert, nicht als Prüfungsaufgaben. Das heißt erstens, die Aufgaben selbst zielen auf den Erwerb von Kompetenzen, nicht auf ihre Überprüfung oder Überprüfbarkeit. Es heißt zweitens, die Kontrollhinweise für die Tutor_innen zielen nicht auf eine umfassende und präzise Überprüfung dessen, was die Studierenden als Ergebnis erzielt haben, sondern auf eine ungefähre Abschätzung, ob der Lernschritt erfolgt ist, der mit der Aufgabe hauptsächlich beabsichtigt war.
- Wahlprinzip: Die Studierenden sollen eine möglichst große Freiheit dabei genießen, wie sie agieren und welche Themengebiete sie bearbeiten wollen. Dazu können sie aus einer Menge von Aufgaben überwiegend selbst auswählen. Überwiegend können die Studierenden die Aufgaben in jeder gewünschten Reihenfolge abarbeiten. Eine Ausnahme ist der Basisbereich, der als erstes bearbeitet werden muss. Ansonsten gibt es bei vielen Aufgaben Wissensvoraussetzungen ("assumes") und bei manchen Aufgaben Produktvoraussetzungen ("requires"), die zwingend (bei "requires") oder möglicherweise (bei "assumes") verlangen, dass zuvor gewisse andere Aufgaben bearbeitet werden. Diese Voraussetzungen sind ausdrücklich markiert. Das ProPra verwendet "requires"-Kopplungen nur, wo sie aus didaktischen Gründen nötig sind -- in der Regel, um motivierende größere Aufgaben aus kleineren Einzelteilen darstellen zu können.
- Zeitumfangsprinzip: Jede Aufgabe bekommt ihren erwarteten Zeitaufwand als Zeitwert zugewiesen. Aufgaben sind 0.25 bis 4 Stunden groß; am häufigsten 1 Stunde. Die Studierenden müssen in der Summe Aufgaben im Zeitwert des Modulumfangs absolvieren; bei 5 LP also z.B. 5*30=150 Stunden. Das Modul ist nicht benotet.
- Entkopplungssprinzip: Die Auswahl und Bearbeitung der Aufgaben kann völlig selbständig, entkoppelt von irgendwelchen festen Veranstaltungszeiten erfolgen.
Einzig, wenn Teilnehmende Päckchen von gelösten Aufgaben zur Kontrolle bei einer Tutor_in vorlegen möchten, kann eine zeitliche Bindung erfolgen.
- Paararbeitsprinzip: Die Studierenden werden stark ermuntert, die Aufgaben (aber nur teilweise die Formulierung der eigentlichen Abgabe) in Paarprogrammierung zu erledigen. Wer möchte, darf aber auch allein arbeiten.
- Reflektionsprinzip: Die Leistung, die die Studierenden erbringen, besteht nicht nur darin, ein Arbeitsergebnis vorzuzeigen, sondern sie sollen in der Lage sein, diese Ergebnisse zu erläutern: Was bedeutet das? Wie ist es zustande gekommen? Was war dabei am schwierigsten? Dazu gibt es in vielen Aufgaben Reflektionsfragen.
- Sparsamkeitsprinzip: Die Kontrolle der Aufgaben soll für die Tutor_innen sehr zügig möglich sein. Deshalb heben die Kontrollhinweise hervor, was mindestens sicherzustellen ist (und welche Hinweise die Studierenden bekommen sollen, wenn es nicht erfüllt ist), und deshalb werden, wo sinnvoll möglich, Vorgaben in den Aufgaben so formuliert, dass sich eine beinahe kanonische Form der Abgabe ergibt (z.B. Kommandoprotokolle).
- Varianzprinzip: Das Programmierpraktikum soll für leistungsschwächere Studierende ohne stark explodierenden Zeitaufwand machbar sein, zugleich aber für sehr leistungsstarke Studierende oder solche mit viel Vorwissen ein interessantes Lernpensum bereithalten. Das wird hauptsächlich durch zwei Maßnahmen erreicht:
- Es gibt Aufgaben der Schwierigkeitsstufen sehr einfach, einfach, mittel und schwierig. Je nach Leistungsstand sucht man sich bevorzugt ein anderes Niveau heraus.
- Insbesondere in den Stufen leicht und mittel enthalten die Aufgaben optionale Hilfshinweise, die anfangs nicht sichtbar sind und im Bedarfsfall von den Studierenden aufgeklappt werden, um das Niveau auf sich abzustimmen.
Aktueller Stand des Programmierpraktikums
Damit die Teilnehmenden genug Wahlmöglichkeiten haben, soll dreimal so viel Aufgabenumfang angeboten werden wie zum Absolvieren des Programmierpraktikums nötig ist, sogar, wenn man die als "schwierig" gekennzeichneten Aufgaben
nicht mitrechnet.
Die Ergebnisse sammeln wir hier:
Wie viel gibt es noch zu tun? Viel!
Was gibt es noch zu tun? Dafür schmökert man am besten in die Dateien "how-to.md" und "aufgabenideen.md" in propra-inf.
Die Aufgaben ("tasks") sind eingeteilt in "chapters" (große Themenbereiche) und darin liegende "taskgroups" (Sub-Themenbereiche)
Die Abschlussarbeiten: Allgemeines
Aufteilung der Arbeit, Zusammenarbeit
Wir (d.h. alle Studierenden plus Prof. Prechelt) erarbeiten das Programmierpraktikum als Ganzes im Team. Zur Koordination verwenden wir neben dem github-Projekt einen Discord-Server. Wir treffen uns wöchentlich (Di 17:15 Uhr) einmal kurz zum Austausch per Webex. Jede Abschlussarbeiter_in übernimmt mindestens einen Aufgabenbereich weitgehend alleine.
Andere Teile werden flexibel aufgeteilt oder sogar gemeinsam bearbeitet;
dazu zählt insbesondere vieles, was nicht spezifisch für einzelne Aufgaben ist,
sondern Querschnittcharakter hat.
Solche Zusammenarbeit ist kein Problem, solange sie in der schriftlichen Ausarbeitung
klar deklariert wird: Wer hat zu dem-und-dem jeweils wie viel beigetragen?
Arbeiten von anderen werden insoweit beschrieben, als das zum Verständnis der eigenen
Teile sinnvoll ist.
Schriftliche Ausarbeitung: Bachelorarbeit
Die schriftliche Ausarbeitung (deren Umfang laut Prüfungsordnung nur ca. 7500 Wörter umfassen soll, also ca. 15 Seiten; da knapp schreiben schwer ist, kommt aber oft das Doppelte vor) beschreibt die Produkte der Arbeit überblicksartig und konzentriert sich ansonsten auf den Prozess, z.B.:
- Didaktisches Konzept (siehe unten)
- Recherche nach verwandten Arbeiten oder wiederverwendbaren Teilen
- Besondere Schwierigkeiten (und ihre Lösung) bei einzelnen Aufgabenstellungen
- Was hat wie lange gedauert und (bei den unerwartet langen Teilen) warum?
- ggf. Reflektion der Zusammenarbeit; besondere Schwierigkeiten und ihre Lösung
Didaktisches Konzept
Das didaktische Konzept stellt das Herzstück einer Abschlussarbeit dar. Man sollte es nach der Einarbeitung deshalb tunlichst bald in Angriff nehmen; das erleichtert auch die Konzeption der einzelnen Aufgaben. Bearbeitet man mehrere Themenkreise, kommen auch mehrere separate didaktische Konzepte in Frage. Das Konzept sollte folgende Fragen beantworten (und zwar meist nicht in Frage/Antwort-Form):
- Welche (ggf.) methodischen Kompetenzen sollen die Teilnehmenden erwerben?
Dies ist in manchen Themenkreisen dominant (z.B. Testen oder git), bei vielen zumindest auch relevant (z.B. wie entwickelt man reguläre Ausdrücke?), bei noch anderen nicht von Interesse.
- Welche technischen Bausteine/Elemente/Aspekte sollten mindestens behandelt werden?
Z.B. weil sie praktisch wichtig sind oder weil sie verständnisfördernd sind.
- Welche Granularität und Schwierigkeit von Aufgaben und Aufgabenblöcken ist sinnvoll? Warum?
z.B. sollte Grundlagenwissen auf Stufe "leicht" behandelt werden, hochspezielles eher auf "mittel" oder "schwierig".
z.B. sollte Grundlagenwissen möglichst in kleinen, unabhängigen Aufgaben zu erlernen sein, aber hohe Motivation ist vielleicht eher mit größeren Vorhaben zu erzielen, was dann umfangreiche Aufgaben bedeutet und/oder Ketten von "requires"-Abhängigkeiten.
- Kann/sollte/muss ein "Erzählbogen" über mehrere Aufgaben gespannt werden (das ist aber schlecht für deren Unabhängigkeit!), um z.B. größere konzeptuelle Zusammenhänge oder typische Nutzungsmuster zu erklären?
Was spricht dafür oder dagegen? Welche Gestaltungsalternativen gibt es?
- Wie motiviert man thematische Aufgabenblöcke?
Ein Aufgabenblock kann einer Taskgroup entsprechen oder durch assumes/requires-Abhängigkeiten aufgespannt werden und dann auch über ganz verschiedene Taskgroups hinweg reichen. Vermutlich muss der Block aber irgendwo als solcher besprochen sein. Evtl. kann das über Terminologie eingeflochten sein und im Glossar passieren.
- Gibt es themenkreis-spezifische Aufgabentypen, die man mehrmals verwenden könnte, z.B. um die Effizienz beim Erklären oder Abarbeiten zu erhöhen?
- Welche verschiedenen Interessenprofile der Teilnehmenden können/wollen die Aufgaben ansprechen? Welche Profile von Vorkenntnissen?
- Welche Schwierigkeiten sind zu erwarten? Wie kann man sie mildern?
Schwierigkeiten können technischer Art sein (z.B. Plattformabhängigkeiten) oder didaktischer Art (Verständnisschwierigkeiten, Lösungsschwierigkeiten) oder motivatorischer Art (Relevanz ist schwierig zu erklären), etc.
Zusätzliche Aspekte für eine Masterarbeit
Die bis hierher beschriebenen Bachelorarbeiten stellen hohe Anforderungen an das informatische Denken, das Wissen und die Urteilskraft. Sie verlangen eine begründete und systematische Herangehensweise und in diesem Sinne ein wissenschaftliches Arbeiten; Sie haben aber nicht den Charakter wissenschaftlicher Forschung. Der ist für eine Masterarbeit jedoch hochgradig wünschenswert.
Deshalb wird die Masterarbeit um einen Forschungsaspekt ergänzt: Evaluation und Qualitätssicherung. Das bedeutet die Bearbeitung z.B. der folgenden Fragen und Aufgaben:
- Welche Forschung gibt es zu solchen Programmierpraktika?
- Mit welchen Verfahren bewertet man den Lernerfolg?
=> Auswählen und umsetzen; mit Pilotstudierenden bewerten; Rückschlüsse ziehen und ggf. Maßnahmen einleiten (Aufgabenauswahl)
- Mit welchen Verfahren bewertet man die Eignung und Qualität der Aufgaben?
=> Auswählen oder entwickeln und ansatzweise umsetzen; Rückmeldung in die Aufgabenentwicklung liefern.
- das impliziert z.B. an geeigneten Punkten im Verlauf Usability-Prüfungen: Jeweils i.d.R. nur 2-3 Versuchspersonen bearbeiten selbständig eine eng begrenzte Aufgabenstellung und berichten dabei live ("think aloud") oder im Anschluss (Interview) von ihren Erfahrungen, die dann in Verbesserungen umgesetzt werden.
- Im größeren Stil kann man sich auch Pilotstudierende vorstellen, die das Programmierpraktikum als Forschungspraktikum angerechnet bekommen.
- Wie die Balance ist zwischen solchen analysierenden Maßnehmen einerseits und Verbesserungsarbeiten an den Aufgaben andererseits, müssen wir unterwegs herausfinden.
Der Fokus bleibt aber ingenieurmäßig: Am Ende wollen wir nicht vor allem Erkenntnisse haben, sondern vor allem ein tolles Programmierpraktikum.
Benotung
Für die Note spielt die schriftliche Ausarbeitung nur für das didaktische Konzept eine Hauptrolle; ansonsten steht das praktische Arbeitsergebnis in Form von Aufgaben im Vordergrund. Die Ausarbeitung ist als eine Art Nebenprodukt der Erarbeitung der Aufgaben anzusehen und verlangt also nicht viel Arbeitszeit. Der bisherigen Erfahrung nach ist der Zeitaufwand für eine Aufgabe je nach Typ 4-6 mal so groß wie der Umfang der Aufgabe. Nehmen wir an 5 mal. Eine Bachelorarbeit hat 12 LP, also 360 Stunden. Rechnet man für die Ausarbeitung und den Vortrag ein Viertel ab (90 Stunden), plus 20 Stunden für die Einarbeitung zu Beginn, so sollte eine
ProPra -Bachelorarbeit idealerweise Aufgaben im Umfang von 50 Stunden erarbeiten (250 Stunden geteilt durch 5). Die Erfahrung zeigt, dass diese Marke meist verfehlt wird; dann sollte die Ausarbeitung den Zeitverlauf entsprechend erklären.
Eine sehr gute Arbeit hat diesen Umfang (54 Stunden neue
ProPra -Aufgaben) und diese Aufgaben sind praktisch, motivierend, klar und unmissverständlich formuliert, verlangen nur wenig Aufwand in der Schlussredaktion und sind für die Tutor_innen leicht zu kontrollieren. Eine ausreichende Arbeit hat etwa den halben Umfang und die Aufgaben sind weit überwiegend praktischer Natur, aber sie verlangen häufig erhebliche Nacharbeiten, bis sie motivierend genug, klar genug und genügend gut kontrollierbar sind.
Eine Masterarbeit produziert entweder den gleichen Aufgabenumfang wie eine Bachelorarbeit und setzt zusätzlich die oben beschriebenen zusätzlichen Aspekte in entsprechendem Umfang und Qualität durch, oder macht bei den zusätzlichen Aspekten gewisse (teilweise!) Abstriche zugunsten von erhöhtem Aufgabenumfang.
Die Abschlussarbeiten (in ungefähr chronologischer Reihenfolge)
MA Christian Hofmann: Aufgaben des Programmierpraktikums zum Arbeiten mit Bestandscode
Siehe die oben unter "Masterarbeit" beschriebenen Aspekte. Darüber hinaus Hauptverantwortung für den Gesamtablauf, die Qualitätssicherung und den Aufgabenbereich Programmverstehen:
- Mitarbeit am sedrila-Werkzeug
- Systemtest/Akzeptanztest von
sedrila
und des Gesamtablaufs auf Studierenden- und auf Tutor_innenseite.
- Aufgabengruppen zum Thema Arbeiten mit Bestandscode:
- Wie erschließt man sich für ein gegebenes Arbeitsziel ein geeignetes Teilverständnis einer großen Codebasis?
Lernziel: Überwindung des Gefühls der Hilflosigkeit; Grundkenntnisse in 2-4 verschiedenen Taktiken zum Aufbau von Verständnis (z.B. Codelesen, Tracing/Stepping, statische Codeanalyse/Maße) und diverser Handlungsbausteine für jede davon
- Wie macht man risikoarm Änderungen an einer großen Codebasis?
Verbesserung der Beobachtbarkeit, Ergänzung von Tests
- Teamabläufe in diesem Umfeld (zusammen mit Sven Hüster): Pull-Requests, Codereviews, CI
- Mitarbeit an den Aufgaben zur Webentwicklung
BA Dominik Pietrak (abgeschlossen): Aufgaben des Programmierpraktikums zu Debugging und Refactoring
- siehe Repo propra-inf
- Debugging: Erlernen einer handvoll methodischer Elemente für erfolgreiches Debugging (Prinzipien, abstrakte Schrittfolge aus: Reproduzieren, Erkundend weiterbeobachten, Hypothesebilden, Hypotheseprüfen) und handwerklicher Aspekte dazu (Codelesen, ad-hoc print-Debugging, dauerhafteres log-Debugging, automatisierte Tests, Benutzung des Debuggers, Refactoring)
- Refactoring (jeweils: Mechanik verstehen, üben, sinnvolle Einsatzfälle verstehen, üben): Rename, Extract Variable, Extract Method. Evtl. fortgeschrittenere. Grenzen der IDE verstehen, z.B. aufgrund von Polymorphie, aufgrund von dynamischer Typisierung.
BA Sven Hüster: Aufgaben des Programmierpraktikums zu Git und Shell
- Git1: Beherrschung des Basissatzes von Kommandos mit gutem konzeptuellen Verständnis dafür, was sie bedeuten (d.h. bewirken). Commit, Tree, Blob. Refspec.
- Git2: Kenntnis (mit mindestens Ausprobieren oder besser noch richtigem Üben) der Idiome für alltägliche Situationen wie: Rebase/Merge mit Konflikten; Rückgängigmachen von Schritten; Unterbrechen von Arbeiten (stash); etc.
Hier kann man schön Gebrauch von der Paararbeit machen, indem die beiden parallel am gleichen Repo arbeiten!
- Git 3: Fortgeschrittene Kommandos (jedenfalls ein paar wichtigere davon)
- Shell interaktiv (bash): Globbing, Pipes, Umlenkung, Variablen, Prompt bauen, Aliases, history, history substitution, man
- Shellprogrammierung: sh, bash (Pipes, Umlenkung, Variablen, if/else, for, while, Spezialvariablen, Unterprogramme, Quoting, statuscodes (siehe z.B. curl), …).
Lernziel: Situationen verstehen, in denen man das jeweils gebrauchen kann.
Mindestens ein nicht-triviales Shellskript selbst schreiben und eines verstehen und modifizieren.
- Umgang mit Dateien: ls, mv, rm, cp, mkdir, rmdir, ….
Lernziel: die Fälle verstehen, in denen das einer GUI überlegen ist: mit Globbing, mit mehreren Argumenten, mit speziellen Optionen
- Typische Helfer für die Shellprogrammierung (wie touch, cat, head, tail, grep, uniq, sort, find, awk, sed, xargs, tee, …) und typische Idiome.
Lernziel: Je mindestens einen gut erinnerbaren Anwendungsfall ausprobieren, in dem das Helferlein gute Dienste leistet.
BA Ronny Ruhe: Aufgaben des Programmierpraktikums zum Aufgabenfeld Testen
- Testgrundlagen: Fehler, Testpyramide, Testfälle, Abgrenzung Test/Debugging
- Grundlagen Testframeworks: unittest, pytest
- Entwurf von Tests reiner Funktionen (pure functions): Funktionstest (black box test), Strukturtest (white box test).
- Tests von Prozeduren mit Seiteneffekten und guter Beobachtbarkeit
- Tests von Prozeduren mit Seiteneffekten und schlechter Beobachtbarkeit: Spy ("mock"), Injektionsmethoden (Unterklasse, Injektion per Konstruktor, …)
- Tests von schwergewichtigen Prozeduren: Stub ("mock")
- Tests von Prozeduren, die schwer herstellbare Testbedingungen brauchen: Stub ("mock") für Zeit-Ersatz, Fehlerbedingungen, etc.
- Gezieltes Füllen von Lücken in der Testabdeckung: coverage
- Gängige Arten von Testgegenständen: CRUD, REST API, …
- Fortgeschrittene Features von pytest (ggf. schon weiter oben einstreuen): Tabellensteuerung, skip, xfail, capsys, …
- Fortgeschrittene methodische Aspekte: TDD, Ping-Pong-Pairprogramming
- andere Testframeworks: Robot Framework, Locust, Gherkin, Playwright
- Linting: black, bandit, flake8, isort, markdownlint
Abseits davon - Aufgaben die als Referenz für das Testen verwendet werden können:
- SQL Taskgroup, Basics, Joins, Selects und Projektaufgabe
- Pythonpraxis-Anteile: Passwortgenerator
BA Ivan Condric: Aufgaben des Programmierpraktikums zu Netzwerk und Systemadministration
- ssh: Schlüsselpaar erzeugen, ~/.ssh, ssh, ssh-agent, tmux, …
- lokales System, z.B. evtl.: w, uptime, whoami, df, du, tail -f, mount, ps, pgrep, kill/pkill, top/htop, ...
Lernziel: Situationen verstehen, in denen man das jeweils gebrauchen kann.
- Mitarbeit bei "Typische Helfer für die Shellprogrammierung" (Hüster)
- Dateisystemaufbau: /bin, /usr, /var, /etc, /mnt, ...
Lernziel: Grobes Verständnis von "Was ist wo?"
- fortgeschrittenes Dateihandling: file, dd, tar, zip, gzip, …
- root sein, z.B. evtl.: sudo (mit sudoers, visudo etc.), su, Ethos, Vorsicht, /etc/passwd, Gruppen/Gruppenrechte, …
- Netz, z.B. evtl.: ping, rsync, curl, wget, …
BA Sven Wegner: Aufgaben des Programmierpraktikums zur Python-Standardbibliothek
- Kleine, praktische Einführungen in jeweils eines oder wenige der wichtigsten Module der Standardbibliothek.
- Ggf. zusätzliche fortgeschrittene Aufgaben zu wichtigen Modulen oder solchen mit anspruchsvollen Konzepten.
BA Hanen Alrwasheda: Aufgaben des Programmierpraktikums zu Python-Sprachkonstrukten
- Aufgabengruppe Python0 (Python-Grundlagen, die eigentlich bekannt sein sollten)
- Aufgabengruppe Python (fortgeschrittene Sprachkonstrukte und ihre Verwendung, immer mit praktischer Anwendung).
MA Daniel Müllers: Didaktik insgesamt, Aufgaben des Programmierpraktikums zu Web-Programmierung
- HTML und CSS
- gemeinsam mit anderen:
- Javascript, DOM
- HTTP, Cookies und Applicationserver
- Frontend-Programmierung
- Zusammenarbeit mit Backends
- Didaktische Grundlagen: Die ergänzte, korrigierte, ausformulierte, wissenschaftlich unterfütterte Fassung der obigen Teile "Prinzipien" und "Didaktisches Konzept".
BA Kilian Hofmann: Aufgaben des Programmierpraktikums zu C/C++
- Entwicklungsumgebung: IDE, Compiler
- Manuelle Speicherverwaltung
- Zeiger
- Präprozessor
- Linker
- Standardbibliothek
- …
Genau wie bei Go (siehe unten) dürfen und sollen sich diese Aufgaben kreuz und quer über diverse Kapitel und Aufgabengruppen erstrecken und zugleich mittels assumes-Abhängigkeiten zu einem Netz verbunden sein.
BA Ihar Brandes: Aufgaben des Programmierpraktikums zu Go (Golang)
Themen z.B.
- Entwicklungsumgebung: IDE, Compiler
- Go für Python-Programmierer: Datentypen, Funktionen, if, Schleifen, …
- Zeiger
- embedding, interfaces
- Networking
- Multiprocessing
- Standardbibliothek
- go test, godoc, go build, go get
- Effective Go idioms
- …
Diese dürfen und sollen sich kreuz und quer über diverse Kapitel und Aufgabengruppen erstrecken und zugleich mittels assumes-Abhängigkeiten zu einem Netz verbunden sein:
Sprachen/Go0 (Grundkenntnisse), Sprachen/Go (Fortgeschrittene Konstrukte), Bibliotheken, Werkzeuge, …
BA Adrian Winau: Ein Programmierprojekt im Rahmen des Programmierpraktikums
…
BA Jamin Saka: Aufgaben des Programmierpraktikums zu Datenhandling und -visualisierung (Pandas, Matplotlib)
- Datenstrukturen und Umgang mit Daten in Pandas
- Konzepte wie Datenhandling, Datenbereinigung
- Umgang mit matplotlib
- explorative Datenanalyse, Arten der Visualisierung (Boxplot, Histogramm, etc.)
Weitere mögliche Themenkreise
Es kommen beispielsweise in Frage:
- Wichtige sehr große (Python)Bibliotheken, siehe z.B. diese Liste.
Ferner die Methoden, wie man eine Bibliothek auswählt, wenn es mehrere gibt. Siehe zu beidem die Notizen in aufgabenideen.md.
- Weitere wichtige Programmiersprachen (und ggf. deren Standardbibliotheken), insbesondere Java, Scala, SQL.
- Mehr aus dem Bereich Webprogrammierung.
- Informationssicherheit (Security): Typische Muster von Mängeln (CWE, OWASP Top 10), Werkzeuge zur Suche von Mängeln, Muster und Werkzeuge für's Richtigmachen.
Bei Interesse an einem solchen Sektor bitte etwas einlesen, erste Aufgabenideen entwickeln und dann gern zu
Lutz Prechelt in die
Sprechstunde kommen.
Rückfragen gern an
Lutz Prechelt.
Letzte Version dieser Seite mit den dann gelöschten vielen Einzelheiten war
Revision 10
eine weitere große Überarbeitung erfolgte nach
Revision 23 in r24 und r25.