2018-06-03 15:08:19 +02:00
#+title : Projekthandbuch
2018-09-16 18:45:03 +02:00
:preamble:
2018-06-03 15:08:19 +02:00
#+author : Andreas Zweili
#+latex_class : article
#+latex_class_options : [a4paper,11pt]
2018-06-03 17:25:15 +02:00
#+latex_header : \input{general/style}
2018-12-11 22:31:40 +01:00
#+latex_header : \loadglsentries[main]{general/glossary}
2018-06-03 15:08:19 +02:00
#+otions : H:5 todo:t
#+language : de
#+startup : align
2018-12-08 08:28:12 +01:00
#+exclude_tags : no_export
2018-09-16 18:45:03 +02:00
:end:
2018-06-03 15:08:19 +02:00
2018-12-11 22:31:40 +01:00
* Über dieses Dokument
2018-12-08 08:28:12 +01:00
2018-12-11 22:31:40 +01:00
Im nachfolgenden Abschnitt finden Sie allgemeine Informationen zu
diesem Dokument.
2018-12-10 21:16:57 +01:00
2018-12-11 22:31:40 +01:00
** Beschreibung
2018-12-10 21:16:57 +01:00
2019-01-12 13:41:37 +01:00
Diese Arbeit hat zum Ziel, die Planung und Erstellung einer grafischen
Oberfläche zum einfachen Bedienen der Software gls:borg footcite:borgbackup ,
durchzuführen sowie zu dokumentieren.
2018-12-10 21:16:57 +01:00
2018-12-11 22:31:40 +01:00
** Zweck und Inhalt
2018-12-10 21:16:57 +01:00
2018-12-11 22:31:40 +01:00
Zweck dieses Dokumentes ist die vollständige und nachvollziehbare Dokumentation
zur Diplomarbeit von Andreas Zweili.
2018-12-10 21:16:57 +01:00
2018-12-11 22:31:40 +01:00
** Aufbau
Alle Inhalte sind chronologisch sortiert, vom ältesten zum jüngsten
Ereignis, und nach Kapiteln getrennt.
2018-12-10 21:16:57 +01:00
2018-12-11 22:28:27 +01:00
** Lizenz
Dieses Dokument wurde von Andreas Zweili im Rahmen der Diplomarbeit an der IBZ
Schule erstellt und steht unter der gls:cc BY-SA 4.0 footcite:cc Lizenz.
2019-01-10 21:40:35 +01:00
Dadurch darf die Arbeit unter Beibehalten der Lizenz kopiert und
2019-01-10 21:10:37 +01:00
weiterverarbeitet werden. Zusätzlich muss der Urheber genannt werden.
2018-12-10 21:16:57 +01:00
2019-02-27 21:55:48 +01:00
* TODO Initialisierung
2018-12-12 21:14:50 +01:00
** Vision
2019-01-10 21:10:37 +01:00
Die Software soll gls:borg für den durchschnittlichen Computer User zugänglich
2019-01-10 21:40:35 +01:00
machen. Backups sollen dabei schnell und unkompliziert erstellt werden können.
Auch die Möglichkeit automatischer im Hintergrund laufender Backups soll dem
2019-01-12 13:41:37 +01:00
User gegeben sein, damit die Hürde für Backups so tief wie möglich gehalten
2019-01-10 21:40:35 +01:00
wird.
2018-12-12 21:14:50 +01:00
Die besten Backups sind solche bei denen man gar nicht mehr weiss das man sie
hat bis man sie braucht.
** Ausgangslage
2019-01-10 21:40:35 +01:00
gls:borg ist deshalb interessant, weil es während einem Backup relativ
2018-12-12 21:14:50 +01:00
wenig Ressource im Vergleich zu anderen Systemen benötigt und schon relativ
2019-01-10 21:10:37 +01:00
lange aktiv entwickelt wird. Dadurch ist es im Alltag geprüft worden.
2019-01-10 21:40:35 +01:00
Des Weiteren bietet gls:borg die Funktion für Verschlüsselung was es einem User
2018-12-12 21:14:50 +01:00
ermöglicht die Daten auf einem unsicheren Cloud Speicher abzulegen.
2019-01-10 21:40:35 +01:00
Des Weiteren speichert gls:borg die Daten mit Block basierter gls:dedup ab. Dies
2018-12-12 21:14:50 +01:00
hat den riesigen Vorteil das bei einem Backup nur die Änderungen auf
Block-Ebene gespeichert werden und nicht jedes Mal die ganze Datei kopiert
werden muss.
Damit ermöglicht die Software auch Backups von sehr grossen Dateien, wie Videos
2019-01-10 21:40:35 +01:00
oder Disk Images von virtuellen Maschinen, in mehreren Versionen. Ohne dabei
2018-12-12 21:14:50 +01:00
jedoch signifikant mehr an Speicher zu benötigen. Zusätzlich werden die Backups
2018-12-19 21:36:46 +01:00
dadurch rasend schnell ausgeführt. Gerade dieses Feature macht gls:borg in den
2019-01-10 21:10:37 +01:00
Augen des Autors besonders interessant da sich der durchschnittliche User
2019-01-10 21:40:35 +01:00
möglichst wenig mit Dingen wie Backups auseinandersetzen möchte. Umso besser
also, wenn sie schnell gehen und so wenig Speicherplatz wie möglich verbrauchen.
2018-12-12 21:14:50 +01:00
2018-12-25 11:50:21 +01:00
gls:borg wird jedoch komplett über die Kommandozeile bedient. Somit ist es für
normale Benutzer eher schwierig den Zugang zu der Software zu finden geschweige
denn sie zu bedienen.
2018-12-19 21:36:46 +01:00
gls:borg bietet Entwicklern eine gls:json, gls:api, mit welcher sie, von gls:borg
2019-01-10 21:10:37 +01:00
ausgegebenen Dateien einfach weiterverarbeiten können.
2018-12-12 21:14:50 +01:00
2018-12-19 21:36:46 +01:00
gls:borg steht unter einer gls:bsd footcite:bsd Lizenz zur Verfügung und ist somit
2018-12-12 21:14:50 +01:00
gls:libre.
Das Projekt muss dabei vom Studenten in Eigenarbeit und einer Zeit von 250
Stunden bis zum 18. März 2019 erarbeitet werden.
** Projektziele
Das Hauptziel der Arbeit soll es sein eine einfach nutzbare grafische
2018-12-19 21:36:46 +01:00
Oberfläche für gls:borg zu entwickeln. Da gls:borg selber freie Software ist und
2019-01-10 21:40:35 +01:00
der Autor mit gls:libre viel gute Erfahrungen gemacht hat, soll das Projekt
2018-12-12 21:14:50 +01:00
selber auch wieder gls:libre sein. Zum einen um der Community etwas
2019-01-10 21:40:35 +01:00
zurückzugeben des weiteren, um anderen Entwicklern die Möglichkeit zu geben die
2019-01-10 21:10:37 +01:00
Software zu verbessern und weiter zu entwickeln.
2018-12-12 21:14:50 +01:00
2019-01-10 21:10:37 +01:00
Als neben läufiges Ziel soll mit dieser Arbeit auch die Verbreitung von freier
2018-12-12 21:14:50 +01:00
Software gefördert werden. Dies wird insbesondere dadurch erreicht, dass die
Software selbst unter der gls:gpl Version 3 footcite:gplv3
veröffentlicht wird. Wenn möglich sollen während der Entwicklung auch
hauptsächlich freie Software verwendet werden. Die gesamte Arbeit wird zudem zu
jedem Zeitpunkt öffentlich einsehbar sein. Der Quelltext der Dokumentation ist
unter diesem Link erreichbar: https://git.2li.ch/Nebucatnetzer/thesis
Die Entwicklung wird hauptsächlich auf einem Linux System stattfinden. Da
BorgBackup einerseits hauptsächlich auf Unix Systeme ausgelegt ist und
anderseits die Hauptzielgruppe des Projektes auch auf Linux Usern liegt.
2019-01-10 21:10:37 +01:00
Trotzdem sollen im Projekt cross-plattform fähige Technologien eingesetzt werden
2018-12-12 21:14:50 +01:00
damit es in der Zukunft möglich ist das Projekt auf andere Plattformen
auszuweiten.
*** Ziele inklusive Gewichtung
2019-01-10 21:10:37 +01:00
Im Projektantrag wurden vor gängig folgende Ziele definiert und entsprechend
2018-12-12 21:14:50 +01:00
gewichtet. Die Gewichtung wurde dabei so vorgenommen, dass Ziele mit einer
2019-01-10 21:40:35 +01:00
Muss-Gewichtung den Minimalanforderungen der Software entsprechen. Die weiteren
Ziele wurden dann mit Ziffern von 5 bis 1 gewichtet. Eine 5 bedeutet dabei
dass, das Ziel in naher Zukunft sehr nützlich/wichtig für die Software wäre
ist. Eine tiefe Zahl sollte dabei, wenn möglich, auch einmal in die Software
2018-12-12 21:14:50 +01:00
integriert werden und ist nicht unwichtig.
#+CAPTION : Projektziele
#+ATTR_LATEX : :environment longtable :align |p{1cm}|p{9cm}|p{1.5cm}|p{2cm}|
#+NAME : tab:projektziele
2019-01-10 20:28:10 +01:00
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| *Ziel-Nr.*\cellcolor[HTML]{C0C0C0} | *Zielsetzung*\cellcolor[HTML]{C0C0C0} | *Muss*\cellcolor[HTML]{C0C0C0} | *Wunsch*\newline (1-5, 5=sehr wichtig)\cellcolor[HTML]{C0C0C0} |
2019-02-27 21:55:48 +01:00
| <5> | <40> | <10> | <10> |
2019-01-10 20:28:10 +01:00
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
2019-01-11 20:05:58 +01:00
| 1. | Die Anwendung setzt auf cross-plattform (Linux, Windows, OS X) fähige Technologien. | x | |
2019-01-10 20:28:10 +01:00
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 2. | Die Anwendung steht unter der gls:gpl v3 der Öffentlichkeit zur Verfügung. | x | |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 3. | Der User kann mit weniger als 3 Klicks ein Backup ausführen. | x | |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 4. | Der User kann ein Archiv mit 3 Klicks löschen. | x | |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 5. | Der User kann unter Linux ein Archiv mit zwei Klicks "read-only" als Laufwerk mounten. | x | |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 6. | Der User kann ein Archiv wieder herstellen. | x | |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 7. | Der User kann den zu sichernden Pfad manuell in der Anwendung definieren. | x | |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 8. | Die Applikation holt ihre Konfiguration aus einer Plain-Text Datei. | x | |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 9. | Der User kann sein Repository auf einer Harddisk ablegen. | x | |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 10. | Die Anwendung exkludiert für einen Linux Computer sinnvolle Pfade bereits zu Beginn. | x | |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 11. | Die Archivliste wird nach einer Aktion automatisch aktualisiert. | x | |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 12. | Der User kann sein Repository auf einem über SSH erreichbaren Server ablegen. | | 5 |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
2019-01-11 20:05:58 +01:00
| 13. | Der User kann den Namen eines Archivs selbst bestimmen. | | 5 |
2019-01-10 20:28:10 +01:00
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 14. | Die Anwendung meldet transparent, wenn das Repository nicht erreichbar ist. | | 5 |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 15. | Die Anwendung meldet dem User, wenn noch ein Hypervisor am Laufen ist. | | 5 |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 16. | Die Anwendung leitet Meldungen von gls:borg transparent weiter. | | 5 |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 17. | Die Anwendung zeigt transparent an das gls:borg im Hintergrund bereits läuft. | | 5 |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 18. | Das Repository wird nach jedem Backup bereinigt. | | 4 |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 19. | Der User kann automatische Hintergrundbackups in der Anwendung konfigurieren. | | 4 |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 20. | Die Anwendung gibt dem User die Möglichkeit ein passendes Repository zu erstellen, wenn keines gefunden wird, die Anwendung jedoch bereits konfiguriert ist. | | 4 |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 21. | Die Applikation verwendet, wann immer möglich allgemeingültige Umgebungsvariablen. | | 4 |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 22. | Die Anwendung cached/speichert (evtl. zusätzliche) Informationen in einer Datenbank. | | 3 |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 23. | Die Anwendung zeigt beim ersten Starten einen Setup Wizard. | | 3 |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
2019-01-11 20:05:58 +01:00
| 24. | Der User kann sich mit 3 Klicks das Log eines Archivs anschauen. Nur möglich mit einer zusätzlichen DB. | | 3 |
2019-01-10 20:28:10 +01:00
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 25. | Die Anwendung kann Systembenachrichtigungen auslösen. | | 3 |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 26. | Der User kann die Anwendung grafisch konfigurieren. | | 3 |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 27. | Der User kann entscheiden ob, ein gemountetes Archiv nach dem Schliessen der Applikation noch weiter verfügbar ist. | | 2 |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 28. | Der User kann das Repository wechseln. | | 2 |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 29. | Der User kann ein Archiv nach einer Datei oder einem Ordner durchsuchen. | | 2 |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 30. | Der User kann die "Retention Policy" konfigurieren. | | 2 |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
2019-01-10 21:10:37 +01:00
| 31. | Die Anwendung kann mit allen Features von BorgBackup umgehen. | | 2 |
2019-01-10 20:28:10 +01:00
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
| 32. | Die Applikation prüft, ob sie sich im richtigen Netzwerk befindet bevor sie eine Verbindung zum Server aufbaut. | | 2 |
|------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------|
2018-12-12 21:14:50 +01:00
#+LATEX :\newpage
** Projektabgrenzung
2018-12-19 21:36:46 +01:00
Die Anwendung beschränkt sich darauf Funktionen von gls:borg grafisch
2018-12-12 21:14:50 +01:00
darzustellen oder nützlich zu erweitern soweit dies über die gls:api möglich
2019-01-10 21:40:35 +01:00
ist. Wie in Abbildung:([[fig:kontext ]]) zu sehen ist, werden die Aktionen effektiv
2018-12-25 11:45:35 +01:00
immer vom Borg Binary ausgeführt und nicht von der grafischen Oberfläche. Eine
Erweiterung von gls:borg ist nicht vorgesehen. Backup und Verschlüsselung sind
2019-01-10 21:10:37 +01:00
heikle Themen und sollten unbedingt nur von Experten angegangen werden. Das
2019-01-10 21:40:35 +01:00
Potenzial für Fehler und die Auswirkungen derer, sind einfach schlicht zu gross.
2018-12-12 21:14:50 +01:00
2019-01-10 21:40:35 +01:00
Des Weiteren wird die Grundlage für eine kollaborative Entwicklung geschaffen.
2019-01-10 21:10:37 +01:00
Während der Laufzeit der Diplomarbeit werden jedoch keine Inputs aus der Borg
2018-12-22 15:27:25 +01:00
Community im Bezug auf die Entwicklung entgegengenommen.
2018-12-19 21:36:46 +01:00
Bugs von gls:borg welche während der Dauer der Diplomarbeit vom Studenten
2018-12-12 21:14:50 +01:00
entdeckt werden, wird dieser dem Projekt melden jedoch nicht selber beheben.
2018-12-10 21:16:57 +01:00
2018-12-25 11:45:35 +01:00
#+caption : Kontextdiagramm des Borg GUI
#+name : fig:kontext
[[file:pictures/kontextdiagramm.pdf ]]
#+attr_latex : :center
2018-12-22 16:52:09 +01:00
** Projektmethode
2019-01-10 21:10:37 +01:00
Für das Projekt wurde die Wasserfall-Methode gewählt. Da nur eine
2019-01-10 21:40:35 +01:00
einzige Person am Projekt arbeitet, kann nur ein Task nach dem anderen
abgearbeitet werden und viele Aufgaben stehen in Abhängigkeiten zueinander.
2019-01-10 21:10:37 +01:00
Somit macht das iterative Vorgehen der Wasserfall-Methode für dieses Projekt am
2018-12-22 16:52:09 +01:00
meisten Sinn.
2018-12-22 16:52:24 +01:00
** Konfigurationsmanagement
2018-12-28 11:03:42 +01:00
In der nachfolgenden Sektion wird definiert wie die Software und Dokumentation
versioniert wird und welche allgemeinen Werkzeuge eingesetzt werden.
*** Versionskontrolle
2019-01-10 21:10:37 +01:00
Die komplette Dokumentation, der Quellcode der Applikation sowie jegliche
zusätzliche Dokumente wie etwa die Zeitplanung werden mittels der Software Git
versioniert. Thematisch zusammengehörende Änderungen werden in einem Commit
2018-12-22 16:55:02 +01:00
zusammengefasst. Somit ist jederzeit nachvollziehbar was wann geändert hat. Ein
Commit sollte dabei gemäss dem Artikel von Chris Beams "How to write a Git
Commit Message" footcite:commit und in englischer Sprache geschrieben sein.
2018-12-22 16:52:24 +01:00
Versionsnummern sind für die Applikation zum jetzigen Zeitpunkt noch nicht
2018-12-25 13:47:28 +01:00
vorgesehen. Sollten sie zukünftig einmal verwendet werden soll eine semantische
2018-12-22 16:55:02 +01:00
Versionierung footcite:semver verwendet. Dabei ist eine Versionsnummer immer
nach diesem Schema aufgebaut, MAJOR.MINOR.PATCH. Bei Änderungen wir die:
2019-01-10 21:40:35 +01:00
1. MAJOR Version erhöht, wenn man inkompatible Änderungen an der gls:api macht.
2. MINOR Version erhöht, wenn man Funktionalität hinzufügt, die
2019-01-10 21:10:37 +01:00
abwärtskompatibel ist.
2019-01-10 21:40:35 +01:00
3. PATCH Version erhöht, wenn man abwärtskompatibel Bug-Fixes hinzufügt.
2018-12-22 16:52:24 +01:00
2019-01-10 21:40:35 +01:00
Auf jeden Fall sollte, wenn möglich immer nur lauffähiger Code im Master Branch
2018-12-22 16:52:24 +01:00
eingecheckt sein damit der Master Branch immer eine funktionierende Software
repräsentiert. Dies gilt auch für das Repository der Dokumentation. Der Master
Branch der Dokumentation sollte maximal mit zwei Befehlen ~make clean~ und
2019-01-10 21:40:35 +01:00
~make~ "kompilierbar" sein.
2018-12-18 21:15:39 +01:00
2018-12-28 11:03:42 +01:00
Als Software für die Versionskontrolle wurde Git footcite:git aus folgenden
Gründen ausgewählt:
- Ist der de facto Standard bei Versionskontrollsoftware
- Läuft auf allen gängigen Betriebssystemen
2019-01-10 21:40:35 +01:00
- Es gäbe gratis Services, die man nutzen könnte (Github, Gitlab)
2018-12-28 11:03:42 +01:00
- Man kann offline arbeiten und Commits erstellen
2019-01-10 21:40:35 +01:00
- Der Autor hat bereits einen eigenen Git Server zur Verfügung
- Der Autor ist bereits mit Git aus vorhergehenden Projekten vertraut,
2018-12-28 11:03:42 +01:00
dadurch muss man keine Ressourcen aufwenden eine neue Software zu lernen.
Zusätzlich hat sich Git in den vorhergehenden Projekten als robuste
und schnelle Software erwiesen.
- Git ist gls:libre unter der gls:gpl v2.
*** Editor
Sowohl bei der Dokumentation wie auch bei der Programmierung wurde
hauptsächlich der Editor GNU Emacs footcite:emacs verwendet. GNU Emacs ist mit
32 Jahren (obwohl seine Wurzeln bis ins Jahre 1976 zurückgehen) wohl eines der
ältesten noch aktiven Software Projekte. Emacs ist gls:libre unter der
gls:gpl v3. Emacs wurde gewählt da es ein schneller, schlanker und sehr
2019-01-10 21:10:37 +01:00
flexibler Texteditor ist. Von normaler Textmanipulation über Taskmanagement
2018-12-28 11:03:42 +01:00
und Emails schreiben ist alles möglich.
*** Dokumentation
Diese Dokumentation wurde in Org-mode footcite:orgmode, einer Erweiterung für
den Text Editor Emacs, geschrieben. Die Syntax erinnert an Markdown und
2019-01-10 21:40:35 +01:00
Org-mode bietet einem eine Vielzahl an Hilfen dafür inklusive dem Erstellen von
2019-01-10 21:10:37 +01:00
Tabellen und Spreadsheet Funktionen. Für finale Version des Dokuments kann
2018-12-28 11:03:42 +01:00
Org-mode die ursprünglich Textdatei über LaTeX in ein PDF exportieren.
LaTeX footcite:latex ist eine Software, welche einem die Benutzung des
Textsatzsystems TeXs vereinfacht. LaTeX wurde gegenüber einem "What You See Is
2019-01-10 21:40:35 +01:00
What You Get" (z.Bsp. MS. Word) Editor gewählt, weil es einem mit seiner Markup
2018-12-28 11:03:42 +01:00
Sprache erlaubt das Dokument in Text Dateien zu erstellen, gerade für
Programmiere ist dies eine sehr interessante Lösung. Dadurch, dass LaTeX auch
nur aus reinen Textdateien besteht, kann man die Dokumente auch ohne weiteres
in die Versionskontrollsoftware einchecken und die Entwicklung im Log
zurückverfolgen. LaTeX ist gls:libre unter der LaTeX Project Public
License.
Die Grafiken in diesem Dokument wurden hauptsächlich mit dem Vektor Grafik
Editor Inkscape footcite:inkscape erstellt. Inkscape ist gls:libre unter der
GNU Public License v3.
Die Diagramme wurden mit Draw.io footcite:draw erstellt. Draw.io ist gls:libre
unter Apache Lizenz Version 2.0 footcite:apache und kann sowohl als Desktop
Applikation wie auch als Webanwendung genutzt werden.
2019-01-10 21:40:35 +01:00
Beim Design der Arbeit wurden soweit als möglich die typografischen Regeln aus
2018-12-28 11:03:42 +01:00
dem Buch "Practical Typography" von Matthew Butterick footcite:typo angewandt.
2019-01-10 21:10:37 +01:00
Bei den Diagrammen wurden ausschliesslich Farben aus der von Google
2019-01-10 21:40:35 +01:00
entwickelten Design Sprache "Material" footcite:material eingesetzt.
2018-12-28 11:03:42 +01:00
2018-12-25 12:19:16 +01:00
** Zeitplanung
Die detaillierte Zeitplanung ist dem Ganttchart in der Datei
[[file:Zeitplanung_Andreas_Zweili.html ][Zeitplanung_Andreas_Zweili.html ]] zu entnehmen. Bei der Zeitplanung wurde darauf
2019-01-10 21:40:35 +01:00
geachtet das die Arbeit soweit, als möglich nicht mit dem Berufsleben
kollidiert An einem normalen Arbeitstag wurde dabei damit gerechnet das ca. 2
Stunden Arbeit am Abend möglich sein sollten. An einem arbeitsfreien Tag wurde
mit 6 Stunden Arbeit gerechnet. Über die Festtage wurden diverse Tage von der
Planung ausgenommen, da es nicht realistisch schien das an diesen Tagen die
Arbeit signifikant vorwärtsgehen würde. Auch Schultage wurde nicht, als
Arbeitstage gerechnet da man meist nicht mehr für weitere Tätigkeiten gross
motiviert ist.
2018-12-25 12:19:16 +01:00
2019-01-10 21:10:37 +01:00
Als zusätzliche Massnahme um die Arbeitslast zu verteilen wurde vom 14. Januar
2018-12-25 12:19:16 +01:00
bis zum 11. März jeder Montag auf der Arbeitsstelle als frei eingegeben.
2019-01-10 21:10:37 +01:00
Dadurch steht wägend des Projektes etwas mehr Zeit zur Verfügung als sonst mit
2019-01-10 21:40:35 +01:00
einer 100 Prozent Arbeitsstelle möglich wäre.
2018-12-24 15:53:54 +01:00
2019-02-27 21:55:48 +01:00
** TODO Controlling
2018-12-25 13:47:43 +01:00
2019-01-10 21:40:35 +01:00
Das Controlling wird verwendet, um zu kontrollieren, dass die eigentliche
Planung mit dem effektiv geleisteten Aufwand respektive den effektiv
verwendeten Ressourcen übereinstimmt. Somit können für zukünftige Projekte
Lehren gezogen werden.
2018-12-25 13:47:43 +01:00
#+LATEX :\newpage
#+LATEX :\begin{landscape}
2019-02-27 21:55:48 +01:00
*** TODO Zeit
2018-12-25 13:47:43 +01:00
#+CAPTION : Zeitcontrolling
#+ATTR_LATEX : :environment longtable :align |p{3cm}|p{5cm}|p{3cm}|p{7cm}|
#+NAME : tab:zeitcontr
|-----------------------------------+------------------------------------------+-------------------------------------------+--------------------------------------|
| *Aufgabe*\cellcolor[HTML]{C0C0C0} | *Gesch. Aufwand*\cellcolor[HTML]{C0C0C0} | *Effekt. Aufwand*\cellcolor[HTML]{C0C0C0} | *Begründung*\cellcolor[HTML]{C0C0C0} |
|-----------------------------------+------------------------------------------+-------------------------------------------+--------------------------------------|
|-----------------------------------+------------------------------------------+-------------------------------------------+--------------------------------------|
| | *Gesamter Aufwand* | | |
|-----------------------------------+------------------------------------------+-------------------------------------------+--------------------------------------|
#+LATEX :\newpage
*** Ressourcen
2019-01-10 21:10:37 +01:00
Folgende Ressourcen werden während der Arbeit benötigt:
2018-12-25 13:47:43 +01:00
#+CAPTION : Ressourcen
#+ATTR_LATEX : :environment longtable :align |p{5cm}|p{3cm}|p{3cm}|p{7cm}|
#+NAME : tab:zeitcontr
|-------------------------------------+--------------------------------------------+-----------------------------------------+--------------------------------------|
| *Ressource*\cellcolor[HTML]{C0C0C0} | *geschätzte Stück*\cellcolor[HTML]{C0C0C0} | *effekt. Stück*\cellcolor[HTML]{C0C0C0} | *Begründung*\cellcolor[HTML]{C0C0C0} |
|-------------------------------------+--------------------------------------------+-----------------------------------------+--------------------------------------|
2019-02-27 21:55:48 +01:00
| Projektleiter/Mitarbeiter | 1 | 1 | - |
| Diplombetreuer | 1 | 1 | - |
| Testuser | 5 | 5 | - |
| Korrekturleser | 3 | 3 | - |
| iPad | 1 | 1 | - |
| Notebook | 1 | 1 | - |
2018-12-25 13:47:43 +01:00
|-------------------------------------+--------------------------------------------+-----------------------------------------+--------------------------------------|
#+LATEX :\end{landscape}
2019-02-27 21:55:48 +01:00
*** TODO Kosten
2018-12-25 13:47:43 +01:00
Werden die internen Lohnkosten des Projektleiters auf ca. 60 CHF pro Stunde
geschätzt ergeben sich aus der Zeitplanung somit theoretische Kosten von 19'200
CHF für die Umsetzung dieser Arbeit. Da dieses Projekt finanziell jedoch in
keinster Weise wirtschaftliche relevant ist, sind die Kosten nur ein rein
theoretischer Faktor.
#+CAPTION : Kostenrechnung
#+NAME : tab:kosten
|--------------------------------+----------------------------------------+-----------------------------------------|
| *Name*\cellcolor[HTML]{C0C0C0} | *Aufwand in h*\cellcolor[HTML]{C0C0C0} | *Kosten in CHF*\cellcolor[HTML]{C0C0C0} |
|--------------------------------+----------------------------------------+-----------------------------------------|
| Initialisierung | 24 | 1440 |
| Analyse | 47 | 2820 |
| Konzept | 34 | 2040 |
| Realisierung | 172 | 10320 |
| Ausblick | 8 | 480 |
| Arbeit korrigieren | 20 | 1200 |
| Meeting #1 | 5 | 300 |
| Meeting #2 | 5 | 300 |
| Meeting #3 | 5 | 300 |
|--------------------------------+----------------------------------------+-----------------------------------------|
| *Total* | 320 | 19200 |
|--------------------------------+----------------------------------------+-----------------------------------------|
#+TBLFM : @2$3=@2$2 * 60::@3$3=@3$2 * 60::@4$3=@4$2 *60::@5$3=@5$2 *60::@6$3=@6$2 *60::@7$3=@7$2 *60::@8$3=@8$2 *60::@9$3=@9$2 *60::@10$3=@10$2 *60
#+TBLFM : @>$2=vsum(@2..@-1)
#+TBLFM : @>$3=vsum(@2..@-1)
2018-12-25 16:53:25 +01:00
** Projektrisiken
2018-12-24 15:53:54 +01:00
2018-12-25 16:53:25 +01:00
Das Risikomanagement dient dazu Risiken im Projekt zu erkennen und Massnahmen
zur Vermeidung der Risiken zu definieren. Dadurch steht man ihnen nicht
2019-01-10 21:40:35 +01:00
unvorbereitet gegenüber, sollten sie eintreffen.
2018-12-25 16:53:25 +01:00
*** Risikobeschreibung
In der Tabelle: ([[tab:risikobeschreibung ]]), sind die Risiken des Projektes
gemeinsam mit ihren Gegenmassnahmen aufgelistet. Jedes Risiko wurde
entsprechend der Tabelle: ([[tab:wahrscheinlichkeit ]]) nach der Wahrscheinlichkeit
des Eintreffens bewertet und entsprechend der Tabelle: ([[tab:auswirkung ]]) nach
seiner Auswirkung bewertet.
#+CAPTION : Projektrisiken
2018-12-25 17:06:31 +01:00
#+ATTR_LATEX : :environment longtable :align |p{0.45\textwidth}|p{0.45\textwidth}| :placement [H]
2018-12-25 16:53:25 +01:00
#+NAME : tab:projektrisiken
2019-01-10 20:28:10 +01:00
|-----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------|
| <30> | <30> |
| *Beschreibung*\cellcolor[HTML]{C0C0C0} | *Massnahmen*\cellcolor[HTML]{C0C0C0} |
|-----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------|
| Ein grösseres Problem in der Programmierung blockiert den Fortschritt. | Immer nur eine Sache auf einmal in der Code-Basis ändern, alle Fehler beheben und erst dann zur nächsten Aufgabe weitergehen. |
|-----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------|
| Viel Arbeit an der Arbeitsstelle, dabei bleibt weniger Zeit für die Diplomarbeit. | Auf der Arbeit Freitage eingeben um die Last etwas zu verteilen. Projektplanung machen. |
|-----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------|
| Know-How zur Umsetzung ist nicht vollständig vorhanden. | Gute Informationsbeschaffung im Internet, Büchern, etc. |
|-----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------|
| Manuelle Tests brauchen zu viel Zeit. | Soviel wie möglich automatisieren. Dabei jedoch nicht den Fokus auf die eigentliche Entwicklung verlieren. |
|-----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------|
| Die Programmierung des Programms benötigt zu viel Zeit. | Bei der Projektplanung genau definieren was die GUI Applikation beinhalten muss. Ziele definieren, Abgrenzungen treffen. |
|-----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------|
2019-01-11 20:05:58 +01:00
| User haben keine Zeit für Utility Tests. | Vor gängig einen Termin abmachen. |
2019-01-10 20:28:10 +01:00
|-----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------|
| gls:borg ändert fundamental seine gls:api. | Gegen eine fixe Version von gls:borg entwickeln. |
|-----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------|
2018-12-25 16:53:25 +01:00
* Analyse
2018-12-22 16:24:17 +01:00
** Umweltanalyse
Die Projektumwelt-Analyse ist eine Methode, die Beziehungen,
Erwartungshaltungen und Einflüsse auf das Projekt durch interne und
2019-01-10 21:10:37 +01:00
externe soziale Umwelt zu betrachten und zu bewerten. Auf Grundlage
2018-12-22 16:24:17 +01:00
der Analyseergebnisse werden erforderliche Massnahmen zur Gestaltung
der Umweltbeziehungen abgeleitet. Die Gestaltung der
Projektumweltbeziehungen ist eine Projektmanagementaufgabe. In der
Tabelle:([[tab:umweltanalyse ]]) wurden die Anforderungen und Wünsche
mit Einschätzung der Wahrscheinlichkeit und der Einflussnahme aufgenommen.
Zusätzlich ist die Beziehung der Stakeholder zum Projekt noch in der
Abbildung:([[fig:umweltgrafik ]]) grafisch dargestellt.
Da das Projekt so ausgelegt ist das der Projektleiter es in Eigenarbeit
2019-01-10 21:10:37 +01:00
verwirklichen kann ist der Einfluss der Stakeholder während der Umsetzung sehr
2018-12-22 16:24:17 +01:00
gering. Die User werden bei der Entwicklung mittels einer "Usability" Studie
miteinbezogen und die gls:borg Community wird mit regelmässigen Posts auf dem
offiziellen Github Repository auf dem Laufenden gehalten.
Nach Ende der Diplomarbeit soll das Projekt für interessierte Entwickler jedoch
offen sein. Der Quellcode wird bereits während der Arbeit öffentlich zur
Verfügung gestellt.
2018-12-10 21:16:57 +01:00
2018-12-22 16:27:20 +01:00
#+CAPTION : Stakeholder Diagramm
#+ATTR_LATEX : :width .9\textwidth
#+NAME : fig:umweltgrafik
[[file:pictures/stakeholder_diagramm.pdf ]]
2018-12-22 16:24:17 +01:00
#+LATEX :\newpage
#+LATEX :\begin{landscape}
#+CAPTION : Umwelt-Analyse
#+ATTR_LATEX : :align |>{\columncolor[HTML]{EFEFEF}}p{0.8cm}|l|l|p{8cm}|l|
#+NAME : tab:umweltanalyse
2019-01-10 20:28:10 +01:00
|-------------------------------+---------------------------------------+------------------------------------+----------------------------------------------------------+----------------------------------------------|
| <5> | <20> | <20> | | |
2018-12-22 16:24:17 +01:00
| *Nr*.\cellcolor[HTML]{C0C0C0} | *Stakeholder*\cellcolor[HTML]{C0C0C0} | *Einfluss*\cellcolor[HTML]{C0C0C0} | *Anforderung/Wünsche*\cellcolor[HTML]{C0C0C0} | *Wahrscheinlichkeit*\cellcolor[HTML]{C0C0C0} |
2019-01-10 20:28:10 +01:00
|-------------------------------+---------------------------------------+------------------------------------+----------------------------------------------------------+----------------------------------------------|
| 1. | BorgBackup Community | gering | - Eine Applikation die den Umfang von BorgBackup abdeckt | mittel |
| | | | - Open-Source | hoch |
| | | | - Mitsprachrecht bei der Entwicklung | niedrig |
|-------------------------------+---------------------------------------+------------------------------------+----------------------------------------------------------+----------------------------------------------|
| 2. | User | gering | - Eine einfache Anwendung | hoch |
| | | | - Einmal einrichten und vergessen | mittel |
|-------------------------------+---------------------------------------+------------------------------------+----------------------------------------------------------+----------------------------------------------|
| 3. | Interessenten | gering | - Einfach verständliches Projekt Repository | hoch |
| | | | - Einfaches Setup zum testen | hoch |
|-------------------------------+---------------------------------------+------------------------------------+----------------------------------------------------------+----------------------------------------------|
| 4. | Projektleiter | hoch | - Stabile Anwendung erstellen | mittel |
| | | | - Ein nachhaltiges Projekt starten | mittel |
| | | | - Anerkennung im fachlichen Umfeld | hoch |
|-------------------------------+---------------------------------------+------------------------------------+----------------------------------------------------------+----------------------------------------------|
2018-12-22 16:24:17 +01:00
#+LATEX :\end{landscape}
2018-12-25 16:53:53 +01:00
** Risiko-Analyse
2018-12-24 15:53:54 +01:00
2019-01-10 21:40:35 +01:00
Bei der Risiko-Analyse wird von einem durchschnittlichen Benutzer ausgegangen,
der zur Zeit noch keine Backups macht und beginnen möchte gls:borg zu nutzen, um
2018-12-25 16:53:53 +01:00
auf einer externen Harddisk seine Backups zu speichern.
2018-12-24 15:53:54 +01:00
2019-01-10 21:40:35 +01:00
Es wird dabei eine Ist/Soll Analyse gemacht, um die Lösung gegenüber der
2018-12-25 16:53:53 +01:00
bestehenden Möglichkeiten zu vergleichen. Jedes Risiko wurde entsprechend der
Tabelle: ([[tab:wahrscheinlichkeit ]]) nach der Wahrscheinlichkeit des Eintreffens
bewertet und entsprechend der Tabelle: ([[tab:auswirkung ]]) nach seiner Auswirkung
im Bezug auf die Nützlichkeit der gemachten Backups.
2018-12-24 15:53:54 +01:00
2018-12-25 16:53:53 +01:00
In der Tabelle: ([[tab:risikobeschreibung ]]) sind dabei die Risiken für das
2019-01-10 21:40:35 +01:00
Szenario aufgelistet und nummeriert. In der Abbildung:([[fig:istrisiko ]]), ist die
Bewertung des Ist-Risikos grafisch dargestellt und in der
2018-12-25 16:53:53 +01:00
Abbildung:([[fig:sollrisiko ]]), ist das Soll-Risiko welches mit dieser Arbeit
angestrebt wird ebenfalls grafisch dargestellt.
2018-12-24 15:53:54 +01:00
2018-12-25 16:53:53 +01:00
Es sollte im Rahmen der Arbeit möglich sein die meisten Risiken zu verringern.
Da automatische Hintergrundbackups jedoch nur ein Kann-Ziel sind wir in dieser
Analyse nicht davon ausgegangen das man das Risiko Nr. 5 im Rahmen dieser
Arbeit reduzieren kann.
2018-12-24 15:53:54 +01:00
#+CAPTION : Risikobewertung Wahrscheinlichkeit
#+ATTR_LATEX : :align l|l :placement [H]
#+NAME : tab:wahrscheinlichkeit
| *Bewertung* | *Beschreibung: Wahrscheinlichkeit (W)* |
|-------------+----------------------------------------|
| 1 = gering | Unwahrscheinlich, <20% |
| 2 = mittel | Mässig wahrscheinlich, 20-50% |
| 3 = hoch | Hohe Wahrscheinlichkeit > 50% |
#+CAPTION : Risikobewertung Auswirkung
#+ATTR_LATEX : :align l|l :placement [H]
#+NAME : tab:auswirkung
2018-12-25 16:53:53 +01:00
| *Bewertung* | *Beschreibung: Auswirkung (A)* |
|-------------+------------------------------------------|
| 1 = gering | Geringe Auswirkungen auf Nützlichkeit |
| 2 = mittel | Mittlere Auswirkung auf die Nützlichkeit |
| 3 = hoch | Hohe Auswirkung auf die Nützlichkeit |
#+CAPTION : Risikobeschreibung
2018-12-25 17:06:31 +01:00
#+ATTR_LATEX : :align |>{\columncolor[HTML]{EFEFEF}}p{0.1\textwidth}|p{0.8\textwidth}| :placement [H]
2018-12-25 16:53:53 +01:00
#+NAME : tab:risikobeschreibung
2019-01-10 20:28:10 +01:00
|-------------------------------+---------------------------------------------------------------------------------------------------------------|
| <10> | <30> |
| *Nr.*\cellcolor[HTML]{C0C0C0} | *Beschreibung*\cellcolor[HTML]{C0C0C0} |
|-------------------------------+---------------------------------------------------------------------------------------------------------------|
| 1. | Der Benutzer hat noch nie die Kommandozeile verwendet und scheitert bereits an der Installation von gls:borg. |
|-------------------------------+---------------------------------------------------------------------------------------------------------------|
| 2. | Der Benutzer verwendet keine Verschlüsselung und verliert seine Harddisk. |
|-------------------------------+---------------------------------------------------------------------------------------------------------------|
| 3. | Der Benutzer speichert die Backups auf der internen statt der externen Harddisk. |
|-------------------------------+---------------------------------------------------------------------------------------------------------------|
| 4. | Der Benutzer löscht aus Versehen ein Backup. |
|-------------------------------+---------------------------------------------------------------------------------------------------------------|
| 5. | Der Anwender vergisst die Backups zu machen. |
|-------------------------------+---------------------------------------------------------------------------------------------------------------|
2018-12-25 16:53:53 +01:00
#+CAPTION : Grafische Darstellung der Ist-Risikoanalyse
#+ATTR_LATEX : :width 9cm :placement [H]
#+NAME : fig:istrisiko
[[file:pictures/istrisiko.pdf ]]
2018-12-24 15:53:54 +01:00
2018-12-25 16:53:53 +01:00
#+CAPTION : Grafische Darstellung der Soll-Risikoanalyse
2018-12-24 15:53:54 +01:00
#+ATTR_LATEX : :width 9cm :placement [H]
2018-12-25 16:53:53 +01:00
#+NAME : fig:sollrisiko
[[file:pictures/sollrisiko.pdf ]]
2018-12-24 15:53:54 +01:00
2018-12-25 17:06:31 +01:00
#+LATEX :\newpage
2018-12-24 15:53:54 +01:00
** SWOT-Analyse
Die SWOT-Analyse ist eine Methode, die Stärken, Schwächen, Chancen und
Gefahren zu erkennen, indem eine 4-Felder-Matrix ausgefüllt wird.
Wichtig vor dem Ausfüllen der SWOT-Analyse ist es, ein klares Ziel zu
haben. Die ausgefüllte SWOT-Analyse für dieses Projekt ist in der
Abbildung:([[fig:swot ]]) zu sehen.
#+caption : SWOT Analyse des Projektes
#+name : fig:swot
[[file:pictures/swot_analyse.pdf ]]
2018-12-25 17:06:31 +01:00
#+attr_latex : :center :width 0.9\textwidth
2018-12-24 15:53:54 +01:00
2019-01-03 12:17:45 +01:00
** Anforderungskatalog
2019-01-10 21:40:35 +01:00
Der Anforderungskatalog entspricht 1 zu 1 den Zielen, welche in der Tabelle
2019-02-27 21:55:48 +01:00
[[tab:projektziele ]] definiert wurden. Es wurde jedoch beschlossen noch die
Kann-Ziele Nr. 26 und Nr. 19 in die Detail Planung mit aufzunehmen. Die
grafische Konfiguration der Anwendung (Ziel Nr. 26) ist mit einer Einstufung
von 3 zwar relativ tief bewertet. Es vereinfacht einem durchschnittlichen
Computer Benutzer die Konfiguration der Anwendung enorm. Das automatische
erstellen Backups im Hintergrund (Ziel Nr. 19) wurde fix eingeplant da es einen
sehr grossen Einfluss auf die Risikobwertung im Kapitel [[Risiko-Analyse ][Risiko-Analyse ]] hat.
2019-01-03 12:17:45 +01:00
** Use Cases
Ein Use Case sammelt alle möglichen Szenarien, die eintreten können,
2019-01-10 21:40:35 +01:00
wenn ein Akteur versucht, mithilfe des betrachteten Systems ein
2019-01-03 12:17:45 +01:00
bestimmtes Ziel zu erreichen. Dabei beschreibt er, was beim Versuch der
Zielerreichung passieren kann. Je nach Ablauf kann auch ein Fehlschlag
ein Ergebnis eines Anwendungsfalls sein (e.g. falsches Passwort beim
Login). Dabei wird die technische Lösung nicht konkret beschrieben.
Die Detailstufe kann dabei sehr unterschiedlich sein.footcite:usecase
*** Anwendungsfalldiagramm
"Ein Anwendungsfalldiagramm ... ist eine der 14 Diagrammarten der
Unified Modelling Language (UML), einer Sprache für die Modellierung
der Strukturen und des Verhaltens von Software- und anderen Systemen.
Es stellt Anwendungsfälle und Akteure mit ihren jeweiligen
Abhängigkeiten und Beziehungen dar."\footcite{usecasediagramm}
Das Anwendungsfalldiagramm für das gls:borg gls:gui ist in der Abbildung:
([[fig:usecase ]]) zu sehen.
#+LATEX :\newpage
#+LATEX :\begin{landscape}
#+CAPTION : Anwendungsfalldiagramm
#+ATTR_LATEX : :height.9\textwidth
#+NAME : fig:usecase
[[file:pictures/use_case.pdf ]]
#+LATEX :\end{landscape}
#+LATEX :\newpage
*** Use Cases Detailbeschreibung
2019-01-10 21:40:35 +01:00
Use Cases werden in der Regel mithilfe einer sogenannten Use Case Schablone im
2019-01-03 12:17:45 +01:00
Detail beschrieben, damit klar ist, wie der Ablauf jeweils genau aussieht. Die
in diesem Projekt verwendete Schablone wurde von Alistair Cockburn definiert.
Die nachfolgend aufgeführten Use Cases, Tabellen:([[tab:uc_backup ]], [[tab:uc_delete ]],
[[tab:uc_restore ]], [[tab:uc_file ]], [[tab:uc_mount ]], [[tab:uc_config ]], [[tab:uc_automatic ]])
wurden dem Anwendungsfalldiagramm, Abbildung:([[fig:usecase ]]), entnommen und
2019-01-10 21:40:35 +01:00
zusätzlich noch um jeweils ein Aktivitätsdiagramm, Abbildungen:
2019-01-03 12:17:45 +01:00
([[fig:activity_backup ]], [[fig:activity_delete ]], [[fig:activity_restore ]],
[[fig:activity_mount ]], [[fig:activity_settings ]], [[fig:activity_automatic ]]), erweitert
um den Ablauf verständlicher zu machen.
Ein Aktivitätsdiagramm ist dabei ein hilfreiches UML Diagramm zum Erweitern von
Use Cases und zeigt einem gut die Zuständigkeiten der Aktoren auf.
**** Use Case 1.0 Backup erstellen
#+LATEX :{\footnotesize
#+CAPTION : Use Case 1.0 Backup erstellen
#+ATTR_LATEX ::environment longtable :align |>{\columncolor[HTML]{EFEFEF}}p{.235\textwidth}|p{.7\textwidth}| :placement [H]
#+NAME : tab:uc_backup
2019-01-10 20:28:10 +01:00
|---------------------+---------------------------------------------------------------------------------------------|
| | <30> |
| *Identifier + Name* | 1.0 Backup erstellen |
|---------------------+---------------------------------------------------------------------------------------------|
| *Description* | Das erstellen einer Datensicherung durch gls:borg anstossen. |
|---------------------+---------------------------------------------------------------------------------------------|
| *Actors* | Benutzer |
|---------------------+---------------------------------------------------------------------------------------------|
| *Status* | Freigegeben |
|---------------------+---------------------------------------------------------------------------------------------|
| *Includes* | - |
|---------------------+---------------------------------------------------------------------------------------------|
| *Trigger* | User möchte ein Backup erstellen. |
|---------------------+---------------------------------------------------------------------------------------------|
| *Preconditions* | Die Applikation wurde gestartet. |
|---------------------+---------------------------------------------------------------------------------------------|
| *Postconditions* | Das erstellte Backup wird angezeigt. |
|---------------------+---------------------------------------------------------------------------------------------|
| *Normal Flow* | 1. Den Quellpfad auswählen. |
| | 2. Den Button "Backup" anklicken. |
2019-01-03 12:17:45 +01:00
| | 3. Ein Pop mit Fortschrittsbalken erscheint und zeigt die Zeit bis zum Ende des Backups an. |
2019-01-10 20:28:10 +01:00
| | 4. Am Ende des Backups verschwindet das Pop-up wieder. |
| | 5. Die Liste der Backups aktualisiert sich. |
|---------------------+---------------------------------------------------------------------------------------------|
| *Alternative Flow* | - |
|---------------------+---------------------------------------------------------------------------------------------|
| *Notes* | - |
|---------------------+---------------------------------------------------------------------------------------------|
| *UC History* | 1.0 Draft erstellt durch AZ |
|---------------------+---------------------------------------------------------------------------------------------|
| *Author* | A. Zweili |
|---------------------+---------------------------------------------------------------------------------------------|
| *Date* | 30.12.2018 |
|---------------------+---------------------------------------------------------------------------------------------|
2019-01-03 12:17:45 +01:00
#+LATEX :}
#+caption : Aktivitätsdiagramm zum Erstellen eines Backups
#+name : fig:activity_backup
[[file:pictures/activity_backup.pdf ]]
#+attr_latex : :center :placement [H]
#+LATEX :\newpage
**** Use Case 2.0 Backup löschen
#+LATEX :{\footnotesize
#+CAPTION : Use Case 2.0 Backup löschen
#+ATTR_LATEX ::environment longtable :align |>{\columncolor[HTML]{EFEFEF}}p{.235\textwidth}|p{.7\textwidth}| :placement [H]
#+NAME : tab:uc_delete
2019-01-10 20:28:10 +01:00
|---------------------+------------------------------------------------------------------|
| | <30> |
| *Identifier + Name* | 2.0 Backup löschen |
|---------------------+------------------------------------------------------------------|
| *Description* | Ein zuvor erstelltes Backup wird gelöscht. |
|---------------------+------------------------------------------------------------------|
| *Actors* | Benutzer |
|---------------------+------------------------------------------------------------------|
| *Status* | Freigegeben |
|---------------------+------------------------------------------------------------------|
| *Includes* | - |
|---------------------+------------------------------------------------------------------|
| *Trigger* | Ein User möchte ein bestehendes Backup löschen. |
|---------------------+------------------------------------------------------------------|
| *Preconditions* | Use Case 1.0 ausgeführt. |
|---------------------+------------------------------------------------------------------|
| *Postconditions* | Das gelöschte Backup wird nicht mehr aufgelistet. |
|---------------------+------------------------------------------------------------------|
| *Normal Flow* | 1. Ein Backup aus der Liste auswählen. |
| | 2. Den Button "Delete anklicken". |
| | 3. Ein Bestätigungsdialog erscheint. |
| | 4. Im Dialog den "Ok" Button anklicken. |
|---------------------+------------------------------------------------------------------|
| *Alternative Flow* | 1. Ein Backup aus der Liste auswählen. |
| | 2. Den Button "Delete anklicken". |
| | 3. Ein Bestätigungsdialog erscheint. |
2019-01-03 12:17:45 +01:00
| | 4. Die Aktion mit einem Klick auf den "Cancel" Button abbrechen. |
2019-01-10 20:28:10 +01:00
|---------------------+------------------------------------------------------------------|
| *Notes* | - |
|---------------------+------------------------------------------------------------------|
| *UC History* | 1.0 Draft erstellt durch AZ |
|---------------------+------------------------------------------------------------------|
| *Author* | A. Zweili |
|---------------------+------------------------------------------------------------------|
| *Date* | 30.12.2018 |
|---------------------+------------------------------------------------------------------|
2019-01-03 12:17:45 +01:00
#+LATEX :}
#+caption : Aktivitätsdiagramm zum Löschen eines Backups
#+name : fig:activity_delete
[[file:pictures/activity_delete.pdf ]]
#+attr_latex : :center :placement [H]
#+LATEX :\newpage
**** Use Case 3.0 Backup wiederherstellen
#+LATEX :{\footnotesize
#+CAPTION : Use Case 3.0 Backup wiederherstellen
#+ATTR_LATEX ::environment longtable :align |>{\columncolor[HTML]{EFEFEF}}p{.235\textwidth}|p{.7\textwidth}| :placement [H]
#+NAME : tab:uc_restore
2019-01-10 20:28:10 +01:00
|---------------------+--------------------------------------------------------------------------------------------------|
| | <30> |
| *Identifier + Name* | 3.0 Backup wiederherstellen |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Description* | Alle Dateien eines Backups wiederherstellen. |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Actors* | User |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Status* | Freigegeben |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Includes* | - |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Trigger* | Daten sollen wieder hergestellt werden. |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Preconditions* | Use Case 1.0 wurde ausgeführt. |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Postconditions* | Die Dateien aus dem Backup wurde im angegeben Pfad wiederhergestellt. |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Normal Flow* | 1. Ein Backup aus der Liste auswählen. |
| | 2. Den Button "Restore" klicken. |
2019-01-10 21:10:37 +01:00
| | 3. Ein Pop-up zur Auswahl eines Zielpfades erscheint. |
2019-01-10 20:28:10 +01:00
| | 4. Den Zielpfad mit klick auf "Choose" bestätigen. |
2019-01-03 12:17:45 +01:00
| | 5. Ein Dateiexplorer öffnet sich mit dem ausgewählt Pfad und enthält die Dateien aus dem Backup. |
2019-01-10 20:28:10 +01:00
|---------------------+--------------------------------------------------------------------------------------------------|
| *Alternative Flow* | 1. Ein Backup aus der Liste auswählen. |
| | 2. Den Button "Restore" klicken. |
2019-01-10 21:10:37 +01:00
| | 3. Ein Pop-up zur Auswahl eines Zielpfades erscheint. |
2019-01-10 20:28:10 +01:00
| | 4. Die Aktion mit klick auf "Cancel" abbrechen. |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Notes* | - |
|---------------------+--------------------------------------------------------------------------------------------------|
| *UC History* | 1.0 Draft erstellt durch AZ |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Author* | A. Zweili |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Date* | 30.12.2018 |
|---------------------+--------------------------------------------------------------------------------------------------|
2019-01-03 12:17:45 +01:00
#+LATEX :}
#+caption : Aktivitätsdiagramm zum Wiederherstellen eines Backups
#+name : fig:activity_restore
[[file:pictures/activity_restore.pdf ]]
#+attr_latex : :center :placement [H]
#+LATEX :\newpage
**** Use Case 4.0 Einzelne Datei wiederherstellen
#+LATEX :{\footnotesize
#+CAPTION : Use Case 4.0 Einzelne Datei wiederherstellen
#+ATTR_LATEX ::environment longtable :align |>{\columncolor[HTML]{EFEFEF}}p{.235\textwidth}|p{.7\textwidth}| :placement [H]
#+NAME : tab:uc_file
2019-01-10 20:28:10 +01:00
|---------------------+--------------------------------------------------------------------------------------------------|
| | <30> |
| *Identifier + Name* | 4.0 Einzelne Datei wiederherstellen |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Description* | Das spezifische Wiederherstellen von einer oder mehreren Dateien. |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Actors* | User |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Status* | Freigegeben |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Includes* | Use Case 4.1 |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Trigger* | Daten sollen wieder hergestellt werden. |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Preconditions* | Use Case 1.0 wurde ausgeführt. |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Postconditions* | - |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Normal Flow* | 1. Ein Backup aus der Liste auswählen. |
| | 2. Auf den Button "Mount" klicken. |
| | 3. Use Case 4.1 wird ausgeführt. |
2019-01-03 12:17:45 +01:00
| | 4. Ein Dateiexplorer öffnet sich mit dem ausgewählt Pfad und enthält die Dateien aus dem Backup. |
2019-01-10 20:28:10 +01:00
| | 5. Wird die Applikation geschlossen wird das Backup ausgehängt. |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Alternative Flow* | - |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Notes* | - |
|---------------------+--------------------------------------------------------------------------------------------------|
| *UC History* | 1.0 Draft erstellt durch AZ |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Author* | A. Zweili |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Date* | 30.12.2018 |
|---------------------+--------------------------------------------------------------------------------------------------|
2019-01-03 12:17:45 +01:00
#+LATEX :}
#+caption : Aktivitätsdiagramm für das spezifische Wiederherstellen einer Datei
#+name : fig:activity_mount
[[file:pictures/activity_mount.pdf ]]
#+attr_latex : :center :placement [H]
#+LATEX :\newpage
**** Use Case 4.1 Backup mounten
#+LATEX :{\footnotesize
#+CAPTION : Use Case 4.1 Backup mounten
#+ATTR_LATEX ::environment longtable :align |>{\columncolor[HTML]{EFEFEF}}p{.235\textwidth}|p{.7\textwidth}| :placement [H]
#+NAME : tab:uc_mount
2019-01-10 20:28:10 +01:00
|---------------------+-----------------------------------------------------------------------------|
| | <30> |
| *Identifier + Name* | 4.1 Backup mounten |
|---------------------+-----------------------------------------------------------------------------|
| *Description* | Ein Backup wird als FUSE gemountet. |
|---------------------+-----------------------------------------------------------------------------|
| *Actors* | Borg GUI, gls:borg |
|---------------------+-----------------------------------------------------------------------------|
| *Status* | Freigegeben |
|---------------------+-----------------------------------------------------------------------------|
| *Includes* | - |
|---------------------+-----------------------------------------------------------------------------|
| *Trigger* | Das Borg GUI gibt an gls:borg den Input zum mounten weiter. |
|---------------------+-----------------------------------------------------------------------------|
| *Preconditions* | Use Case 1.0 wurde ausgeführt. |
|---------------------+-----------------------------------------------------------------------------|
| *Postconditions* | Das Backup wurde gemountet. |
|---------------------+-----------------------------------------------------------------------------|
| *Normal Flow* | 1. Borg GUI sammelt die Backup ID in Use Case 4.0. |
2019-01-03 12:17:45 +01:00
| | 2. Borg GUI übergibt die Backup ID an gls:borg zusammen mit einem Zielpfad. |
2019-01-10 20:28:10 +01:00
| | 3. gls:borg hängt das Backup als FUSE Laufwerk am Zielpfad ein. |
| | 4. gls:borg meldet Erfolg an Borg GUI. |
|---------------------+-----------------------------------------------------------------------------|
| *Alternative Flow* | 1. Borg GUI sammelt die Backup ID in Use Case 4.0. |
2019-01-03 12:17:45 +01:00
| | 2. Borg GUI übergibt die Backup ID an gls:borg zusammen mit einem Zielpfad. |
2019-01-10 20:28:10 +01:00
| | 3. gls:borg hängt das Backup als FUSE Laufwerk am Zielpfad ein. |
| | 4. gls:borg meldet einen Fehler an Borg GUI. |
|---------------------+-----------------------------------------------------------------------------|
| *Notes* | - |
|---------------------+-----------------------------------------------------------------------------|
| *UC History* | 1.0 Draft erstellt durch AZ |
|---------------------+-----------------------------------------------------------------------------|
| *Author* | A. Zweili |
|---------------------+-----------------------------------------------------------------------------|
| *Date* | 30.12.2018 |
|---------------------+-----------------------------------------------------------------------------|
2019-01-03 12:17:45 +01:00
#+LATEX :}
#+LATEX :\newpage
**** Use Case 5.0 Konfiguration ändern
#+LATEX :{\footnotesize
#+CAPTION : Use Case 5.0 Konfiguration ändern
#+ATTR_LATEX ::environment longtable :align |>{\columncolor[HTML]{EFEFEF}}p{.235\textwidth}|p{.7\textwidth}| :placement [H]
#+NAME : tab:uc_config
2019-01-10 20:28:10 +01:00
|---------------------+--------------------------------------------------------------------------------------------------|
| | <30> |
| *Identifier + Name* | 5.0 Konfiguration ändern |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Description* | Das Verändern und Speichern der Konfiguration der Applikation. |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Actors* | User |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Status* | Freigegeben |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Includes* | - |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Trigger* | Ein User möchte die Einstellungen der Applikation anpassen. |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Preconditions* | Applikation gestartet. |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Postconditions* | - |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Normal Flow* | 1. Auf den Button "Settings" klicken. |
| | 2. Ein neues Fenster mit den Einstellungen öffnet sich. |
| | 3. Der Benutzer ändert mindestens eine Einstellung. |
| | 4. Der Button "OK" wird angeklickt. |
2019-01-03 12:17:45 +01:00
| | 5. Die Konfiguration wird in die Konfigurationsdatei geschrieben und in der Applikation geladen. |
2019-01-10 20:28:10 +01:00
|---------------------+--------------------------------------------------------------------------------------------------|
| *Alternative Flow* | 1. Auf den Button "Settings" klicken. |
| | 2. Ein neues Fenster mit den Einstellungen öffnet sich. |
| | 3. Der Benutzer kann Einstellungen ändern. |
| | 4. Der Button "Cancel" wird angeklickt. |
2019-01-11 20:05:58 +01:00
| | 5. Jegliche Änderungen werden verworfen und die Konfigurationsdatei bleibt im aktuellen Zustand. |
2019-01-10 20:28:10 +01:00
|---------------------+--------------------------------------------------------------------------------------------------|
| *Notes* | - |
|---------------------+--------------------------------------------------------------------------------------------------|
| *UC History* | 1.0 Draft erstellt durch AZ |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Author* | A. Zweili |
|---------------------+--------------------------------------------------------------------------------------------------|
| *Date* | 30.12.2018 |
|---------------------+--------------------------------------------------------------------------------------------------|
2019-01-03 12:17:45 +01:00
#+LATEX :}
#+caption : Aktivitätsdiagramm zum Ändern von Einstellungen
#+name : fig:activity_settings
[[file:pictures/activity_settings.pdf ]]
#+attr_latex : :center :placement [H]
#+LATEX :\newpage
**** Use Case 6.0 automatische Backups aktivieren
#+LATEX :{\footnotesize
#+CAPTION : Use Case 6.0 automatische Backups aktivieren
#+ATTR_LATEX ::environment longtable :align |>{\columncolor[HTML]{EFEFEF}}p{.235\textwidth}|p{.7\textwidth}| :placement [H]
#+NAME : tab:uc_automatic
2019-01-10 20:28:10 +01:00
|---------------------+-----------------------------------------------------------------------|
| | <30> |
| *Identifier + Name* | 6.0 automatische Backups aktivieren |
|---------------------+-----------------------------------------------------------------------|
2019-01-03 12:17:45 +01:00
| *Description* | Ein Systemdienst wird hinterlegt zum ausführen automatischer Backups. |
2019-01-10 20:28:10 +01:00
|---------------------+-----------------------------------------------------------------------|
| *Actors* | User |
|---------------------+-----------------------------------------------------------------------|
| *Status* | Freigegeben |
|---------------------+-----------------------------------------------------------------------|
| *Includes* | - |
|---------------------+-----------------------------------------------------------------------|
| *Trigger* | Ein User möchte automatisierte Backups haben. |
|---------------------+-----------------------------------------------------------------------|
| *Preconditions* | Eine funktionierende Konfiguration muss hinterlegt sein. |
| | Applikation gestartet. |
|---------------------+-----------------------------------------------------------------------|
| *Postconditions* | Ein Systemdienst wurde erstellt welcher jeden Tag ein Backup macht. |
|---------------------+-----------------------------------------------------------------------|
| *Normal Flow* | 1. Auf den Button "Settings" klicken. |
| | 2. Bei der Option "Automatic Backups" den Hacken setzen. |
| | 3. Die Settings mit klick auf "Ok" schliessen und speichern. |
|---------------------+-----------------------------------------------------------------------|
| *Alternative Flow* | 1. Auf den Button "Settings" klicken. |
| | 2. Bei der Option "Automatic Backups" den Hacken setzen. |
2019-01-10 21:10:37 +01:00
| | 3. Die Aktion mit klick auf "Cancel" abbrechen |
2019-01-10 20:28:10 +01:00
|---------------------+-----------------------------------------------------------------------|
| *Notes* | - |
|---------------------+-----------------------------------------------------------------------|
| *UC History* | 1.0 Draft erstellt durch AZ |
|---------------------+-----------------------------------------------------------------------|
| *Author* | A. Zweili |
|---------------------+-----------------------------------------------------------------------|
| *Date* | 30.12.2018 |
|---------------------+-----------------------------------------------------------------------|
2019-01-03 12:17:45 +01:00
#+LATEX :}
#+caption : Aktivitätsdiagramm zum Aktivieren von automatischen Backups
#+name : fig:activity_automatic
[[file:pictures/activity_automatic.pdf ]]
#+attr_latex : :center :placement [H]
#+LATEX :\newpage
2019-02-27 21:55:48 +01:00
* TODO Konzept
2018-12-24 15:53:54 +01:00
2018-12-23 10:07:34 +01:00
** Varianten
2018-12-10 21:16:57 +01:00
2019-01-10 21:40:35 +01:00
Da Borg eine JSON API zur Verfügung stellt bieten sich diverse Möglichkeiten, um
2018-12-16 21:51:22 +01:00
das Programm anzubinden. Da das Ziel ist, das Programm normalen Nutzern
zugänglicher zu machen, bietet sich ein normales Desktop Programm am ehesten
an. Desktop Programme werden von allen Computer Usern täglich genutzt und sind
somit etwas was sie kennen.
2018-12-18 21:16:01 +01:00
Daraus ergeben sich die in diesem Kapitel aufgeführten Möglichkeiten für das
Projekt.
2018-12-19 21:12:30 +01:00
*** Bewertung
2018-12-18 21:16:01 +01:00
Die Bewertungspunkte setzen sich einerseits aus den Projektzielen anderseits
aus für das Projekt sinnvollen Punkten zusammen. Dadurch ergeben sich dann die
2019-01-10 21:40:35 +01:00
Bewertungen, welche in der nachfolgenden Tabelle aufgenommen wurden. Die
2018-12-22 13:57:08 +01:00
möglichen Varianten wurden danach bewertet. Die effektive Berechnung des
Resultats wird nach folgender Formel durchgeführt.
\begin{equation}
G * EP = KE
\end{equation}
Also die Gewichtung(/G/ ) multipliziert mit der erreichten Punktzahl(/EP/ )
ergibt das Kriteriumsergebnis(/KE/ ). Für das Endresultat wird dann die Summe
über alle Kriterien gebildet. Die Variante mit der höchsten Summe wurde für das
Projekt ausgewählt.
Mussziele erhalten dabei eine
2018-12-18 21:16:01 +01:00
Gewichtung von 10 und Wunschziele eine Gewichtung entsprechend der Bewertung in
der Tabelle Projektziele ([[tab:projektziele ]]).
#+CAPTION : Muster Bewertungstabelle
#+ATTR_LATEX : :align |>{\columncolor[HTML]{EFEFEF}}p{4cm}|c|p{2cm}|p{2cm}|p{2cm}|
#+NAME : tab:muster
2019-01-10 20:28:10 +01:00
|---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
| <20> | <20> | <20> | <20> | <20> |
| *Kriterium*\cellcolor[HTML]{C0C0C0} | *Gewichtung*\cellcolor[HTML]{C0C0C0} | *max. Punktzahl*\cellcolor[HTML]{C0C0C0} | *erreichte Punktzahl*\cellcolor[HTML]{C0C0C0} | *Kriteriums- ergebnis*\cellcolor[HTML]{C0C0C0} |
|---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
| 1. Cross Plattform nutzbar | 10 | 10 | 10 | 100 |
| 2. Freie Software | 5 | 10 | 10 | 50 |
| 3. Vorkenntnisse | 5 | 10 | 10 | 50 |
| 4. Integriert sich gut ins System | 5 | 10 | 10 | 50 |
| 5. Ohne spezielle Tools nutzbar | 5 | 10 | 10 | 50 |
| 6. Lesbarkeit des Codes | 5 | 5 | 5 | 25 |
| 7. Einfachheit des Setups | 5 | 5 | 5 | 25 |
| 8. Lernfaktor | 5 | 5 | 5 | 25 |
| 9. Verbreitung bei der BorgBackup Community | 5 | 5 | 5 | 25 |
| 10. Geschwindigkeit der Entwicklung | 3 | 5 | 5 | 15 |
|---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
| *Total* | | | | 415 |
|---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
2018-12-18 21:16:01 +01:00
#+TBLFM : @3$5=@3$2 * @3$4::@4$5=@4$2 * @4$4::@5$5=@5$2 * @5$4::@6$5=@6$2 * @6$4::@7$5=@7$2 * @7$4::@8$5=@8$2 * @8$4::@9$5=@9$2 * @9$4::@10$5=@10$2 * @10$4::@11$5=@11$2 * @11$4::@12$5=@12$2 * @12$4
#+TBLFM : @>$5=vsum(@3..@-1)
2018-12-16 21:51:22 +01:00
*** Backend
2018-12-19 21:12:30 +01:00
Fürs Backend bieten sich die folgende drei Sprachen an: [[C# ][C# ]], [[C++ ][C++ ]], [[Python ][Python ]].
2019-01-10 21:40:35 +01:00
Dies vor allem, weil alle Allrounder Sprachen sind und sich gut für Desktop
2018-12-19 21:12:30 +01:00
Applikationen eignen.
2018-12-16 21:51:22 +01:00
2018-12-18 21:16:01 +01:00
**** C#
2018-12-16 21:51:22 +01:00
2018-12-19 21:12:30 +01:00
C# ist eine von Microsoft entwickelte Programmiersprache welche viele
2019-01-10 21:40:35 +01:00
Frameworks zur Verfügung hat. Insbesondere aufgrund der grossen kommerziellen
2018-12-19 21:12:30 +01:00
Nutzung und der guten Integration mit Windows hat C# eine relative grosse
Verbreitung. Bei Linux und OS X ist es jedoch schwieriger C# zu integrieren und
zu nutzen.
2018-12-16 21:51:22 +01:00
2019-01-10 21:40:35 +01:00
Sie ist zu Teilen gls:libre. Die Common Language Runtime, welche für das
2018-12-16 21:51:22 +01:00
Ausführen von Software zuständig ist, ist unter der MIT Lizenz lizenziert
footcite:csharp der aktuelle Compiler Roslyn ist unter der Apache Lizenz
2019-01-10 21:10:37 +01:00
verfügbar footcite:roslyn. Da es sehr viele offizielle Teile um die Sprache C#
2019-01-10 21:40:35 +01:00
gibt, kann im Rahmen des Projektes nicht direkt abgeschätzt werden, ob alle
2018-12-19 21:12:30 +01:00
benötigten Teile gls:libre sind. Für die Bewertung wird deshalb ein kleinerer
Wert als bei C++ und Python genommen.
2019-01-10 21:40:35 +01:00
C# ist die Programmiersprache, welche an der IBZ hauptsächlich gelehrt wird.
2018-12-19 21:12:30 +01:00
Dadurch sind die Kenntnisse der Sprache und ihrer Anwendung bereits
einigermassen vorhanden. Ausserhalb der Schule wurde die Sprache jedoch noch nie
eingesetzt.
Entwickelt wird C# hauptsächlich mit der gls:ide Microsoft Visual Studio.
2019-01-10 21:10:37 +01:00
Eine sehr umfangreiche und komplexe Software. Visual Studio ist dabei nur für
2018-12-19 21:12:30 +01:00
Windows und OS X erhältlich. Es ist auch möglich C# Projekte ausserhalb von
2019-01-10 21:40:35 +01:00
Visual Studio zu erstellen, es ist jedoch nicht sehr einfach.
2018-12-19 21:12:30 +01:00
Der Code ist gut lesbar und es gibt offizielle Styleguides von Microsoft was
den Code über Projekte hinaus einigermassen einheitlich aussehen lässt. Zudem
hilft hier auch Visual Studio stark den Code entsprechend zu formatieren.
Besonders angenehm sind die Klassen- und Methodennamen der offiziellen
Frameworks. Insgesamt sehr gut gelöst aber in Sachen Lesbarkeit noch etwas
hinter Python.
Unter Windows ist das Setup von C# relativ einfach. Allerdings ist es auch dort
im Vergleich zu Python eine umfangreiche Angelegenheit Visual Studio sauber zu
installieren und nutzbar zu machen. Auf anderen Plattform wird dies leider
nicht einfacher und unter Linux ist es bereits schwierig eine funktionierende
2019-01-10 21:10:37 +01:00
Umgebung in Gang zu bringen.
2018-12-19 21:12:30 +01:00
2019-01-10 21:40:35 +01:00
Da C# bereits an der IBZ gelernt wird, ist der Lernfaktor hier im Vergleich zu
2018-12-19 21:12:30 +01:00
den anderen Sprachen sicher am kleinsten. Allerdings gibt es noch keinerlei
Kenntnisse beim Einbinden eines der unten aufgeführten gls:gui Frameworks.
Daher gibt es auf jeden Fall noch genügend zu lernen.
2018-12-19 21:36:46 +01:00
Die gls:borg Community hat vor relativ kurzer Zeit die offizielle Unterstützung
2019-01-10 21:40:35 +01:00
von Windows zurückgezogen. Da C# eine sehr Windows lastige Sprache ist, wird
2018-12-19 21:12:30 +01:00
daher davon ausgegangen das die Sprache innerhalb der gls:borg Community nicht
sehr verbreitet ist.
2019-01-10 21:40:35 +01:00
C# ist eine stark typisiert Sprache und kompilierte Sprache. Des Weiteren ist
2018-12-19 21:12:30 +01:00
Visual Studio der Erfahrung nach nicht die schnellste Software. Dies alles
2019-01-10 21:10:37 +01:00
führt dazu das C# nicht gerade die schnellste Sprache zum Programmieren ist.
2018-12-19 21:12:30 +01:00
Jedoch aufgrund des moderneren Unterbaus sicher schneller als C++.
2018-12-16 21:51:22 +01:00
2018-12-18 21:16:01 +01:00
#+CAPTION : C# Bewertungstabelle
#+ATTR_LATEX : :align |>{\columncolor[HTML]{EFEFEF}}p{4cm}|c|p{2cm}|p{2cm}|p{2cm}|
#+NAME : tab:csharp
2019-01-10 20:28:10 +01:00
|---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
| <20> | <20> | <20> | <20> | <20> |
| *Kriterium*\cellcolor[HTML]{C0C0C0} | *Gewichtung*\cellcolor[HTML]{C0C0C0} | *max. Punktzahl*\cellcolor[HTML]{C0C0C0} | *erreichte Punktzahl*\cellcolor[HTML]{C0C0C0} | *Kriteriums- ergebnis*\cellcolor[HTML]{C0C0C0} |
|---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
| 1. Cross Plattform nutzbar | 10 | 10 | 8 | 80 |
| 2. Freie Software | 5 | 10 | 8 | 40 |
| 3. Vorkenntnisse | 5 | 10 | 6 | 30 |
| 4. Integriert sich gut ins System | 5 | 10 | 8 | 40 |
| 5. Ohne spezielle Tools nutzbar | 5 | 10 | 6 | 30 |
| 6. Lesbarkeit des Codes | 5 | 5 | 4 | 20 |
| 7. Einfachheit des Setups | 5 | 5 | 2 | 10 |
| 8. Lernfaktor | 5 | 5 | 3 | 15 |
| 9. Verbreitung bei der BorgBackup Community | 5 | 5 | 1 | 5 |
| 10. Geschwindigkeit der Entwicklung | 3 | 5 | 3 | 9 |
|---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
| *Total* | | | | 279 |
|---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
2018-12-18 21:16:01 +01:00
#+TBLFM : @3$5=@3$2 * @3$4::@4$5=@4$2 * @4$4::@5$5=@5$2 * @5$4::@6$5=@6$2 * @6$4::@7$5=@7$2 * @7$4::@8$5=@8$2 * @8$4::@9$5=@9$2 * @9$4::@10$5=@10$2 * @10$4::@11$5=@11$2 * @11$4::@12$5=@12$2 * @12$4
#+TBLFM : @>$5=vsum(@3..@-1)
**** C++
2018-12-16 21:51:22 +01:00
C++ ist eine stark typisierte und kompilierte Programmiersprache. Sie ist seit
1998 Teil des ISO Standards footcite:cpp98. ISO/IEC 14882:2017 footcite:cpp17
2019-01-10 21:40:35 +01:00
ist zurzeit die aktuellste Variante. Die Sprache existiert seit ca. 33 Jahren
2018-12-16 21:51:22 +01:00
und hat eine weitreichende Verbreitung gefunden. C++ ist auf allen
2018-12-19 21:12:30 +01:00
Betriebssystemen gut unterstützt muss jedoch für jedes System separat
kompiliert werden.
2018-12-16 21:51:22 +01:00
2018-12-18 21:16:01 +01:00
Von C++ sind innerhalb des Projektes keinerlei Vorkenntnisse vorhanden. Dies
ist ein sehr hoher Risikofaktor.
2018-12-18 21:59:54 +01:00
C++ kompiliert direkt zu Maschinensprache und ist dadurch sehr performant und
läuft sehr gut auf jedem System. C++ ist im Vergleich zu modernen Sprachen
jedoch relativ komplex und bietet diverse Stolpersteine für Programmierer.
2019-01-10 21:40:35 +01:00
Zum Entwickeln braucht es verhältnismässig wenig. Da die Sprache bereits sehr
2018-12-18 21:59:54 +01:00
alt ist, stammt sie noch aus einer Zeit wo man noch etwas rudimentärer
programmierte. Allerdings braucht man in jedem Fall einen gls:compiler um ein
ausführbares Programm zu erzeugen. Bei komplexeren Programmen wird man um
2019-01-10 21:40:35 +01:00
mindestens so etwas wie glspl:makefile auch nicht herumkommen
2018-12-18 21:59:54 +01:00
Im Vergleich zu Python oder C# ist C++ wohl die am schwersten lesbare Sprache.
2019-01-10 21:40:35 +01:00
Zudem gibt es auch keinen zentralen Styleguide, welcher einem vorgeben würde wie
2019-01-10 21:10:37 +01:00
der Code am besten ausschauen sollte. Somit haben sich über die Jahre mehrere
2018-12-18 21:59:54 +01:00
Standards etabliert.
2019-01-10 21:40:35 +01:00
Der Lernfaktor wäre aufgrund der mangelnden Vorkenntnisse hier ganz klar am
2018-12-18 21:59:54 +01:00
Grössten.
Da C++ eine alte Sprache ist geniesst sie auch eine dementsprechende
Verbreitung. Daher ist anzunehmen das sicher mindestens ein grössere Teil der
älteren BorgBackup Entwickler C++ oder C gelernt haben.
2018-12-16 21:51:22 +01:00
Da C++ auch heute noch zu den meistgenutzten Sprachen gehört gibt es
2019-01-10 21:40:35 +01:00
entsprechend viele Ressourcen dazu und Beispiel Projekte, von denen man ableiten
kann. Auch hilfreiche Libraries gibt es sehr viele, welche den Programmierer
2018-12-18 21:59:54 +01:00
unterstützen können. Die Sprache selber ist jedoch eher umständlich zu
2019-01-10 21:40:35 +01:00
schreiben. Hinzu kommt noch das man, während der Entwicklung immer wieder den
2018-12-18 21:59:54 +01:00
Code kompilieren muss. In einem Projekt mit dieser begrenzten Zeitspanne eher
ungeeignet.
2018-12-16 21:51:22 +01:00
2018-12-18 21:16:01 +01:00
#+CAPTION : C++ Bewertungstabelle
#+ATTR_LATEX : :align |>{\columncolor[HTML]{EFEFEF}}p{4cm}|c|p{2cm}|p{2cm}|p{2cm}|
#+NAME : tab:cpp
2019-01-11 20:05:58 +01:00
|---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+-------------------------------------------------|
| <20> | <20> | <20> | <20> | <20> |
2019-01-10 21:10:37 +01:00
| *Kriterium*\cellcolor[HTML]{C0C0C0} | *Gewichtung*\cellcolor[HTML]{C0C0C0} | *max. Punktzahl*\cellcolor[HTML]{C0C0C0} | *erreichte Punktzahl*\cellcolor[HTML]{C0C0C0} | *Kriteriums- -ergebnis*\cellcolor[HTML]{C0C0C0} |
2019-01-11 20:05:58 +01:00
|---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+-------------------------------------------------|
| 1. Cross Plattform nutzbar | 10 | 10 | 8 | 80 |
| 2. Freie Software | 5 | 10 | 10 | 50 |
| 3. Vorkenntnisse | 5 | 10 | 0 | 0 |
| 4. Integriert sich gut ins System | 5 | 10 | 8 | 40 |
| 5. Ohne spezielle Tools nutzbar | 5 | 10 | 6 | 30 |
| 6. Lesbarkeit des Codes | 5 | 5 | 2 | 10 |
| 7. Einfachheit des Setups | 5 | 5 | 3 | 15 |
| 8. Lernfaktor | 5 | 5 | 5 | 25 |
| 9. Verbreitung bei der BorgBackup Community | 5 | 5 | 3 | 15 |
| 10. Geschwindigkeit der Entwicklung | 3 | 5 | 2 | 6 |
|---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+-------------------------------------------------|
| *Total* | | | | 271 |
|---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+-------------------------------------------------|
2018-12-18 21:16:01 +01:00
#+TBLFM : @3$5=@3$2 * @3$4::@4$5=@4$2 * @4$4::@5$5=@5$2 * @5$4::@6$5=@6$2 * @6$4::@7$5=@7$2 * @7$4::@8$5=@8$2 * @8$4::@9$5=@9$2 * @9$4::@10$5=@10$2 * @10$4::@11$5=@11$2 * @11$4::@12$5=@12$2 * @12$4
#+TBLFM : @>$5=vsum(@3..@-1)
**** Python
Der Python Interpreter ist für eine Vielzahl an Betriebssystemen erhältlich,
inklusive Windows, OS X und Linux. Nahezu jedes Desktop Linux System kommt mit
Python vor installiert. Auch OS X kommt bereits ab Werk mit Python Version 2.
Version 3 lässt sich sehr einfach nachinstallieren und ist einfach nutzbar.
2019-01-10 21:40:35 +01:00
Unter Windows gestaltetet sich die Installation etwas aufwendiger aber auch
2019-01-12 13:41:37 +01:00
nicht sehr kompliziert. Python integriert sich in Windows jedoch etwas weniger
elegant als C#.
2018-12-16 21:51:22 +01:00
2018-12-18 21:16:01 +01:00
Python ist freie Software unter der Python Software Foundation License
footcite:python und wird durch die Python Software Foundation in einem
Community basierten Modell entwickelt.
Die Vorkenntnisse sind im Vergleich zu C++ relativ gross und zu C# etwas
weniger ausgeprägt. Es wurden damit im Rahmen der Ausbildung schon ein
grösseres Projekt realisiert und ansonsten mehrere kleine Projekte im Privaten
erstellen.
Für Python gibt es ein paar glspl:ide welchen den Programmierer bei seiner
Arbeit unterstützen können. Keine davon ist allerdings ein Muss um Python
programmieren zu können. Im einfachsten Fall wäre dies mit Notepad möglich. Ein
2019-01-10 21:10:37 +01:00
Editor mit etwas fortgeschritteneren Features wäre jedoch empfehlenswert.
2018-12-16 21:51:22 +01:00
Python unterstützt mehrere Programmierungsparadigmen wie etwa
2019-01-10 21:10:37 +01:00
objektorientiert, funktionale oder Prozedurale Paradigmen. Bei der Entwicklung
2018-12-18 21:16:01 +01:00
von Python wurde sehr grossen Wert auf die Lesbarkeit der Sprache gelegt. Dies
2019-01-10 21:10:37 +01:00
mit dem Hintergedanken das eine Programmiersprache viel häufiger gelesen als
2018-12-18 21:16:01 +01:00
effektiv geschrieben wird footcite:pep8.
2018-12-16 21:51:22 +01:00
2018-12-18 21:16:01 +01:00
Um ein Python Programm zu starten braucht es eigentlich kein grosses Setup.
Solange die Abhängigkeiten vorhanden sind, kann man ein Skript mit einem
2018-12-22 00:39:15 +01:00
einfachen Befehl, Code Snippet ([[code:minimal_python ]]) starten.
2018-12-16 21:51:22 +01:00
2018-12-18 21:16:01 +01:00
#+caption : Minimal Python Setup
2018-12-22 00:39:15 +01:00
#+name : code:minimal_python
2018-12-18 21:16:01 +01:00
#+BEGIN_SRC bash
python3 example.py
#+END_SRC
2018-12-16 21:51:22 +01:00
2018-12-18 21:16:01 +01:00
Da Python schon eine etwas bekanntere Sprache ist, ist der Lernfaktor der
Sprache selber nicht mehr so hoch. Allerdings gibt es noch viele interessante
2019-01-10 21:40:35 +01:00
Konzepte, die man im Zusammenhang mit der Sprache lernen kann. Wie etwa zum
2018-12-18 21:16:01 +01:00
Beispiel multiple Vererbung von Klassen.
2018-12-16 21:51:22 +01:00
2018-12-19 21:36:46 +01:00
gls:borg selber wurde in Python geschrieben. Daher ist davon auszugehen das
2018-12-18 21:16:01 +01:00
Python innerhalb dieser Community eine sehr hohe Verbreitung geniesst.
2018-12-16 21:51:22 +01:00
2018-12-18 21:16:01 +01:00
Python ist eine dynamisch typisierte und interpretierte Sprache. Dies bedeutet
2019-01-10 21:10:37 +01:00
das man bei Variablen nicht explizit den Typ angeben muss und die Programme zur
2018-12-18 21:16:01 +01:00
Laufzeit für den Computer übersetzt werden. Interpretierte Sprachen haben den
Vorteil das man mit ihnen in der Regel sehr schnell und unkompliziert
2019-01-10 21:40:35 +01:00
entwickeln kann, dies jedoch zulasten der Performance.
2018-12-16 21:51:22 +01:00
2018-12-18 21:16:01 +01:00
#+CAPTION : Python Bewertungstabelle
#+ATTR_LATEX : :align |>{\columncolor[HTML]{EFEFEF}}p{4cm}|c|p{2cm}|p{2cm}|p{2cm}|
#+NAME : tab:python
2019-01-11 20:05:58 +01:00
|--------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+-------------------------------------------------|
| <20> | <20> | <20> | <20> | <20> |
2019-01-10 21:10:37 +01:00
| *Kriterium*\cellcolor[HTML]{C0C0C0} | *Gewichtung*\cellcolor[HTML]{C0C0C0} | *max. Punktzahl*\cellcolor[HTML]{C0C0C0} | *erreichte Punktzahl*\cellcolor[HTML]{C0C0C0} | *Kriteriums- -ergebnis*\cellcolor[HTML]{C0C0C0} |
2019-01-11 20:05:58 +01:00
|--------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+-------------------------------------------------|
| 1. Cross Plattform nutzbar | 10 | 8 | 8 | 80 |
| 2. Freie Software | 5 | 10 | 10 | 50 |
| 3. Vorkenntnisse | 5 | 10 | 5 | 25 |
| 4. Integriert sich gut ins System | 5 | 10 | 8 | 40 |
| 5. Ohne spezielle Tools nutzbar | 5 | 10 | 7 | 35 |
| 6. Lesbarkeit des Codes | 5 | 5 | 4 | 20 |
| 7. Einfachheit des Setups | 5 | 5 | 4 | 20 |
| 8. Lernfaktor | 5 | 5 | 3 | 15 |
| 9. Verbreitung in der BorgBackup Community | 5 | 5 | 5 | 25 |
| 10. Geschwindigkeit der Entwicklung | 3 | 5 | 4 | 12 |
|--------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+-------------------------------------------------|
| *Total* | | | | 322 |
|--------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+-------------------------------------------------|
2018-12-18 21:16:01 +01:00
#+TBLFM : @3$5=@3$2 * @3$4::@4$5=@4$2 * @4$4::@5$5=@5$2 * @5$4::@6$5=@6$2 * @6$4::@7$5=@7$2 * @7$4::@8$5=@8$2 * @8$4::@9$5=@9$2 * @9$4::@10$5=@10$2 * @10$4::@11$5=@11$2 * @11$4::@12$5=@12$2 * @12$4
#+TBLFM : @>$5=vsum(@3..@-1)
2019-01-10 21:10:37 +01:00
*** Frontend
2018-12-18 21:16:01 +01:00
2018-12-19 22:25:35 +01:00
Fürs Frontend sind folgende Projekte interessant: [[Qt ][Qt ]], [[Gtk ][Gtk ]] und [[Electron ][Electron ]]. Alle
2019-01-10 21:10:37 +01:00
drei sind cross-plattform fähige gls:gui Frameworks und nicht von einer
2018-12-19 22:25:35 +01:00
spezifischen Sprache abhängig. Da nahezu keine Erfahrung mit den aufgeführten
2019-01-10 21:40:35 +01:00
Frameworks vorhanden ist, werden bei den Frontend Frameworks die Punkte der
Verbreitung in der Community und Geschwindigkeit der Entwicklung ausgeschlossen.
In beiden Fällen wäre nicht mal eine ungenaue Schätzung wirklich möglich.
2018-12-18 21:16:01 +01:00
2018-12-19 22:25:35 +01:00
**** Qt
Qt footcite:qt, "cute" ausgesprochen, ist ein Framework zum Entwickeln von
2019-01-10 21:40:35 +01:00
grafischen Oberflächen, welche auf verschiedenen System ohne grosse Änderungen
2018-12-19 22:25:35 +01:00
laufen sollen und sich dabei soweit als möglich wie eine native Applikation
verhalten und "anfühlen" soll.
Die Rechte an Qt hält die Firma "The Qt Company". Das Framework Qt wird jedoch
offen entwickelt und die Community hat ein Mitspracherecht. Die Linux
Desktopumgebung KDE nutzt das Qt Framework intensiv. Qt ist gls:libre und der
gls:gpl v3 footcite:qtlicense oder mit einer kostenpflichtigen proprietären
2019-01-11 17:55:58 +01:00
Lizenz erhältlich, falls die gls:gpl nicht genutzt werden kann.
2018-12-19 22:25:35 +01:00
Vorkenntnisse zu Qt sind nur sehr wenig vorhanden. Mehr als ein paar Tests
wurden damit noch nicht gemacht.
Eine Qt Oberfläche kann direkt in der jeweiligen Sprache des Backends
geschrieben werden oder Mittels des Qt Designers als XML Datei gespeichert und
dann in die eigentliche Applikation importiert werden. Somit ist keine
spezielle Software nötig.
2019-01-11 17:55:58 +01:00
XML ist nicht übermässig gut lesbar, allerdings kann man Qt in der verwendeten
2018-12-19 22:25:35 +01:00
Sprache programmiert werden somit ist es hauptsächlich von der Sprache im
Backend abhängig. Die Dokumentation ist in C++ geschrieben was für einen
Entwickler ohne C++ Kenntnisse die Software etwas unzugänglich macht.
Qt scheint, soweit dies bis jetzt abgeschätzt werden kann, sehr leicht in ein
Projekt zu integrieren sein.
2019-01-11 17:55:58 +01:00
Da noch sehr wenig Kenntnisse vorhanden sind, ist der Lernfaktor entsprechend
2018-12-19 22:25:35 +01:00
gross.
2018-12-18 21:16:01 +01:00
#+CAPTION : Qt Bewertungstabelle
#+ATTR_LATEX : :align |>{\columncolor[HTML]{EFEFEF}}p{4cm}|c|p{2cm}|p{2cm}|p{2cm}|
#+NAME : tab:qt
2019-01-10 20:28:10 +01:00
|-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
| <20> | <20> | <20> | <20> | <20> |
2018-12-18 21:16:01 +01:00
| *Kriterium*\cellcolor[HTML]{C0C0C0} | *Gewichtung*\cellcolor[HTML]{C0C0C0} | *max. Punktzahl*\cellcolor[HTML]{C0C0C0} | *erreichte Punktzahl*\cellcolor[HTML]{C0C0C0} | *Kriteriums- ergebnis*\cellcolor[HTML]{C0C0C0} |
2019-01-10 20:28:10 +01:00
|-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
| 1. Cross Plattform nutzbar | 10 | 10 | 10 | 100 |
| 2. Freie Software | 5 | 10 | 10 | 50 |
| 3. Vorkenntnisse | 5 | 10 | 2 | 10 |
| 4. Integriert sich gut ins System | 5 | 10 | 8 | 40 |
| 5. Ohne spezielle Tools nutzbar | 5 | 10 | 8 | 40 |
| 6. Lesbarkeit des Codes | 5 | 5 | 3 | 15 |
| 7. Einfachheit des Setups | 5 | 5 | 4 | 20 |
| 8. Lernfaktor | 5 | 5 | 4 | 20 |
|-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
| *Total* | | | | 295 |
|-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
2018-12-19 22:25:35 +01:00
#+TBLFM : @3$5=@3$2 * @3$4::@4$5=@4$2 * @4$4::@5$5=@5$2 * @5$4::@6$5=@6$2 * @6$4::@7$5=@7$2 * @7$4::@8$5=@8$2 * @8$4::@9$5=@9$2 * @9$4::@10$5=@10$2 * @10$4
2018-12-18 21:16:01 +01:00
#+TBLFM : @>$5=vsum(@3..@-1)
2018-12-22 00:40:03 +01:00
**** Gtk
2018-12-18 21:16:01 +01:00
2018-12-22 00:40:03 +01:00
Gtk ist sowohl für Linux wie auch für Windows und OS X erhältlich. Gtk hat als
Projekt der Gnome Foundation seine Wurzeln jedoch ganz klar in der Linux Welt.
2019-01-10 21:10:37 +01:00
Gtk ist gls:libre unter der Lesser General Public Lizenz footcite:gtklicense.
2019-01-11 17:55:58 +01:00
Gtk ist ein Projekt der GNOME Foundation einer nicht für Profit Organisation,
2018-12-22 00:40:03 +01:00
welche die Entwicklung diverser freier Software Projekte koordiniert.
Zu Gtk gibt es keinerlei Vorkenntnisse als Programmierer. Gtk wurde bis jetzt
2019-01-12 13:41:37 +01:00
nur intensiv als User verwendet.
2018-12-22 00:40:03 +01:00
Gtk integriert sich nur unter Linux wirklich gut ins System. Unter Windows und
2019-01-12 13:41:37 +01:00
OS X können die Applikationen schnell etwas fremd wirken. Dies ist gut bei der
2019-01-11 17:55:58 +01:00
Applikation Meld footcite:meld zu sehen, wenn man eine Datei auswählen möchte,
2018-12-22 00:40:03 +01:00
Abbildung ([[fig:meld ]]).
#+caption : Screenshot der Applikation Meld unter Windows 10
#+name : fig:meld
[[file:pictures/meld.png ]]
2018-12-22 14:11:03 +01:00
#+attr_latex : :center
2018-12-22 00:40:03 +01:00
2019-01-11 17:55:58 +01:00
Die Gtk Dokumentation empfiehlt footcite:gtk_setup, dass man unter Windows das
Programm MSYS2 installiert, um Gtk einzurichten. Zum Programmieren an sich
2018-12-22 00:40:03 +01:00
braucht es offenbar nicht zwingend weitere Tools aus einem Editor. Wie auch bei
Qt hat man jedoch die Möglichkeit das gls:gui mit einem gls:gui Designer
grafisch zu erstellen.
2019-01-11 17:55:58 +01:00
Wie auch Qt kann man Gtk entweder direkt in der Backend Sprache programmieren
2018-12-22 00:40:03 +01:00
oder aus dem gls:gui Designer dann als XML exportieren. Der Code in der
2019-01-11 17:55:58 +01:00
Dokumentation ist in C geschrieben, welches auch nicht die zugänglichste
Sprache ist.
2018-12-22 00:40:03 +01:00
Die Verwendung von Gtk innerhalb des Programms scheint ähnlich einfach zu sein
wie bei Qt. Die Installation ist allerdings unter Windows eher das Gegenteil
von einfach.
2019-01-11 17:55:58 +01:00
Da die Kenntnisse gleich null sind, ist der Lernfaktor auf dem Maximum.
2018-12-19 22:25:35 +01:00
2018-12-18 21:16:01 +01:00
#+CAPTION : Gtk Bewertungstabelle
#+ATTR_LATEX : :align |>{\columncolor[HTML]{EFEFEF}}p{4cm}|c|p{2cm}|p{2cm}|p{2cm}|
#+NAME : tab:gtk
2019-01-10 20:28:10 +01:00
|-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
| <20> | <20> | <20> | <20> | <20> |
2018-12-18 21:16:01 +01:00
| *Kriterium*\cellcolor[HTML]{C0C0C0} | *Gewichtung*\cellcolor[HTML]{C0C0C0} | *max. Punktzahl*\cellcolor[HTML]{C0C0C0} | *erreichte Punktzahl*\cellcolor[HTML]{C0C0C0} | *Kriteriums- ergebnis*\cellcolor[HTML]{C0C0C0} |
2019-01-10 20:28:10 +01:00
|-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
| 1. Cross Plattform nutzbar | 10 | 10 | 10 | 100 |
| 2. Freie Software | 5 | 10 | 10 | 50 |
| 3. Vorkenntnisse | 5 | 10 | 0 | 0 |
| 4. Integriert sich gut ins System | 5 | 10 | 6 | 30 |
| 5. Ohne spezielle Tools nutzbar | 5 | 10 | 8 | 40 |
| 6. Lesbarkeit des Codes | 5 | 5 | 3 | 15 |
| 7. Einfachheit des Setups | 5 | 5 | 3 | 15 |
| 8. Lernfaktor | 5 | 5 | 5 | 25 |
|-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
| *Total* | | | | 275 |
|-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
2018-12-22 00:40:03 +01:00
#+TBLFM : @3$5=@3$2 * @3$4::@4$5=@4$2 * @4$4::@5$5=@5$2 * @5$4::@6$5=@6$2 * @6$4::@7$5=@7$2 * @7$4::@8$5=@8$2 * @8$4::@9$5=@9$2 * @9$4::@10$5=@10$2 * @10$4
2018-12-18 21:16:01 +01:00
#+TBLFM : @>$5=vsum(@3..@-1)
2018-12-22 13:53:49 +01:00
**** Electron
2018-12-18 21:16:01 +01:00
2019-01-11 17:55:58 +01:00
Electron ist ein cross-plattform Framework zum Entwickeln von glspl:gui welches
2018-12-22 00:40:03 +01:00
dabei jedoch auf Technologien aus der Webentwicklung benutzt. Entwickelt wird
Electron von der Firma Github und ist gls:libre unter der MIT Lizenz
footcite:electronlicense.
2019-01-11 17:55:58 +01:00
Da Electron auf Technologien aus der Webentwicklung setzt, sind hier im
Vergleich zu den anderen Frameworks bereit gute Kenntnisse vorhanden. Über die
genau Funktion und Implementierung sind noch keine Kenntnisse vorhanden.
2018-12-22 00:40:03 +01:00
Die Verwendung von Webtechnologien macht Electron zwar sehr kompatibel auf den
2018-12-22 13:53:49 +01:00
unterstützten Systemen, oftmals sehen die Applikationen jedoch doch eher wie
2019-01-11 17:55:58 +01:00
eine Webseite als wie eine Desktop Applikation aus. Ein weiterer Nachteil ist
der hohe Ressourcenverbrauch, da jede Applikation nahezu einer eigenen Instanz
2018-12-22 13:53:49 +01:00
des Google Chrome Browsers gleich kommt.
2019-01-10 21:10:37 +01:00
Bei der Installation muss Node.js und der Paket Manager von Node.js, NPM,
2018-12-22 13:53:49 +01:00
vorhanden sein. Zum Programmieren selber braucht es keine speziellen Tools. Ein
2019-01-11 17:55:58 +01:00
Editor und ein Webbrowser sollten ausreichend sein.
2018-12-22 13:53:49 +01:00
Electron Applikationen bestehen hauptsächlich aus HTML, CSS und JavaScript
2019-01-10 21:10:37 +01:00
Code. Wenn man sich die komplette Applikation in Node.js programmieren möchte
kommt dann noch eine zusätzliche Sprache hinzu. HTML ist ähnlich mühsam zu
2019-01-11 17:55:58 +01:00
lesen wie XML. CSS und JavaScript sind relativ angenehm zu lesen, wobei es für
2019-01-10 21:10:37 +01:00
beide keine offiziellen Styleguides gibt. Was bei Webanwendungen jedoch immer
2019-01-11 17:55:58 +01:00
das schwierigste ist, ist der Wechsel zwischen verschiedenen Sprachen und
2018-12-22 13:53:49 +01:00
Konzepten. Dieses Problem hat man bei Electron leider auch.
Das Setup von Electron ist etwa ähnlich kompliziert wie das Setup von Gtk und
ist sehr ähnlich dem Entwickeln einer normalen Webapplikation.
Da an der IBZ Webtechnologien bereits intensiv behandelt worden sind und man in
2019-01-11 17:55:58 +01:00
diesem Rahmen bereits ein paar Webapplikationen erstellt hat, wäre der
2018-12-22 13:53:49 +01:00
Lernfaktor bei Electron wohl nicht so gross wie etwa bei Qt oder Gtk.
2018-12-22 00:40:03 +01:00
2018-12-18 21:16:01 +01:00
#+CAPTION : Electron Bewertungstabelle
#+ATTR_LATEX : :align |>{\columncolor[HTML]{EFEFEF}}p{4cm}|c|p{2cm}|p{2cm}|p{2cm}|
#+NAME : tab:electron
2019-01-10 20:28:10 +01:00
|-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
| <20> | <20> | <20> | <20> | <20> |
2018-12-18 21:16:01 +01:00
| *Kriterium*\cellcolor[HTML]{C0C0C0} | *Gewichtung*\cellcolor[HTML]{C0C0C0} | *max. Punktzahl*\cellcolor[HTML]{C0C0C0} | *erreichte Punktzahl*\cellcolor[HTML]{C0C0C0} | *Kriteriums- ergebnis*\cellcolor[HTML]{C0C0C0} |
2019-01-10 20:28:10 +01:00
|-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
| 1. Cross Plattform nutzbar | 10 | 10 | 10 | 100 |
| 2. Freie Software | 5 | 10 | 10 | 50 |
| 3. Vorkenntnisse | 5 | 10 | 5 | 25 |
| 4. Integriert sich gut ins System | 5 | 10 | 4 | 20 |
| 5. Ohne spezielle Tools nutzbar | 5 | 10 | 7 | 35 |
| 6. Lesbarkeit des Codes | 5 | 5 | 3 | 15 |
| 7. Einfachheit des Setups | 5 | 5 | 3 | 15 |
| 8. Lernfaktor | 5 | 5 | 3 | 15 |
|-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
| *Total* | | | | 275 |
|-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------|
2018-12-22 00:40:03 +01:00
#+TBLFM : @3$5=@3$2 * @3$4::@4$5=@4$2 * @4$4::@5$5=@5$2 * @5$4::@6$5=@6$2 * @6$4::@7$5=@7$2 * @7$4::@8$5=@8$2 * @8$4::@9$5=@9$2 * @9$4::@10$5=@10$2 * @10$4
2018-12-18 21:16:01 +01:00
#+TBLFM : @>$5=vsum(@3..@-1)
2018-12-23 10:07:34 +01:00
*** Ergebnis
2018-12-10 21:16:57 +01:00
2018-12-22 13:53:49 +01:00
Aufgrund der erreichten Punktzahl, Tabelle:([[tab:result ]]), bei den vorhergehenden
Variantenbewertungen, wurde entschieden für das Backend der Applikation auf
2019-01-03 12:17:45 +01:00
Python zu setzen und fürs Frontend Qt zu benutzen.
2018-12-22 13:53:49 +01:00
#+CAPTION : Variantenbewertung Ergebnis
#+ATTR_LATEX : :align |>{\columncolor[HTML]{EFEFEF}}p{4.5cm}|r| :placement [H]
#+NAME : tab:result
|------------------------------------+-----------------------------------------------|
| *Variante*\cellcolor[HTML]{C0C0C0} | *Erreichte Punktzahl*\cellcolor[HTML]{C0C0C0} |
|------------------------------------+-----------------------------------------------|
| *Backend* | |
| C# | 279 |
| C++ | 271 |
| Python | 322 |
| *Frontend* | |
| Qt | 295 |
| Gtk | 275 |
| Electron | 275 |
|------------------------------------+-----------------------------------------------|
2019-01-10 20:28:10 +01:00
** Applikationsname
Da die einzusetzende Technologie nun feststeht lässt sich auch gut ein Name für
die Applikation ableiten. Oftmals werden die grafischen Applikationen gleich
benannt wie die Kommandozeilen Applikation aber mit dem Namen des gls:gui
2019-01-11 17:55:58 +01:00
Frameworks als Suffix. Somit wird das zu erstellende gls:gui für gls:borg im
2019-01-10 21:10:37 +01:00
weiteren Verlauf der Arbeit nun Borg-Qt genannt
2019-01-10 20:28:10 +01:00
** Testing
Die Anwendung wird während der Realisierung soweit als möglich mit
automatischen Unittests und Funktionstests überprüft. Dies hauptsächlich um die
Erfahrung in diesem Bereich zu erweitern und um ein gutes Fundament für die
Zukunft des Projektes zu bauen.
Aufgrund der Unerfahrenheit in diesem Bereich werden die Testfälle,
Tabelle:([[tab:testcases ]]), final jedoch von Hand überprüft. Somit kann vermieden
werden das nicht funktionierende automatische Tests den Abschluss des Projektes
2019-01-11 20:05:25 +01:00
verhindern. Da die Testfälle sich hauptsächlich an den Use Cases orientieren
gibt es ein paar Ziele die dadurch nicht getestet werden können. Zudem sind zur
Zeit nur ca. 20. der Ziele durch die Use Cases abgedeckt. Die weiteren Ziele
lassen sich erst sinnvoll integrieren wenn die Basis für das Programm
geschaffen wurde.
Die Ziele die nicht durch die Testfälle getestet werden können sind Ziel Nr. 1
und Nr. 2. Für Ziel Nr. 1 wird in der Sektion [[Realisierung ]] ein Proof of Concept
erstellt um die cross-plattform Fähigkeit zu beweisen. Ziel Nr. 2 ist mit
folgendem Link erfüllt. https://github.com/borg-qt/borg-qt/blob/master/LICENSE.
Dabei handelt es sich um die Lizenz des Borg-Qt Repository.
2019-01-10 20:28:10 +01:00
Getestet wird die Applikation jeweils auf dem Computer des Projektleiters. Auf
2019-01-10 21:10:37 +01:00
diesem läuft die aktuelle Langzeitsupport Version (18.04) von Ubuntu
2019-01-10 20:28:10 +01:00
footcite:ubuntu Linux, mit der GNOME Desktop Umgebung footcite:gnome, als
Betriebssystem. Die Tests werden jeweils gegen eine von PyInstaller generierte
Binärdatei ausgeführt. Der genaue Vorgang der Erstellung dieser Datei wird in
der Sektion: [[Releases ][Releases ]] beschrieben. Somit werden die Tests immer gegen eine
veröffentlichbare Version gemacht.
Als Testdateien wird jeweils das Code Repository von Borg-Qt selber verwendet.
Der Pfad des gls:borg Repository für lokale Backups soll ~/tmp/test-borgqt~
sein, in den Testfällen "Lokales Repository", genannt und das Passwort ~foo~ .
Im Makefile des Repository wird dieses Setup definiert. Somit kann man als
Entwickler nur ~make repo~ ausführen und hat eine funktionsfähige Testumgebung.
Um Backups über SSH testen zu können wird eine virtuelle Maschine mit Ubuntu
18.04 verwendet. Die Konfiguration der virtuellen Maschine sieht dabei wie
folgt aus:
- 2 CPU Kerne
- 1024 MB RAM
- IP: 10.7.89.117
- Ein User ~borg~ mit Passwort ~borg~
- gls:borg Repository unter ~/home/borg/backup/diplom~ mit Passwort ~foo~ , in
den Testfällen "Server Repository" genannt
- Der SSH Key des Entwicklers wird in den User ~borg~ importiert. Dies
ermöglicht Passwort freie Logins.
2018-12-10 21:16:57 +01:00
2019-02-27 21:55:48 +01:00
Die Testfälle werden während der Entwicklung kontinuierlich durchgeführt. Am
Ende der Diplomarbeit wird das finale Ergebnis des jeweiligen Testfalles
erfasst. Allfällige Besonderheiten werden im Kapitel [[Realisierung ][Realisierung ]]
beschrieben.
2019-01-10 20:28:10 +01:00
#+LATEX :\newpage
#+LATEX :\begin{landscape}
2019-02-27 21:55:48 +01:00
** TODO Testfälle
2019-01-10 20:28:10 +01:00
#+LATEX :{\footnotesize
#+CAPTION : Testfälle
#+ATTR_LATEX : :environment longtable :align |>{\columncolor[HTML]{EFEFEF}}l|p{2cm}|p{2cm}|p{3.5cm}|p{2cm}|p{3cm}|p{3.5cm}|p{2.5cm}| :placement [H]
#+NAME : tab:testcases
2019-02-27 21:55:48 +01:00
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| <20> | <10> | <10> | <10> | <10> | <10> | <10> | <10> |
| *ID*\cellcolor[HTML]{C0C0C0} | *Objective*\cellcolor[HTML]{C0C0C0} | *Precondition*\cellcolor[HTML]{C0C0C0} | *Steps*\cellcolor[HTML]{C0C0C0} | *Testdata*\cellcolor[HTML]{C0C0C0} | *Expected Result*\cellcolor[HTML]{C0C0C0} | *Postcondition*\cellcolor[HTML]{C0C0C0} | *Result*\cellcolor[HTML]{C0C0C0} |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-01* | Anwendung starten | Lokales Repository initialisiert.\newline Lokale Konfigurationsdatei erstellt. | 1. Anwendung starten. | - | Die Anwendung startet ohne Fehlermeldung und zeigt eine leere Backup Liste an. | Die Anwendung wird angezeigt. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-02* | Anwendung starten | Lokale Konfigurationsdatei erstellt. | 1. Anwendung starten. | - | Die Anwendung wirft eine Fehlermeldung das sie das lokale Repository nicht finden kann. | Die geöffnete Fehlermeldung blockiert die Applikation. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-03* | Anwendung starten | - | 1. Anwendung starten. | - | Die wirft eine Fehlermeldung das sie die Konfigurationsdatei nicht finden kann. | Die geöffnete Fehlermeldung blockiert die Applikation. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-04* | Lokales Backup erstellen | TC-01 ausgeführt. | 1. In der Ordnerübersicht das Code Repository auswählen.\newline 2. Den Button “Backup” betätigen. | Testdateien | Die Anwendung zeigt einen Fortschrittsbalken der nach erfolgtem Backup verschwindet. | Die Backup Liste wird aktualisiert und zeigt ein Backup an. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-05* | Lokales Backup erstellen | TC-01 ausgeführt.\newline BorgBackup macht bereits ein Backup. | 1. In der Ordnerübersicht das Code Repository auswählen.\newline 2. Den Button “Backup” betätigen. | Testdateien | Die Anwendung wirft eine Fehlermeldung das BorgBackup bereits ausgeführt wird. | Die geöffnete Fehlermeldung blockiert die Applikation. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-06* | Lokales Backup erstellen | TC-01 ausgeführt. | 1. Das Lokale Repository an einen beliebigen Ort verschieben.\newline 2. In der Ordnerübersicht das Code Repository auswählen.\newline 3. Den Button “Backup” betätigen. | Testdateien | Die Anwendung wirft eine Fehlermeldung das sie das lokale Repository nicht finden kann. | Die geöffnete Fehlermeldung blockiert die Applikation. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-07* | Lokales Backup erstellen | TC-01 ausgeführt. | 1. Den Button “Backup” betätigen. | - | Die Anwendung wirft eine Fehlermeldung das der User einen Pfad angeben soll. | Die geöffnete Fehlermeldung blockiert die Applikation. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-08* | Lokales Backup löschen | TC-04 ausgeführt. | 1. In der Backup Liste das Backup auswählen.\newline 2. Den Button “Delete” betätigen. | - | Die Anwendung zeigt einen Fortschrittsbalken der nach erfolgtem Löschen verschwindet. | Die Backup Liste wird aktualisiert und ist nun leer. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-09* | Lokales Backup löschen | TC-04 ausgeführt. | 1. Das Lokale Repository an einen beliebigen Ort verschieben.\newline 2. In der Backup Liste das Backup auswählen.\newline 3. Den Button “Delete” betätigen. | - | Die Anwendung wirft eine Fehlermeldung das sie das lokale Repository nicht finden kann. | Die geöffnete Fehlermeldung blockiert die Applikation. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-10* | Lokales Backup löschen | TC-04 ausgeführt. | 1. Den Button “Delete” betätigen. | - | Die Anwendung wirft eine Fehlermeldung das der User ein Backup auswählen soll. | Die geöffnete Fehlermeldung blockiert die Applikation. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-11* | Lokales Backup wiederherstellen | TC-04 ausgeführt. | 1. In der Backup Liste das Backup auswählen.\newline 2. Den Button “Restore” betätigen.\newline 3. Im geöffneten Dateidialog den Pfad "/home/andreas/Downloads" auswählen.\newline 4. Den Button “Open” anklicken. | - | Nach erfolgtem Wiederherstellen öffnet ein Dateiexplorer den Ziel Pfad. | Die Anwendung und ein Dateiexplorer wird angezeigt. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-12* | Lokales Backup wiederherstellen | TC-01 ausgeführt. | 1. Den Button “Backup” betätigen. | - | Die Anwendung wirft eine Fehlermeldung das der User ein Backup auswählen soll. | Die geöffnete Fehlermeldung blockiert die Applikation. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-13* | Lokales Backup wiederherstellen | TC-01 ausgeführt. | 1. Das Lokale Repository an einen beliebigen Ort verschieben.\newline 2. In der Backup Liste das Backup auswählen.\newline 3. Den Button “Restore” betätigen. | - | Die Anwendung wirft eine Fehlermeldung das sie das lokale Repository nicht finden kann. | Die geöffnete Fehlermeldung blockiert die Applikation. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-14* | Lokales Backup wiederherstellen | TC-01 ausgeführt. | 1. In der Backup Liste das Backup auswählen.\newline 2. Den Button “Restore” betätigen.\newline 3. Im geöffneten Dateidialog den Pfad "/home/andreas/Downloads" auswählen.\newline 4. Den Button “Cancel” anklicken. | - | Der Datei Dialog schliesst sich wieder. | Die Anwendung wird angezeigt. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-15* | Home Directory sichern und wiederherstellen | TC-01 ausgeführt. | 1. Vom Pfad "/home/andreas/" ein Backup erstellen.\newline 2. In der Backup Liste das gemachte Backup auswählen.\newline 3. Den Button “Restore” betätigen.\newline 4. Im geöffneten Dateidialog den Pfad "/home/andreas/Downloads" auswählen.\newline 5. Den Button “Open” anklicken. | "/home/andreas/" | Nach erfolgtem Wiederherstellen öffnet ein Dateiexplorer den Ziel Pfad.\newline Darin fehlen jedoch temporäre Pfade wie “~/.cache” etc. | Die Anwendung und ein Dateiexplorer wird angezeigt. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-16* | Einzelne Datei wiederherstellen | TC-04 ausgeführt. | 1. In der Backup Liste das Backup auswählen.\newline 2. Den Button “Mount” betätigen.\newline 3. Aus dem sich öffnenden Dateiexplorer die Datei README.org nach "/home/andreas/Downloads" kopieren. | - | Die wiederhergestellte Datei ist identisch mit der in TC-04 gesicherten. | Die Anwendung und ein Dateiexplorer wird angezeigt. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-17* | Einzelne Datei wiederherstellen | TC-01 ausgeführt. | 1. Das Lokale Repository an einen beliebigen Ort verschieben.\newline 2. In der Backup Liste das Backup auswählen.\newline 3. Den Button “Mount” betätigen. | - | Die Anwendung wirft eine Fehlermeldung das sie das lokale Repository nicht finden kann. | Die geöffnete Fehlermeldung blockiert die Applikation. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-18* | Pfad des lokalen Backup Repository anpassen | TC-04 ausgeführt.\newline Backup Repository nach "/tmp/test-borgqt2" verschoben | 1. Den Button "Settings" betätigen.\newline 2. Den Repository Pfad auf "/tmp/test-borgqt2/" ändern.\newline 3. Den Button "Apply" betätigen. | - | Die Backup Liste wird aktualisiert und zeigt wieder das Backup von TC-04 an. | Die Anwendung wird angezeigt. Die Konfigurationsdatei zeigt auf den neuen Pfad. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-19* | Backup Name ändern | TC-01 ausgeführt. | 1. Den Button "Settings" betätigen.\newline 2. Bei der Option "Archive Prefix" "Muster" eintragen.\newline 3. Den Button "Apply" betätigen.\newline 4. TC-04 durchführen. | Backupname: Muster | Die Anwendung zeigt einen Fortschrittsbalken der nach erfolgtem Backup verschwindet. | Die Backup Liste wird aktualisiert und zeigt ein Backup mit dem Präfix "Muster" an. Die Konfigurationsdatei beinhaltet die Option des Präfixes. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-20* | Keine Einstellungen ändern | TC-01 ausgeführt. | 1. Den Button "Settings" betätigen.\newline 2. Eine beliebige Option ändern.\newline 3. Den Button "Cancel" betätigen. | - | Der Einstellungsdialog schliesst sich. | Die Anwendung wird angezeigt. Die Konfigurationsdatei ist noch im selben Zustand wie bei TC-01. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-21* | Automatische Backups konfigurieren | TC-01 ausgeführt. | 1. Den Button "Settings" betätigen.\newline 2. Bei der Option "Automatic Backups" bei "Backup Path" die Testdateien angeben sowie "Hourly" auswählen und bei "Time" die nächste Stunde angeben.\newline 3. Den Button Apply betätigen. | Backup-zeit: 2 Minuten nach aktueller Zeit Testdateien | Der Datei Dialog schliesst sich wieder. | Die Anwendung wird angezeigt. Die Konfigurationsdatei wurde um die Option des automatischen Backups erweitert. Die Anwendung hat einen "Service" auf dem System erstellt. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-22* | Automatische Backups durchführen | TC-16 ausgeführt. | 1. TC-21 durchführen.\newline 2. Auf Ablauf der Zeit warten.\newline 3. Die Anwendung öffnen. | - | In der Backup Liste wird ein Backup angezeigt. | Die Anwendung wird angezeigt. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-23* | Server Backup erstellen | Server Repository bereit.\newline Server Konfigurationsdatei erstellt. | TC-04 durchführen. | Testdateien | Die Anwendung zeigt einen Fortschrittsbalken der nach erfolgtem Backup verschwindet. | Die Backup Liste wird aktualisiert und zeigt ein Backup an. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-24* | Lokales Backup erstellen während dem eine VM läuft | TC-01 ausgeführt.\newline Virtualbox VM Starten. | 1. In der Ordnerübersicht das Code Repository auswählen.\newline 2. Den Button “Backup” betätigen. | Testdateien | Die Anwendung wirft eine Fehlermeldung aus das es zur Zeit aufgrund einer laufenden VM unsicher sei ein Backup durchzuführen. | Die geöffnete Fehlermeldung blockiert die Applikation. | Nicht implementiert |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
| *TC-25* | Abgebrochenes Backup bereinigen | TC-01 ausgeführt. | 1. In der Ordnerübersicht das Code Repository auswählen.\newline 2. Den Button “Backup” betätigen.\newline 3. Die Anwendung schliessen.\newline 4. Anwendung wieder öffnen.\newline 5. TC-04 Durchführen. | Testdateien | Bei Schritt 4. sollte ein Teilbackup zu sehen sein.\newline Bei Schritt 5 sollte einfach ein normales Backup zu sehen sein. | Die Anwendung wird angezeigt. | Erfolgreich durchgeführt 25.02.2019 A.Z. |
|------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------|
2019-01-10 20:28:10 +01:00
#+LATEX :}
#+LATEX :\end{landscape}
#+LATEX :\newpage
2019-03-02 10:57:16 +01:00
** Klassendiagramm
Um die Abhängigkeiten zwischen den einzelnen Klassen der Anwendung aufzuzeigen
wurde ein Klassendiagramm, Abbildung:([[fig:class_diagramm ]]), erstellt. Das
Klassendiagramm basiert auf dem UML Standard. Im Diagramm wurden nicht alle
"Properties" und Methoden alles Klassen aufgezeichnet sondern nur solche die
auf eine andere Klasse verweisen. Dadurch bleibt das Diagramm übersichtlicher.
2018-12-10 21:16:57 +01:00
2019-02-27 21:55:48 +01:00
** Benutzerfreundlichkeitsstudie
2019-01-15 21:16:30 +01:00
Um Borg-Qt auf seine Nutzerfreundlichkeit zu testen wird im Rahmen der
Diplomarbeit noch eine kleine Benutzerfreundlichkeitsstudie gemacht. Bei einer
2019-02-27 21:55:48 +01:00
solchen Studie erhalten die Probanden, Tabelle:([[tab:probanden ]]) ein paar
2019-01-15 21:16:30 +01:00
Aufgaben, abgebildet in der Sektion [[Aufgaben ]], welche sie in einer begrenzten
Zeit zu erledigen haben. Die Aufsichtsperson gibt ihnen dabei keinerlei
2019-02-27 21:55:48 +01:00
Hilfestellungen. Die Probanden sollen die Aufgaben alleine mit Hilfe der Tipps
und Hinweisen in der Anwendung lössen. Im Anschluss bewerten die Probanden dann
2019-01-15 21:16:30 +01:00
die einzelnen Aufgaben nach ihrer Schwierigkeit,
Tabelle:([[tab:usability_colours ]]). Daraus lässt sich dann eine sogenannte Heatmap
erstellen. Aus der Heatmap kann man anschaulich herauslesen welche Bereiche für
die User noch zu kompliziert sind und Nacharbeit benötigen.
2019-02-27 21:55:48 +01:00
Die Propanden wurden aus dem Umfeld des Projektleiters ausgewählt. Es wurde
dabei versucht ein einigermassen breites Spektrum an Computerkenntnissen
abzudecken die Anwendung allen Erfahrungsstufen behilflich sein soll. Die
Angaben in der Tabelle:([[tab:probanden ]]) sind jedoch die Selbsteinschätzung der
Probanden und nicht die des Projektleiters zum jweiligen Tester.
#+CAPTION : Benutzerfreundlichkeitsstudie Probanden
2019-01-15 21:16:30 +01:00
#+ATTR_LATEX : :align |>{\columncolor[HTML]{EFEFEF}}r|c|c|c|c| :placement [H]
2019-02-27 21:55:48 +01:00
#+NAME : tab:probanden
2019-01-15 21:16:30 +01:00
|-------------------------------+--------------------------------------+---------------------------------+----------------------------------------------+----------------------------------------------|
| *Nr.*\cellcolor[HTML]{C0C0C0} | *Geschlecht*\cellcolor[HTML]{C0C0C0} | *Alter*\cellcolor[HTML]{C0C0C0} | *Englischkenntnisse*\cellcolor[HTML]{C0C0C0} | *Computerkenntnisse*\cellcolor[HTML]{C0C0C0} |
|-------------------------------+--------------------------------------+---------------------------------+----------------------------------------------+----------------------------------------------|
| 1 | Männlich | 30 | Sehr gut | Sehr gut |
|-------------------------------+--------------------------------------+---------------------------------+----------------------------------------------+----------------------------------------------|
2019-02-27 21:55:48 +01:00
| 2 | Männlich | 26 | Gut | Sehr gut |
2019-01-15 21:16:30 +01:00
|-------------------------------+--------------------------------------+---------------------------------+----------------------------------------------+----------------------------------------------|
2019-02-27 21:55:48 +01:00
| 3 | Männlich | 26 | Gut | Mittel |
2019-01-15 21:16:30 +01:00
|-------------------------------+--------------------------------------+---------------------------------+----------------------------------------------+----------------------------------------------|
2019-02-27 21:55:48 +01:00
| 4 | Männlich | 34 | Mässig | Mittel |
2019-01-15 21:16:30 +01:00
|-------------------------------+--------------------------------------+---------------------------------+----------------------------------------------+----------------------------------------------|
2019-02-27 21:55:48 +01:00
| 5 | Weiblich | 26 | Gut | Mittel |
2019-01-15 21:16:30 +01:00
|-------------------------------+--------------------------------------+---------------------------------+----------------------------------------------+----------------------------------------------|
#+CAPTION : Benutzerfreundlichkeitsstudie Bewertungsraster
#+ATTR_LATEX : :align |l|l| :placement [H]
#+NAME : tab:usability_colours
|-----------------------------------+---------------------------------------|
| *Grün*\cellcolor[HTML]{4CAF50} | Die Aufgabe war sehr einfach. |
|-----------------------------------+---------------------------------------|
| *Gelb*\cellcolor[HTML]{FFEB3B} | Die Aufgabe war etwas herausfordernd. |
|-----------------------------------+---------------------------------------|
| *Orange*\cellcolor[HTML]{FF9800} | Die Aufgabe war schwierig. |
|-----------------------------------+---------------------------------------|
| *Rot*\cellcolor[HTML]{f44336} | Die Aufgabe war sehr schwierig. |
|-----------------------------------+---------------------------------------|
| *Schwarz*\cellcolor[HTML]{424242} | Die Aufgabe war unlösbar. |
|-----------------------------------+---------------------------------------|
*** Aufgaben
1. Du möchtest deine Dateien sichern. Erstelle dazu eine Datensicherung des Ordners ~/home/testuser/Downloads~ .
2. Du hast aus versehen die Datei ~/home/testuser/Downloads/Example.pdf~
gelöscht. Stelle die Datei wieder her. Am Ende soll sie unter
~/home/testuser/Documents/Example.pdf~ zu finden sein.
3. Stelle ein beliebiges Archiv wieder her. Der Zielpfad ist ~/home/testuser/Documents/~ .
4. Lösche ein Archiv deiner Wahl.
5. Du möchtest das der Ordner ~/home/testuser/Pictures/~ nicht mehr gesichert
wird. Konfiguriere die Applikation entsprechend.
*** Resultate
#+CAPTION : Benutzerfreundlichkeitsstudie Resultate
#+ATTR_LATEX : :environment longtable :align |>{\columncolor[HTML]{EFEFEF}}l|l|l|l|l|l| :placement [H]
#+NAME : tab:usability_result
2019-02-27 21:55:48 +01:00
|--------------------------------+-------------------------------------+-------------------------------------+-------------------------------------+-------------------------------------+---------------------------------------|
| *Test*\cellcolor[HTML]{C0C0C0} | *Proband 1*\cellcolor[HTML]{C0C0C0} | *Proband 2*\cellcolor[HTML]{C0C0C0} | *Proband 3*\cellcolor[HTML]{C0C0C0} | *Proband 4*\cellcolor[HTML]{C0C0C0} | *Probandin 5*\cellcolor[HTML]{C0C0C0} |
|--------------------------------+-------------------------------------+-------------------------------------+-------------------------------------+-------------------------------------+---------------------------------------|
| 1. | \cellcolor[HTML]{4CAF50} | \cellcolor[HTML]{4CAF50} | \cellcolor[HTML]{FFEB3B} | \cellcolor[HTML]{4CAF50} | \cellcolor[HTML]{4CAF50} |
|--------------------------------+-------------------------------------+-------------------------------------+-------------------------------------+-------------------------------------+---------------------------------------|
| 2. | \cellcolor[HTML]{FFEB3B} | \cellcolor[HTML]{FFEB3B} | \cellcolor[HTML]{FF9800} | \cellcolor[HTML]{FF9800} | \cellcolor[HTML]{FF9800} |
|--------------------------------+-------------------------------------+-------------------------------------+-------------------------------------+-------------------------------------+---------------------------------------|
| 3. | \cellcolor[HTML]{4CAF50} | \cellcolor[HTML]{FFEB3B} | \cellcolor[HTML]{4CAF50} | \cellcolor[HTML]{4CAF50} | \cellcolor[HTML]{4CAF50} |
|--------------------------------+-------------------------------------+-------------------------------------+-------------------------------------+-------------------------------------+---------------------------------------|
| 4. | \cellcolor[HTML]{4CAF50} | \cellcolor[HTML]{4CAF50} | \cellcolor[HTML]{4CAF50} | \cellcolor[HTML]{4CAF50} | \cellcolor[HTML]{4CAF50} |
|--------------------------------+-------------------------------------+-------------------------------------+-------------------------------------+-------------------------------------+---------------------------------------|
| 5. | \cellcolor[HTML]{4CAF50} | \cellcolor[HTML]{FFEB3B} | \cellcolor[HTML]{FF9800} | \cellcolor[HTML]{FFEB3B} | \cellcolor[HTML]{FFEB3B} |
|--------------------------------+-------------------------------------+-------------------------------------+-------------------------------------+-------------------------------------+---------------------------------------|
**** Proband 1
Der Proband fand die Aufgaben grundsätzlich einfach zu lösen. Das die "Mount"
Funktion zum Wiederherstellen einzelner Dateien gedacht war hat er nicht
erkannt.
**** Proband 2
Der Proband kam mit den Aufgaben insgesamt gut klar. Bei der ersten Aufgabe
hätte er sich eine Meldung gewünscht wenn das Backup erfolgreich durchgelaufen
ist. Wie Proband 1 hat auch er die "Mount" Funktion nicht genutzt zum
wiederherstellen einer einzelnen Datei. Text Hinweise wurden nur bedingt
wahrgenommen.
**** Proband 3
Proband 3 kam mit der Anwendung an sich gut klar. Bei der Aufgabe zwei wurde
noch ein Bug entdeckt der näher untersucht werden muss. Die Aufgabe zwei fand
er über alles gesehen auch am schwierigsten da er mit der Materie nahezu nicht
vertraut ist. Als zusätzlichen Input gab er an das ein Kontextmenü welches sich
mit Rechtsklick auf ein Element öffnet etwas sei was er gerne hätte da er
andere Anwendungen oft so steuert. Aufgabe 5 war auch etwas herausfordernder
als 1,3 und 4 insbesondere war unklar wie der Ordner zu der Liste hinzugefügt
werden sollte.
**** Proband 4
Bei Proband 4 war die grösste Hürde dass, das Interface nur in English
verfügbar war. Bei Aufgabe zwei hat er sich nach eigenen Angaben etwas verloren
gefühlt und hätte sich auch ein Kontextmenü auf dem Rechtsklick gewünscht.
Mit etwas Hilfe bei der Übersetzung waren die restlichen Aufgaben jedoch gut zu
meistern.
**** Probandin 5
Probandin 5 mit der Anwendung insgesamt sehr gut klar und hat auch als Einzige
die Tooltips auf den Buttons entdeckt und dann genutzt. Aufgabe 2 war jedoch
auch schwierig zu lösen danach ging es jedoch ohne Probleme. Als Feedback wurde
genannt, dass 21:00 Uhr etwas spät für solche Tests sei.
*** TODO Auswertung
Nach den 5 Tests liess sich feststellen das die Anwendung für die Anwender
insgesamt einfach zu bedienen ist sobald sie einmal wissen welche Buttons
welche Aktion auslösen und wie sich die Anwendung verhält. Um Hilfestellung zu
leisten wird im Rahmen der Diplomarbeit noch ein Hilfefenster eingebaut welches
den Benutzern beim ersten Starten der Anwendung angezeigt wird und kurz die
jeweiligen Elemente des Interfaces anzeigt. Somit sollte auch das Problem bei
der Aufgabe zwei etwas abgeschwächt werden. Eines der Hauptprobleme war dort
das die Probanden nicht herausgefunden haben der schnellste Weg eine einzelne
Datei wieder herzustellen über die "Mount" Funktion ginge. Die Einarbeitung in
die Thematik von Backups würde sich jedoch wohl nur sehr schwer über das
gls:gui realisieren lassen. Hier müsste auf jeden Fall eine Dokumentation oder
im Idealfall ein Schulung Abhilfe schaffen.
Das Kontextmenü auf dem Rechtsklick welches von zwei Usern gewünscht worden
ist, ist eine sehr gute Idee und sollte sich auch realisieren lassen. Dieses
Feature wird nicht im Rahmen der Diplomarbeit umgesetzt und für die zukünftige
Entwicklung aufgenommen.
Ein Dialog welcher ein erfolgreiches Erstellen eines Archives bestätigt wird
nicht eingebaut. Bei erfolgreicher Durchführung verschwindet der
Fortschrittsdialog und in der Archivlist erscheint ein weiterer Eintrag. Das
sind zwar nicht die offensichtlichsten Hinweise im Falle eines Fehlers
erscheint jedoch sofort ein Dialog der darauf hinweist. Somit sollten die
beiden Vorgänge genügend unterschieden sein und es hat auch kein andere Proband
das Bedürfnis nach einer Bestätigung.
Auch für die Zukunft wird eine deutsche Übersetzung geplant. Dies würde die
Anwendung dann vor allem Leuten mit weniger guten Englisch Kenntnissen
zugänglich machen.
Im Rahmen der Diplomarbeit werden noch einige Texte angepasst. An gewissen
Stellen redet die Anwendung von "Backups" und an anderen von "Archives". Da
gls:borg sie selber "Archives" nennt sollte Borg-Qt noch so angepasst werden
das überall von "Archives" die Rede ist. Zudem wird bei den "Include" und
"Exclude" Optionen über der Liste noch ein Label hinzugefügt um die Elemente zu
beschreiben. Desweiteren werden die Buttons "Add file" und "Add folder" zu
"Exclude file" und "Exclude folder" sowie "Include file" und "Include folder"
umbenannt. Somit zeigen die Buttons dann auch direkt das sie Dateien respektive
Ordner ein-/auschliessen. Ein paar der Probanden hatten es zuerst über den
"Remove" Button versucht.
Der Bug der entdeckt wurde tritt immer dann auf wenn ein Archiv gemountet
ist und man ein Backup erstellen möchte. Dies ist jedoch offenbar eine Funktion
die von gls:borg nicht unterstützt wird footcite:borgmount. gls:borg könnte
eigentlich mehrere Archive gleichzeitig mounten. Der User müsste jedoch jedes
der Archive zuerst wieder unmounten bevor er eine neue Datensicherung erstellen
kann. Die genaue Lösung wird dann in der [[UI Anpassungen nach Benutzerfreundlichkeitsstudie ][Realisierung ]] beschrieben.
Insgesamt war der Test eine sehr interessante Erfahrung. Enduser sehen eine
Anwendung mit ganz anderen Augen als der Entwickler der Anwendung der von jedem
Element weiss wie der Code dazu aussieht. Er hat auch gezeigt das die Aufgaben
auch richtig gestellt werden müssen ansonsten wissen die Probanden schon gar
nicht erst was gefordert ist. Auch sollte wenn möglich darauf geachtet werden
das auf einem Betriebsystem getestet mit welchem die Probanden bereits etwas
Erfahrung haben. Zwei der Probanden waren ab dem Verhalten und Aussehen des
Dateimanagers von Ubuntu 18.04 etwas verwirrt da sie ihn zuvor noch nicht
gesehen und bentuzt hatten.
2019-01-15 21:16:30 +01:00
2018-12-24 15:53:54 +01:00
* TODO Realisierung
2019-01-14 10:41:31 +01:00
** Cross-plattform Kompatibilität
2019-01-03 12:17:45 +01:00
Um sicherzugehen das die gewählten Technologien auch den Anforderungen
entsprechen wurde ein kleines "Hello World" Programm mit Python3 und Qt
geschrieben. Dieses läuft ohne jegliche Probleme und Anpassung auf Windows,
Linux und OS X. Wie in den Screenshots in Abbildung:([[fig:hello_world ]]) zu sehen
ist.
#+caption : Python und Qt Applikation unter Windows (links), Linux (rechts) und OS X (unten)
#+name : fig:hello_world
[[file:pictures/hello_world.png ]]
#+attr_latex : :center
2019-02-27 21:55:48 +01:00
** Benutzerinterface
2019-01-14 10:40:59 +01:00
*** Inspiration
Bevor gls:borg vom Projektleiter als Backup Software eingesetzt wurde, nutzte
er die Software "Back in Time"footcite:backintime. Die Software setzt auf Rsync
zum kopieren der Dateien. Dies erlaubt auch schnelle Backups über SSH zu
machen. "Back in Time" hat allerdings das Problem, dass es keine gls:dedup
beherrscht.
Das Userinterface, zu sehen in Abbildung:([[fig:bit_main ]]), ist jedoch sehr
gelungen und soll Borg-Qt als Vorlage dienen. Insbesondere die einfache und
direkte Art ein Backup eines spezifischen Pfades zu machen ist sehr spannend.
Da sie es dem User so einfach wie möglich macht ein Backup zu erstellen.
#+caption : Screenshot des Hauptfensters der Software "Back in Time"
#+name : fig:bit_main
[[file:pictures/bit_main.png ]]
#+attr_latex : :center
2018-12-10 21:16:57 +01:00
2019-02-27 21:55:48 +01:00
*** Erste Umsetzung
2018-12-10 21:16:57 +01:00
2019-01-15 21:09:59 +01:00
Qt bietet einem mehrere Möglichkeiten zum erstellen der graphischen Oberfläche.
Zum einen kann die ganze Oberfläche programmatisch erstellt werden. Dies gibt
dem ein grosses Mass an Kontrolle über das Erstellte ist allerdings nicht sehr
intuitiv.
Die angenehmere Variante ist des den Qt Designer, Abbildung:([[fig:qt_designer ]]),
zu nutzen. Mit diesem lassen sich die Oberflächen in einer graphischen
Oberfläche designen und mit einem Befehl auch gleich starten damit man direkt
sieht wie sich die Oberflächen auf dem System verhalten.
#+caption : Ein Screenshot der Applikation Qt Designer
#+name : fig:qt_designer
[[file:pictures/qt_designer.png ]]
#+attr_latex : :center
2018-12-10 21:16:57 +01:00
2019-01-15 21:09:59 +01:00
Auf Basis der Ziele und der Use Cases wurde eine erste Version des glspl:gui
erstellt. Im Hauptfenster, Abbildung:([[fig:borgqt_main_v1 ]]), befinden sich wie
auch bei "Back in Time" in der einen Hälfte eine Liste der vorhandenen Backups
(bei Borg Archive genannt) und in der anderen Hälfte ein Dateimanagemer. Dieser
dient zur Auswahl des zu sichernden Pfades. Im oberen Bereich findet sich die
Toolbar mit den Aktionen die der User ausführen kann. Gemäss den Use Cases sind
dies "Backup", "Restore", "Mount", "Delete" und "Settings".
2019-02-27 21:55:48 +01:00
Bei den Icons wurde zuerst versucht nach der "Icon Naming
Specification"footcite:iconnamespec auszuwählen. Diese Spezifikationen würden
es erlauben einfach den definierten Namen des Icons anzugeben. Qt würde dann
jeweils das passende Icon basierend auf dem System anzeigen. Somit wären die
Icons passend zum jeweiligen Betriebssystem. Allerdings gab es für die Aktionen
keine passenden Icons in der Spezifikation. Deshalb wurden schlussendlich das
"Feather" Icon Theme Set ausgewählt. Dabei handelt es sich um ein freies Icon
Theme unter der MIT Lizenz welches SVG Dateien bereit stellt. Dadurch können
die Icons frei skalieren und funktionieren auch auf Geräten mit einer hohen
Auflösung.
2019-01-15 21:09:59 +01:00
#+caption : Screenshot des Borg-Qt Hauptfensters Version 1
#+name : fig:borgqt_main_v1
#+attr_latex : :placement [H]
[[file:pictures/borgqt_main_v1.png ]]
2019-02-27 21:55:48 +01:00
Im Einstellungsfenster gibt es drei Tabs zur Auswahl. Einmal den "General" Tab,
2019-01-15 21:09:59 +01:00
Abbildung:([[fig:borgqt_settings_general_v1 ]]), dieser zeigt allgemeine Optionen
2019-02-27 21:55:48 +01:00
an. Im zweiten Tab "Include", Abbildung:([[fig:borgqt_settings_include_v1 ]]), kann
der User die Ordner und Dateien auswählen die er sichern will. Der dritte Tab
"Exlcude", Abbildung:([[fig:borgqt_settings_exclude_v1 ]]), gibt dem User die
Möglichkeit einzelne Ordner oder Dateien von den Backups auszuschliessen.
2019-01-15 21:09:59 +01:00
#+caption : Screenshot der Borg-Qt "General" Einstellungen Version 1
#+name : fig:borgqt_settings_general_v1
#+attr_latex : :width .7\textwidth :placement [H]
[[file:pictures/borgqt_settings_general_v1.png ]]
2019-02-27 21:55:48 +01:00
#+caption : Screenshot der Borg-Qt "Include" Einstellungen Version 1
#+name : fig:borgqt_settings_include_v1
#+attr_latex : :width .7\textwidth :placement [H]
[[file:pictures/borgqt_settings_include_v1.png ]]
2019-01-15 21:09:59 +01:00
#+caption : Screenshot der Borg-Qt "Exclude" Einstellungen Version 1
#+name : fig:borgqt_settings_exclude_v1
#+attr_latex : :width .7\textwidth :placement [H]
[[file:pictures/borgqt_settings_exclude_v1.png ]]
Das "Progress" Dialogfenster, Abbildung:([[fig:borgqt_progress_v1 ]]), zeigt dem
User einen Fortschrittsbalken und einen einen "Cancel" Button zum Abbrechen der
Aktion an. Das Fenster ist generisch gehalten damit es von verschiedenen Tasks
gleichermassen genutzt werden kann.
#+caption : Screenshot des Borg-Qt "Progress" Dialogfensters Version 1
#+name : fig:borgqt_progress_v1
#+attr_latex : :width .6\textwidth :placement [H]
[[file:pictures/borgqt_progress_v1.png ]]
Im "Archive" Dialogfenster, Abbildung:([[fig:borgqt_archiv_v1 ]]), werden
Detailinformationen eines Archives angezeigt. Diese sind etwa die Grösse des
Archives, wieviele Dateien es beinhaltet, wie lange das Erstellen dauerte, etc.
#+caption : Screenshot des Borg-Qt Archivinformationsfenster Version 1
#+name : fig:borgqt_archiv_v1
#+attr_latex : :width .6\textwidth :placement [H]
[[file:pictures/borgqt_archive_v1.png ]]
2018-12-10 21:16:57 +01:00
2019-02-27 21:55:48 +01:00
** Einstellungen
2018-12-10 21:16:57 +01:00
2019-02-27 21:55:48 +01:00
Die Einstellungen werden von der Applikation benötigt um die vom User
definierten Vorgaben auszuführen, Das Backup Repository zu finden, etc.
Diese Einstellungen sollen in einer Klar-Text Datei gespeichert werden. Dies
hat zum einen den Vorteil das man die Einstellungen sehr einfach sicher kann,
zum anderen kann man die Einstellungen der Applikation auch anpassen ohne das
man die Applikation selber starten muss.
*** Backend
2018-12-10 21:16:57 +01:00
2019-02-27 21:55:48 +01:00
Zum Erstellen und Auslesen der Konfigurationsdatei wurde das Python Standard
Modul ~configparser~ footcite:configparser verwendet. Dieses macht es einem
sehr einfach eine Datei im "INI" Stil zu erstellen und parsen.
"INI" Stil bedeutet dabei das die Einstellungen in "Key/Value" Paaren
gespeichert werden. Somit kann man einfach auf den benötigten Wert zugreifen in
dem man seinen Schlüssel angibt. Ein Beispiel ist im Code Snippet:
([[code:ini_file ]]) zu sehen.
#+caption : Ein Beispiel einer INI Datei.
#+name : code:ini_file
#+begin_src bash
# docs/borg_qt.conf.example
[borgqt]
includes = [
"/home/username/ ",
"/home/otheruser/Downloads"
]
repository_path = /tmp/test-borgqt
password = foo
prefix = muster
#+end_src
Das Auslesen und schreiben der Konfigurationsdatei liess sicher relativ einfach
realisieren. Die grösste Herausforderung dabei war, das ~Configparser~ keinen
Support für eine Liste von Werten hat. Die wurde insbesondere für ~include~ und
~exclude~ Pfade benötigt. Also für die Pfade welche gesichert werden oder von
einem Backup ausgeschlossen werden sollen.
Abhilfe schafte hier ein Stackexchange Posts footcite:configlist. Dieser Schlug
vor das man die Liste im gls:json Format speichern soll. Da ~Configparser~ alle
Werte im Format "String" zurück gibt können dann die gls:json Listen sehr
einfach von einem gls:json Parser umgewandelt werden. Im Projekt wurde dies
dann unter anderem als Methode der ~Config~ Klasse, Code
Snippet:([[code:json_config ]]), implementiert. Somit muss man jeweils nur die
~_return_list_option()~ Methode mit der benötigten Option als Argument aufrufen
und bekommt als Result eine funktionierende Python Liste zurück.
Beim Schreiben der Konfigurationsdatei macht man dann einfach das Umgekehrte.
Man konvertiert eine Python Liste in einen gls:json String.
#+caption : Methode zum Parsen von JSON Listen in Konfigurationsdateien.
#+name : code:json_config
#+begin_src python
# borg_qt/config.py
def _return_list_option(self, option):
"""Reads the provided option from the configparser object and returns
it as a list."""
if option in self.config['borgqt']:
return json.loads(self.config['borgqt'][option])
else:
return []
#+end_src
Die Datei wird jeweils beim Start der Applikation gelesen und angewendet. Somit
weiss die Applikation bereits nach dem Start wo das Repository liegen sollte
und wie die Login Daten dafür sind. Dies geschiet mittels der Method
~_get_path~ , Codesnippet:([[code:config_path ]]). Es gibt dabei zwei mögliche Pfade
wo die Konfigurationsdatei liegen könnte. Befindet sich die Datei nicht am
vergegeben Pfad ~~/.config/borg_qt/borg_qt.conf~ oder direkt "neben" dem
Binary, gibt die Applikation eine entsprechende Meldung,
Abbildung:([[fig:borgqt_missing_config ]]), aus. Der Hauptfad unter
~~/.config/borg_qt/borg_qt.conf~ wird dabei gemäss dem Ziel Nr. 21 über die
Umgebungsvariabel ~HOME~ zusammengesestzt.
#+caption : Methode zum Suchen der Konfigurationsdatei
#+name : code:config_path
#+begin_src python
# borg_qt/config.py
def _get_path(self):
"""searches for the configuration file and returns its full path."""
home = os.environ['HOME']
dir_path = os.path.dirname(os.path.realpath(__file__))
if os.path.exists(os.path.join(home, '.config/borg_qt/borg_qt.conf')):
return os.path.join(home, '.config/borg_qt/borg_qt.conf')
elif os.path.exists(os.path.join(dir_path, 'borg_qt.conf')):
return os.path.join(dir_path, 'borg_qt.conf')
else:
raise BorgException("Configuration file not found!")
#+end_src
#+caption : Screenshot der Borg-Qt Fehlermeldung bei fehlender Konfigurationsdatei.
#+name : fig:borgqt_missing_config
#+attr_latex : :width .3\textwidth :placement [H]
[[file:pictures/borgqt_missing_config.png ]]
*** Frontend
Um es für die User einfacher zu machen wurde beschlossen die Applikation
um eine grafische Konfigurationsmöglichkeit zu erweitern. Diese stellt dabei
hauptsächlich die Werte aus der Konfigurationsdatei grafisch dar und übergibt
allenfalls geänderte Werte ans Backend welches die Konfiguration dann wieder in
der Datei speichert.
Das Meiste davon ist nicht besonders aufregender Code da hauptsächlich nur die
Werte aus der Konfigurationsdatei in die entsprechenden Textfelder und Listen
im grafischen Interface geschrieben werden auch beim Speichern der geänderten
Einzel-Werte funktioniert es in etwa gleich. Beim Speichern der geänderten
Listen jedoch trat eine weitere Herausforderung auf.
Qt kennt keinen Mechanismus zum auslesen aller Elemente aus einem sogenannten
~QListWidget~ , einem UI Element welches Liste darstellt. Somit ist es nötig das
man die Elemente zuerst in einer Zwischenliste speichert bevor man sie zurück
in das ~Configparser~ Objekt schreiben kann. Im Code sieht dies dann wie in
Codesnippet:([[code:qlistwidgets_items ]]) aus. Dabei wird jedes Element einzeln aus
dem ~QListWidget~ geholt und in die Zwischenliste geschoben. Im zweiten Teil
wird die Liste dann wieder zu einem gls:json String konvertiert und im
~Configparser~ Objekt gespeichert. Die Option ~indent=4~ dient dabei der
Lesbarkeit damit nicht der ganze gls:json String auf ein Zeile in der
Konfiguration gespeichert wird sondern jedes Listenelement seine eigene Zeile
erhält.
#+caption : Workaround zum Auslesen aller Elemente in QListWidgets.
#+name : code:qlistwidgets_items
#+begin_src python
# borg_qt/config.py
# Workaraound to get all items of a QListWidget as a list
includes = []
for index in range(self.list_include.count()):
includes.append(self.list_include.item(index).text())
# Configparser doesn't know about list therefore we store them as json
# strings
self.config['borgqt']['includes'] = json.dumps(includes,
indent=4,
sort_keys=True)
#+end_src
** Borg Interface
Für die jeweiligen Funktionen von gls:borg wurde eine Hauptklasse
~BorgQtThread~ erstellt um soviel Code wie möglich zwischen den einzelnen
Funktionen wiederverwendne zu können. Jede Funktion vererbt die Klasse dann und
adaptiert sie soweit als nötig.
Damit gls:borg aus der Anwendung angesteuert werden kann wird das Python Modul
~subprocess~footcite:subprocess verwendet. Dieses erlaubt einem neue Prozesse
zu erstellen welche man oftmals benötigt um etwa, wie im Fall von Borg-Qt,
externe Applikationen zu starten, zu steuern und ihre Ausgabewerte auszulesen.
Damit gls:borg die Ausgabe im gls:json Format ausgibt muss man man noch die
Parameter ~--log-json~ und ~--json~ ausgeben. Der erste Parameter ändert
hauptsächlich das Format von Errormeldungen und der zweite formatiert dann die
finale Ausgabe. Die Ausgaben werden dann jeweils an Variabeln weitergegeben
(~json_output~ und ~json_error~ ) welche dann im weiteren Code verarbeitet
werden.
Insbesondere ~json_error~ ist für den weiteren Programmablauf von grosser
Wichtigkeit. Wenn Borg ein Problem feststellt wird dieses an diese Variabel
weitergegeben. Mittels der Methode im Codesnippet:([[code:json_err ]]), wird die
Variabel ausgewertet und im Falle eines Fehlers wirft der Code eine Exception
welche im Hauptprogramm abgefangen wird. Dabei wird dann eine Fehlermeldung in
einem separaten Fenster ausgegeben. Die Methode wurde dabei auf der Klasse
~BorgQtThread~ umgesetzt und steht somit allen Funktionen zur Verfügung. Die
Fehlermeldung bei einer fehlenden Konfigurationsdatei,
Abbildung:([[fig:borgqt_missing_config ]]), funktioniert nach dem gleichen Prinzip
und konnte somit zum grössten Teil wiederverwendet werden. Der restliche
gls:json Output kann dann einfach mit dem ~json~ Modul geparst werden.
Somit werden dem User direkt die Fehlermeldungen von gls:borg angezeigt und es
muss nur an gewissen Stellen noch applikationsspezifisches Exception Handling
betrieben werden.
#+caption : Auswertung der json err Variabel.
#+name : code:json_err
#+begin_src python
# borg_qt/borg_interface.py
def process_json_error(self, json_err):
if json_err:
error_list = json_err.split('\n')
if "borg.locking" in error_list[0]:
pass
else:
err = json.loads(error_list[0])
raise BorgException(err['message'])
#+end_src
** Backup
Bei den Backups handelt es sich ohne Zweifel um die wichtigste Funktion von
Borg-Qt. Deshalb soll das erstellen eines Backups so schnell und unkompliziert
wie möglich von statten gehen.
*** Backend
werden. Die Funktion ~backup~ nimmt 3 Argumente auf: ~includes~ , ~excludes~ ,
~prefix~ . Wobei ~excludes~ und ~prefix~ beide optional sind. Im Hauptcode
werden diese Argumente aus der Konfigurationsdatei ausgelesen. Die Includes
werden im Falle eines Backups im Hintergrund auch aus der Konfigurationsdatei
gelesen oder wenn es der User manuell ausführt wird der im Frontend ausgewählte
Pfad mitgegeben.
Die "Excludes" haben lange nicht funktionert. Der Grund dafür waren zusätzliche
Anführungszeichen um die Exclude Pfade. Diese wurden aus Versehen hinzugefügt
da gls:borg normalerweise auf der Kommandozeile ausgeführt wird und die
Anführungszeichen dort notwendig sind um allfällige Leer- oder Sonderzeichen
abzufangen. Es wurde davon ausgegangen dass, da ~subprocess~ Modull ähnlich
funktioniert wie die Kommandozeile. Da man an das Modull direkt einen String
übergibt sind die zusätzlichen Anführungszeichen nicht notwendig und führen
sogar dazu das die Pfade gar nicht funktioneren. Somit werden die "Excludes"
einfach mit dem entsprechenden Parameter gepaart und als gesamte Liste an das
finale Kommando angehängt zu sehen in Codesnippet:([[code:excludes ]]).
#+caption : Erstellen des "borg create" Kommandos fürs erstellen von Backups.
#+name : code:excludes
#+begin_src python
# borg_qt/borg_interface.py
# Funktion zum Verarbeiten der "Excludes"
def _process_excludes(self, excludes):
processed_items = []
if excludes:
for item in excludes:
processed_items.extend(['-e', item])
return processed_items
else:
return processed_items
# Methode zum Erstellen des BorgBackup Kommandos.
def create_command(self):
self.command = ['borg', 'create', '--log-json', '--json',
('::'
+ self.prefix
+ '{now:%Y-%m-%d_%H:%M:%S}')]
self.command.extend(self.includes)
if self.excludes:
self.command.extend(self.excludes)
#+end_src
Aus zeitlichen Gründen konnte die Funktion zur Erkennung eines laufenden
Hypervisors nicht während der Diplomarbeit entwickelt werden.
*** Frontend
Damit die Backups im Frontend funktionieren musste zum einen der "Backup" Knopf
mit der Funktion ~backup~ verknüpft werden. Desweiteren wurde ein Dateibaum, in
Abbildung:([[fig:borgqt_file_tree ]]) grün umrahmt, eingefügt. Dieser gibt den Pfad
des angewählten Objektes and die ~backup~ Funktion weiter.
#+caption : Screenhot des Dateibaumes.
#+name : fig:borgqt_file_tree
[[file:pictures/borgqt_file_tree.png ]]
Während dem ein Backup erstellt wird, wird ein kleiner Dialog mit Ladebalken
angezeigt, Abbildung:([[fig:borgqt_progress_v2 ]]). Dieser dient hauptsächlich dazu
dem User das Gefühl zu geben das die Applikation noch am Arbeiten ist.
Der Dialog musste gegenüber der ersten Version in Sektion: [[Erste Umsetzung ][Erste Umsetzung ]] noch
etwas angepasst werden. gls:borg gibt während dem Erstellen eines Backups keine
Informationen zurück welches einem erlauben würden einen Fortschrittsbalken zu
generieren welcher effektiv den Fortschritt anzeigt. gls:borg gibt einzig die
Anzahl der verarbeiteten Dateien in regelmässigen Abständen zurück. Da gls:borg
jedoch zu Beginn nicht meldet wieviele Dateien gesichert werden lässt sich
damit keine Prozentzahl erstellen. Ein paar Experimente bei denen die zu
sichernenden Dateien zuerst von Borg-Qt gezählt werden sollten, wurden
verworfen. Einerseits weil keine Methode gefunden werden konnte welche die
gleiche Anzahl Dateien zurückgab wie gls:borg. Anderseits weil es den Backup
Vorgang unnötig in die Länge zieht. Dies ist insbesondere der Fall wenn sich
sehr viele Dateien im Quellverzeichnis befinden. Aus diesem Grund wurde der
Fortschrittsbalken mit Prozentanzeige durch einen sich wiederholenden
Ladebalken ersetzt.
Damit die Applikation während eines langen Vorgangs wie ein Backup oder ein
Restore nicht einfriert muss der gls:borg Prozess in einem eigenen Thread
gestartet werden. Python würde hierzu ein Modul,
~threading.Thread~footcite:threading, mitliefern. Allerdings war es nicht
möglich den Fortschrittsdialog und die Thread so zu verknüpfen das sich der
Dialog schliesst wenn das Backup durchgelaufen ist und der Thread wieder
entfernt wird. Aus diesem Grund wurde dann ein erfolgreicher Test mit dem PyQt
Modul ~QThread~footcite:qthread gemacht. Mit diesem war es ohne weiteres
möglich den Dialog zu schliessen sobald das Backup fertig durchgelaufen war.
Auch das stoppen des Threads mit einem Klick auf den "Cancel" Button
funktioniert einwandfrei.
#+caption : Screenshot des "Aktion in Ausführung" Dialogs.
#+name : fig:borgqt_progress_v2
#+attr_latex : :width .4\paperwidth :placement [H]
[[file:pictures/borgqt_progress_v2.png ]]
Wurde das Backup erfolgreich erstellt, wird die Liste mit den Archiven sowie
die Repository Statistik aktualisiert. Beide Elemente sind in der,
Abbildung:([[fig:borgqt_archive_list ]]), grün respektive rot umrahmt. Beide
Funktionen wurden im Grossen und Ganzen gleich wie bereits die ~backup~
Funktion implementiert. Die zurückerhaltenen gls:json Strings werden wieder auf
die jeweilige Information geparst und die Archive in Python Listen, die
Repository Statisk in Ganzzahlen umgewahndelt.
Da gls:borg die Repository Grössen in Bytes zurück gibt sollten diese zur
Anzeige noch in eine menschenlesbarses Format umgerechnet werden. In Borg-Qt
geschieht dies mit der Helferfunktion ~convert_size~ . Die Funktion wurde von
Stackoverflow footcite:sizeformat übernommen.
#+caption : Screenshot der aktualisierten Archivliste und Repository Statistik.
#+name : fig:borgqt_archive_list
[[file:pictures/borgqt_archive_list.png ]]
** Restore
Der Code für das Wiederherstellen eines Backups ist sehr ähnlich wie der Code
für das Erstellen. Die Besonderheiten bei dieser Funktion sind vorallem die
Kontrolle das ein Archiv angewählt wurde bevor man die Wiederherstellung
startet, das Erstellen des Zielpfades sowie das Aufräumen bei einem Fehler.
Wird der "Restore" Knopf gedrückt ohne das ein Backup angewählt wurde erscheint
folgende Fehlermeldung, Abbildung:([[fig:no_archive_selected ]]), um den Benutzer
darauf hinzuweisen das er dies noch tun sollte.
#+caption : Screenshot der Fehlermeldung eines fehlenden Archives während einem Restore.
#+name : fig:no_archive_selected
#+attr_latex : :width .2\paperwidth :placement [H]
[[file:pictures/borgqt_no_archive_selected.png ]]
Das Wiederherstellen an sich läuft so ab das der Benutzer zuerst ein Archiv
auswählt und dann auf "Restore" klickt. Daraufhin öffnet sich ein Dialog in
welchem der Benutzer den Zielort auswählen kann. Sobald er dies getan hat
erstellt Borg-Qt darin einen Order mit dem Namen des Archives und beginnt mit
dem eigentlichen Wiederherstellen. Sollte der Zielort für die Applikation nicht
beschreibbar sein erscheint eine entsprechende Fehlermeldung,
Abbildung:([[fig:not_writeable ]]), und der Vorgang wird abgebrochen. Nach einer
erfolgreichen Wiederherstellung öffnet die Applikation den Zielort in einem
Dateimanager damit der User gleich mit den Dateien weiterarbeiten kann.
#+caption : Screenshot der Fehlermeldung wenn der Zielort nicht beschreibbar ist.
#+name : fig:not_writeable
#+attr_latex : :width .2\paperwidth :placement [H]
[[file:pictures/borgqt_not_writeable.png ]]
Gibt es während dem Wiederherstellen einen Fehler gibt die Anwendung den
entsprechenden Fehler aus und löscht zusätlich noch den zu Beginn erstellten
Archiv Ordner. Dies aus dem Grund da die Wiederherstellung ja nicht komplett
durchgelaufen ist befindet sich das Archiv in einem unfertigen Zustand. Somit
ist es sinnvoller die wiederhergestellten Dateien wegzuräumen als unter
Umständen defekte Dateien zurückzulassen.
Wird das gleiche Archiv nochmal an den gleichen Zielort wiederhergestellt ist
das für gls:borg kein Problem. Es überschreibt die Dateien einfach nocheinmal.
** Mount
Die "Mount" Funktion ist sehr ähnlich wie die "Restore" Funktion. Sie prüft
auch zuerst ob der Benutzer überhaupt ein Archiv angewählt hat und gibt falls
dies nicht der Fall ist eine entsprechende Fehlermeldung aus. Im Gegensatz zur
"Restore" Funktion zeigt die "Mount" Funktion jedoch keinen Dialog zum
Auswählen des Zielpfades. Die Funktion erstellt sich diesen selbst. Der
Zielpfad ist dabei kombiniert aus dem ~/tmp~ Verzeichnis und dem Namen des
Archives.
gls:borg mountet jedes Archiv nur mit Leserechten. Da es relativ
unwahrscheinlich ist das der Zielpfad in unbeschreibbarer Form bereits vor dem
Ausführen der Appliation bereits vorhanden ist. Sollte dies jedoch der Fall
sein kann davon ausgegangen werden das der Benutzer das Archiv bereits einmal
gemountet wurde. Genau dies wird in der Applikation auch so überprüft. Falls
der Zielort schreibbar ist wird das ausgewählte Archiv auf diesem Pfad
gemountet. Anschliessend wird wie auch bei der Restore Funktion der Pfad in
einem Dateimanager geöffnet damit der Benutzer direkt mit den Dateien
weiterarbeiten kann. Wurde erkannt dass, das Archiv bereits gemountet wurde
öffnet die Applikation direkt den Dateimanager ohne zu versuchen das Archiv
nocheinmal zu mounten.
Zusätlich wird der Pfad jedes gemounteten Archives in einer Liste gespeichert.
Beim Beenden der Applikation iteriert die Applikation über jeden Pfad in der
Liste unmountet und löscht ihn. Somit befindet sich das System wieder im
gleichen Zustand wie vor dem Start der Applikation.
** Delete
Der Benutzer hat in der Applikation auch die Möglichkeit Archive wieder zu
löschen. Hierbei greift wie bei der "Restore" und "Mount" Funktion auch wieder
die Überprüfung ob der Benutzer ein Archiv ausgewählt hat. Ist dies gegeben
zeigt die Applikation dem Benutzer einen Dialog, Abbildung:([[fig:yes_no ]]), zum
sicherstellen das er das Archiv wirklich löschen möchte. Bestätigt er diesen
mit "Yes" wird der Vorgang vortgesetzt und das Archiv gelöscht. Anschliessend
werden die Archivliste und die Repository Statistik aktualisiert um den neuen
Zustand wiederzugeben.
#+caption : Screenshot des Yes/No Dialogs in der "Delete" Funktion.
#+name : fig:yes_no
#+attr_latex : :width .3\paperwidth :placement [H]
[[file:pictures/borgqt_yes_no.png ]]
** Automatische Backups
Damit der Benutzer die Backups von Hand machen muss ist es sinnvoll eine
Funktion bereitzustellen welche die Backups automatisch im Hintergrund
erledigt. Dadurch ist sichergestellt das die Backups im allgemeinen Trubel des
Lebens nicht vergessen gehen.
Damit automatische Backups überhaupt möglich sind muss die Applikation zuerst
Backups im Hintergrund erstellen können, also ohne das die ganze grafische
Oberfläche angezeigt wird. Bei Borg-Qt wird dies über ein Kommandozeilen
Parameter realisiert. Hierfür wurde das Python Standard Paket ~argparser~
verwendet. Konkret bedeutet dies dass, wenn man die Applikation auf
der Kommandozeile wie folgt ausführt ~borg_qt -B~ wird die grafische Oberfläche
nicht angezeigt und es wird direkt die Method ~background_backup~ der Klasse
~MainWindow~ ausgeführt. Dabei werden alle Ordner welche in den Einstellungen
unter "Include" sowie "Exclude" gespeichert wurden, im Archiv gesichert,
respektive davon ausgeschlossen. Damit sind die Voraussetzungen für
automatische Backups gegeben.
Um die Backups in regelmässigen Intervalen auszuführen gibt es zwei
Möglichkeiten wie man dies implementieren könnte. Zum einen könnte man die
Applikation permanent im Hintergrund laufen lassen, etwa als Trayicon wie man
das von anderen Applikationen wie etwas Dropbox kennt zum anderen kann man es
über Werkzeuge des Betriebssystems bewerkstelligen.
Die drei Desktopbetriebsysteme, Windows, OS X und Linux, bringen alle drei
Werkzeuge mit um periodisch einen ein Programm auszuführen. Unter Linux wurde
dies früher mit sogenannten Cron Jobs gemacht. Die moderne Lösung sind
heutzutage jedoch sogenannte Systemd Timer. Für Borg-Qt wurde beschlossen es
mit den Werkzeugen des Betriebssystems zu machen. Also konkret Systemd. Dies
einerseits aus dem Grund das ein Grossteil der Funktion bereits programmiert
wurde und man somit Zeit sparen kann, zum anderen wurden die Systemd Timer
genau für solche Zwecke programmiert. Zu guter Letzt soll die Anwendung dem
Benutzer auch soweit als möglich aus dem Weg gehen. Eine Applikation welche
permanent in der Taskleiste lebt scheint hier nicht wirklich das Kriterium zu
erfüllen.
Systemd ist ein init System welches dazu dient dazu die Benutzerumgebung und
die dazugehörigen Prozesse zu starten und zu verwalten footcite:systemd. Die
Prozesse werden über sogenannte "Services" gestartet. Die Services werden dabei
einfach in Klartextdateien mit der Dateiendung ~.service~ definiert. Der Inhalt
orientiert sich dabei praktischerweise am "INI" Stil. In Borg-Qt wurde das INI
Format bereits bei den Konfigurationsdateien verwendet. Somit können dort
gesammelte Erfahrungen wiederverwendet werden. Soll ein Service in einem
gewissen Zeitinterval ausgeführt werden benötigt Systemd eine weiter Datei mit
dem gleichen Namen jedoch mit der Dateiendung Timer. Der Inhalt ist auch wieder
im INI Stil gehalten. Systemd versteht eine Vielzahl an Datumsformaten
footcite:systemddate. In Borg-Qt wurden zwei Varianten in den Einstellungen
umgesetzt. Eine welche "Predefined Schedule" genannt wurde und eine mit dem
Namen "Custom Schedule", zu sehen in, Abbildung:([[fig:schedule ]]). Die Predefined
Option wird dabei in die von Systemd unterstützten Formate "hourly", "daily",
"weekly" und "monthly" übersetzt. Wie der Name schon sagt wird dann stündlich,
täglich, wöchentlich oder monatlich ein Backup erstellt. Mit der Custom Option
kann der Benutzer sich den Zeitplan individueller gestalten. Etwa "jeden
Mittwoch um 12:00 Uhr" für Systemd übersetzt würde dieser Zeitplan dann so
aussehen: ~Wednesday *-*-* 12:00:00~ . Für spätere Versionen von Borg-Qt wäre es
allenfalls auch möglich die Auswahl von mehreren Wochentagen zu ermöglichen
damit der Benutzer etwa folgenden Zeitplan erstellen könnte "Montag, Mittwoch,
Freitag stündliche Backups." (~Monday, Wednesday, Friday *-*-* *:00:00~ ).
#+caption : Screenshot der "Schedule" Einstellungen
#+name : fig:schedule
#+attr_latex : :placement [H]
[[file:pictures/borgqt_settings_schedule.png ]]
Das erstellen der eigentlichen Systemd Konfiguration passiert in Borg-Qt in der
~Config~ Klasse. Zum schreiben, und de-/aktivieren des Systemd Services, respektive
Timers wurde wurde eine Klasse ~SystemdFile~ . Somit könnte die Funktion auch
einfach in einem anderen Projekt verwendet werden.
Systemd benötigt zum Starten der Anwendung den absoluten Pfad in der Service
Datei. Da davon ausgegangen werden kann das Borg-Qt im ~PATH~ des Systems
abgelegt wird, wurde das Unix Tool "which" verwendet um den exakten Speicherort
zu erhalten. Mittels des Befehls ~which borg-qt~ erhält man den absoluten
Speicherort der Datei. Zusammen mit den Daten aus den Einstellungen wird diese
Information in einem ~Configparser~ Objekt gespeichert welches dann mithilfe
der ~SystemdFile~ Klasse in eine ~borg_qt.service~ ,
Codesnippet:([[code:systemdservice ]]), respektive ~borg_qt.timer~ ,
Codesnippet:([[code:systemdtimer ]]), Datei im Systemd Pfad für Benutzerdaten
~/home/username/.config/systemd/user/~ gespeichert wird und aktiviert.
Eine Option in der ~borg_qt.timer~ die noch erwähnenswert ist, ist ~Persistent
= true~. Ist ~Persistent~ auf ~true~ gesetzt holt Systemd den Tasks nach sollte
er eine Ausführung verpasst haben. Dies ist insbesondere dann hilfreich wenn
etwa der Zeitplan auf ~daily~ oder ~weekly~ gesetzt wurde. Sollte also etwa
jeden Mittwoch ein Backup gemacht werden aber der Computer lief an diesem Tag
nicht, startet Systemd Borg-Qt sobald der Computer das nächste Mal
eingeschaltet wird kommt.
Mit dem Abschluss des automatischen Backups wurde die für die Entwicklung
reservierte Zeit aufgebraucht und die Entwicklung neuer Funktionen für den
Zeitrahmen der Diplomarbeit angehalten.
#+caption : Systemd Service Datei für Borg-Qt
#+name : code:systemdservice
#+begin_src bash
#~/.config/systemd/user/borg_qt.service
[Unit]
Description = Runs Borg-Qt once in the backround to take a backup according to the configuration.
[Service]
Type = oneshot
ExecStart = /home/andreas/bin/borg_qt -B
#+end_src
#+caption : Systemd Timer Datei für Borg-Qt
#+name : code:systemdtimer
#+begin_src bash
#~/.config/systemd/user/borg_qt.timer
[Unit]
Description = Starts the borg_qt.service according to the configured schedule.
[Timer]
OnCalendar = hourly
Persistent = true
[Install]
WantedBy = timers.target
#+end_src
** UI Anpassungen nach Benutzerfreundlichkeitsstudie
Im Rahmen der durchgeführten [[Benutzerfreundlichkeitsstudie ][Benutzerfreundlichkeitsstudie ]] wurden einige Punkte
festgestellt welche im Rahmen der Diplomarbeit angepasst werden konnten. Zum
einen wurden einige Buttons neu beschriftet um klarer auf ihre Funktion
hinzuweisen. Dies wurde bei den "Include" Optionen,
Abbildungen:([[fig:borgqt_settings_include_v2 ]]) und bei den "Exclude" Optionen,
Abbildung([[fig:borgqt_settings_exclude_v2 ]]), gemacht.
#+caption : Screenshot der Borg-Qt "Include" Einstellungen Version 2
#+name : fig:borgqt_settings_include_v2
#+attr_latex : :placement [H]
[[file:pictures/borgqt_settings_include_v2.png ]]
#+caption : Screenshot der Borg-Qt "Exclude" Einstellungen Version 2
#+name : fig:borgqt_settings_exclude_v2
#+attr_latex : :placement [H]
[[file:pictures/borgqt_settings_exclude_v2.png ]]
Zudem wurde ein kleines Hilfe Fenster, Abbildung:([[fig:borgqt_help ]]), eingebaut
welches dem Benutzer beim Start der Applikation angezeigt wird. Dieses soll ihm
einen kurzen Überblick darüber geben welcher Button welche Aktion auslöst.
Optional kann der Benutzer dann noch entscheiden das er das Fenster beim
nächsten Start nicht mehr angezeigt bekokmmen möchte. Über den Button "Help"
kann das Fenster jederzeit unabhängig der Einstellungen wieder angezeigt werden.
#+caption : Screenshot des Borg-Qt Hilfe Fenster
#+name : fig:borgqt_help
#+attr_latex : :placement [H]
[[file:pictures/borgqt_help.png ]]
** Releases
Für die finale Veröffentlichung wird Borg-Qt als ein sogennantes ausführbares
"Binary" zur Verfügung gestellt. Man kennt diese auf Windows Systemen etwa als
die Dateien mit der Endung ".exe". In diesem Fall handelt es sich beim Binary
um ein selbstenpackendes Dateiarchiv. Darin enthalten sind alle benötigten
Python Modulle und sonstige Dateien wie etwa die Icons oder gls:gui
Definitionsdateien. Beim Ausführen entpackt sich das Archiv in einen temporären
Ordner und liesst dann von dort aus alle benötigten Dateien.
Diese Art der Auslieferung hat dabei den Vorteil das der User das Programm
nicht speziell installieren muss oder dafür irgendwelche zusätzlichen Dinge
installieren muss. Der Nachteil ist jedoch das so ein Binary nur auf dem
jeweilgen Betriebssystem erstellt werden kann. Das heisst das man unter Linux
etwa keine Binaries für Mac erstellen kann oder umgekehrt.
Erstellt werden die Dateien mit einem Programm namens
"PyInstaller"footcite:pyinstaller. Man führt das Programm dabei auf der
Kommandozeile gegen die Hauptdatei des Codes aus. Der Befehl dafür ist relativ
einfach, Codesnippet:([[code:pyinstaller ]]). Wichtig dabei ist das man die Pfade
der zusätzlichen Dateien wie etwa Icons mit angibt da PyInstaller diese nicht
selber finden kann. Der gezeigte Code wurde dabei in ein Makefile
implementiert. Somit kann man in der obersten Ebene des Repository einfach den
Befehl ~make~ ausführen und das Binary wird im Ordner ~dist~ erstellt.
#+caption : Code zum Erstellen der finalen Binaries von Borg-Qt
#+name : code:pyinstaller
#+begin_src bash
pyinstaller --hidden-import=PyQt5.sip \
--add-data=borg_qt/static/icons:static/icons \
--add-data=borg_qt/static/UI:static/UI \
-F borg_qt/borg_qt.py; \
#+end_src
2019-01-10 20:28:10 +01:00
2018-12-24 15:53:54 +01:00
* TODO Ausblick
2019-02-27 21:55:48 +01:00
** TODO Erreichte Ziele
*** TODO Risikoanalyse der neuen Ist-Situation
2018-12-10 21:16:57 +01:00
** TODO Projektmanagement
2019-02-27 21:55:48 +01:00
Gantt Chart sehr hilfreich beim behalten des Überblickes für das Projekt. Gibt
einem einen durchgehenden roten Faden.
Die konservativen Zeitschätzungen haben sich als korrekte Entscheidung
erwiesen. In Zukunft kann noch stärker versucht werden die Zeit welche für
ähnliche Code Teile verwendet wird kürzer zu schätzen. Copy/Paste erlaubt unter
Umständen enorme Zeitersparnise.
Die regelmässigen Arbeitsessions haben sich als eine gute Variante des Arbeiten
erwiesen und haben die Last der Diplomarbeit gut verteilt.
2018-12-10 21:16:57 +01:00
** TODO Umsetzung
2019-02-27 21:55:48 +01:00
Unittests sind der Shit brauchen allerdings Zeit und eine gewisse Erfahrung mit
der Sprache. Qt ist eine hilfreiches Framework wenn auch sehr umfangreich. Wenn
man gewillt ist sich mit dem C++ Code auseinanderzusetzen ist die Dokumentation
jedoch sehr detailiert.
** TODO Weiterverwendung von Borg-Qt
2018-12-10 21:16:57 +01:00
2018-12-24 15:53:54 +01:00
** TODO Gelerntes
2018-12-10 21:16:57 +01:00
PLACEHOLDER
2018-12-08 08:28:12 +01:00
2018-12-25 13:47:55 +01:00
#+LATEX :\newpage
#+LATEX :\begin{landscape}
* Arbeitsjournal
2019-03-02 10:57:16 +01:00
#+LATEX :\newpage
#+LATEX :\begin{landscape}
** Klassendiagramm
#+caption : Klassendiagramm der Borg-Qt Applikation
#+name : fig:class_diagramm
#+attr_latex : :height .7\textwidth :placement [H]
[[file:pictures/class_diagramm.pdf ]]
#+LATEX :\end{landscape}
2018-12-25 13:47:55 +01:00
#+CAPTION : Arbeitsjournal
#+ATTR_LATEX : :environment longtable :align |p{2cm}|p{5cm}|p{5cm}|p{7cm}|
#+NAME : tab:arbeitsjournal
2019-02-27 21:55:48 +01:00
|-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| <8> | <20> | <20> | <20> |
| *Von/Bis*\cellcolor[HTML]{C0C0C0} | *Geplante Arbeiten*\cellcolor[HTML]{C0C0C0} | *Erreichte Arbeiten*\cellcolor[HTML]{C0C0C0} | *Eindruck*\cellcolor[HTML]{C0C0C0} |
|-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 10.-16.12.2018 | Zeitplan erarbeiten, Ziele dokumentieren | keine Abweichung | - |
|-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 17.-23.12.2018 | Lösungsvarianten erfassen, Lösungsvarianten bewerten, Lösungsvariante bestimmen, SWOT Analyse erstellen, 1. Meeting | keine Abweichung | Marco Frei hat noch diverse Punkte eingebracht die, die Planung ziemlich durcheinander bringen. Bedeute viel zusätzliche Arbeit. |
|-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 24.-30.12.2018 | Controlling erarbeiten, Ist- und Soll-Analyse, SWOT Analyse, Umweltanalyse, Massnahmen Katalog erarbeiten, User Stories erarbeiten, Use Case Diagramm erstellen, Use Cases ausarbeiten, Anforderungskatalog erstellen, UML Diagramme | keine Abweichung | UML Diagramme für eine Software zu erstellen die nicht existiert ist noch eine interessante Herausforderung. |
|-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 31.12-06.01.2019 | Lösungsvarianten erarbeiten und entscheiden, Test Konzept beschreiben und Testfälle erstellen, Github Repository erstellen | Testfälle liessen sich noch nicht für alle Ziele erstellen. Gewisse Features hängen noch sehr davon ab wie die Basis der Applikation sich entwickelt. | Insgesamt gut gelaufen. Das Repository auf Github konnte ich unter einer eigenen Organisation erstellen dadurch wird das Zusammenarbeiten in der Zukunf einfacher. |
|-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 07.-13.01.2019 | UI ausarbeiten, UI Test ausarbeiten | keine Abweichung | Das das Projekt gut im Zeitplan ist soweit ein positiver Ausblick. |
|-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 14.-20.01.2019 | Backend "Read Config" Funktion schreiben, Frontend "Read Config" Funktion beginnen | "Frontend Read Config", "Backend Write Config", "Frontend Write Config", Funktion bereits abgeschlossen. | Soweit sehr gut im Zeitplan. Die Arbeitssessions mit den Kollegen helfen. Seltsam das Qt keine Methode list.items() kennt. |
|-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 21.-27.01.2019 | "Backend Backup" Funktion, "Frontend Backup" Funktion beginnen, Automatische Backups recherchieren | keine Abweichung | Erkältung drückt etwas auf die Performance. Unittest sind nocht nicht perfekt aber sind eine grosse Hilfe. |
|-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 28.-03.02.2019 | "Frontend Backup" Funktion fertigstellen, "Backend und Frontend Restore" Funktion | Geplantes erreicht sowie "Mounting" und "Delete" Funktion sowohl im Backend wie auch im Frontend bereits umgesetzt. | Da die Funktionen immer von gls:borg ausgeführt werden konnte sehr viel Code von den "Backup" und "Restore" Funktionen übernommen werden was die Entwicklung sehr beschleunigt hat. |
|-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 04.02.-10.02.2019 | Meeting Pendenzen nochmal durchgehen. Die Interface Funktionen bereinigen. Automatische Backups implementieren. | Meeting Pendenzen wurden aufgenommen und das Interface wurde bereinigt. Automatische Backups konnten noch nicht fertig gestellt werden. | Automatische Backups sind noch relativ komplex und benötigen Kenntnisse der Systemd Timer. |
|-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 11.02.-17.02.2019 | UI Tests mit den Usern durchführen, Resultate auswerten, Feedback in Applikation einarbeiten | keine Abweichung | Es ist sehr spannend zu sehen wie Benutzer mit der Anwendung interagieren und welche Featues sie vermissen. |
|-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 18.02.-24.02.2019 | Automatische Backups implementieren, 1. Release veröffentlichen, Readme updaten | keine Abweichung | Das Projekt ist soweit sehr gut im Zeitplan. Die Systemd Timer sind können mit vielen verschiedenen Zeitformaten umgehen und sind sehr flexibel. |
|-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 25.02.-03.03.2019 | Testfälle durchgehen, Dokumentation zur Realisierung abschliessen | | |
|-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
2018-12-25 13:47:55 +01:00
#+LATEX :\end{landscape}
2018-12-08 08:28:12 +01:00
* Bibliography :no_export:
bibliography:general/bibliography.bib
