Embed Size (px)
Citation preview
Gottfried Wilhelm
Leibniz Universität Hannover
Fakultät für Elektrotechnik und Informatik
Institut für Praktische Informatik
Fachgebiet Software Engineering
Entwurf und Implementierung eines
Projektmanagement-Werkzeuges
Bachelorarbeit
im Studiengang Informatik
von
Toan Vu
Prüfer: Prof. Dr. Kurt Schneider
Zweitprüfer: Dr. rer. nat. Arne Meier
Betreuer: Dipl.-Math. Raphael Pham
Hannover, 4. September 2012
III
Zusammenfassung
Projekte in der SW-Industrie umfassen gewisse Gemeinsamkeiten wie z.B. definierter
Anfang und definiertes Ende, Meilensteine, Deadlines, Verteilung von Dokumenten bzw.
Ressourcen. In einem Projekt werden teilnehmende Personen unterschiedliche Aufgaben
wahrnehmen, Ergebnisse zu verschiedenen Zeitpunkten abliefern und eine spezifische
Funktion haben. In der Regel wird die Koordination für das restliche Arbeitsteam von
einem Projektleiter geleistet. Um dieser Aufgabe gerecht zu werden, wird ein hohes Maß
an Kommunikation verlangt, was in der Gegenwart oft per E-Mail erledigt wird. In der
Industrie werden verschiedene Werkzeuge verwendet, um den Projektleiter zu
unterstützen. Das sogenannte Projektmanagement-Werkzeug bildet den
durchzuführenden Prozess (Termin, Phasen, Deliverables u.ä.) in einem Modell ab und
stellt diesen abstrahiert dar, wodurch der Projektleiter das Projekt anschaulich planen
kann. Im Rahmen dieser Arbeit wurde ein Projektmanagement-Werkzeug entwickelt, mit
dem der SE-interne Prozess des jährlichen Softwareprojektes abgebildet wird. Die dazu
entwickelte Software ermöglicht das Versenden vorgefertigter E-Mails an eine bestimmte
Gruppe von Personen zu festgelegten Zeitpunkten. Die Prozesse können mittels eines
Gantt-Diagramms anschaulich dargestellt werden. Durch das Projektmanagement-
Werkzeug können alle an dem Softwareprojekt beteiligten Personen erfasst und verwaltet
werden. Die Arbeit präsentiert eine Umsetzung der beschriebenen Funktionalität durch
das Konzept der Aspektorientierten Programmierung.
Inhaltsverzeichnis
IV
Inhaltsverzeichnis
Abbildungsverzeichnis .................................................................................................. VI
Abkürzungsverzeichnis ................................................................................................ VII
1 Einleitung ..................................................................................................................1
1.1 Problemstellung .........................................................................................................1
1.2 Ziel und Aufbau der Arbeit .......................................................................................2
2 Konzepte ....................................................................................................................4
2.1 Softwareprojekt ..........................................................................................................4
2.2 Grundlagen ..................................................................................................................7
2.2.1 Definitionen ...................................................................................................7
2.2.2 Personalplanung ..........................................................................................8
2.2.3 Zeitplanung ...................................................................................................8
2.3 Analyse von verschiedenen Werkzeugen .............................................................9
2.3.1 PHProject ......................................................................................................9
2.3.2 OpenProj .....................................................................................................11
2.3.3 Microsoft Project ........................................................................................12
3 Anforderungen ........................................................................................................15
3.1 Anforderungen .......................................................................................................... 15
3.2 Anwendungsfälle ...................................................................................................... 17
3.2.1 Personalverwaltung ....................................................................................18
3.2.2 Aktivitätsverwaltung ...................................................................................21
3.3 Qualitätsanforderungen .......................................................................................... 22
3.3.1 Benutzbarkeit ..............................................................................................22
3.3.2 Wartbarkeit ..................................................................................................23
3.3.3 Zuverlässigkeit ...........................................................................................23
3.4 Risiken ........................................................................................................................ 24
4 Projektumsetzung ...................................................................................................26
4.1 Ergebnisse der Prototypenentwicklung .............................................................. 26
4.2 Software ..................................................................................................................... 31
Inhaltsverzeichnis
V
4.3 Struktur des Modells................................................................................................ 31
4.3.1 Beziehungen ...............................................................................................32
4.3.2 Pakete ..........................................................................................................33
4.3.3 Klassenstruktur ..........................................................................................35
4.4 Implementierung....................................................................................................... 38
4.4.1 Laden von Objekten ...................................................................................38
4.4.2 Inhalt der Emails mit Schlüssel-Worten als Platzhaltern auswerten .......39
5 Erweiterungsmöglichkeiten ...................................................................................41
6 Zusammenfassung und Ausblick ..........................................................................42
Literaturverzeichnis .......................................................................................................44
Abbildungsverzeichnis
VI
Abbildungsverzeichnis
Abbildung 1: Beispiel für den Ablauf des Softwareprojekts .................................................4
Abbildung 2: Screenshot eines Beispiels für Prozessverwaltung von entwickeltem PMW ..9
Abbildung 3: Screenshot für PHProjekt ............................................................................10
Abbildung 4: Screenshot für OpenProj .............................................................................12
Abbildung 5: Screenshot für MS Project ...........................................................................14
Abbildung 6: Zusammenhang von wichtigen use-cases ...................................................18
Abbildung 7: Screenshot für die Informationsverwaltung einer Studierenden ...................19
Abbildung 8: Screenshot für die Verwaltung eines Teams ...............................................20
Abbildung 9: Anwendungsfalldiagramm der Personalverwaltung .....................................20
Abbildung 11: Anwendungsfalldiagramm der Aktivitätsverwaltung ...................................22
Abbildung 12: Screenshot für SQL-Typ 1 .........................................................................28
Abbildung 13: Screenshot für SQL-Typ 2 .........................................................................29
Abbildung 14: Screenshot für SQL-Typ 3 .........................................................................30
Abbildung 15: ER-Diagramm ...........................................................................................32
Abbildung 16: Paketezusammenhang ..............................................................................33
Abbildung 17: Model-View-Controller in Personal-Paket ..................................................34
Abbildung 18: Klassenstruktur von Entities ......................................................................36
Abbildung 19: Interface IView und konkrete Klasse, die dieses Interface implementieren 37
Abkürzungsverzeichnis
VII
Abkürzungsverzeichnis
API
CSV
GPL
GUI
HSQL
IMAP
LID
PHP
PMW
POP3
SE
SMTP
SQL
WYSIWYG
Application Programming Interface
Comma separated values
General Public License
Graphical User Interface
Hyper Structured Query Language
Internet Message Access Protocol
Light-Weight Documentation of Experiences
Personal Home Page
Post Office Protocol Version 3
Projektmanagement-Werkzeug
Simple Mail Transfer Protocol
Software Engineering
Structured Query Language
What you see is what you get
1 Einleitung
1
1 Einleitung
Bevor das Problem der vorliegenden Arbeit dargestellt wird, soll die Softwareprojekt-
Veranstaltung des SE-Instituts an der Hannoveraner Universität erläutert werden, in deren
Rahmen das Projektmanagement-Werkzeug entwickelt wird. Im Anschluss daran wird in
das Projekt eingeführt, bei dem das Thema der Arbeit praktisch umgesetzt worden ist.
Dabei werden auch die konkreten Probleme beschrieben, welche die Notwendigkeit der in
dem Projekt entwickelten Software begründen.
1.1 Problemstellung
Das Software-Projekt ist eine jährlich angebotene Veranstaltung des SE-Instituts der
Leibniz-Universität Hannover. Die Studierende sollen durch diese Veranstaltung
praktische Erfahrungen und Einblicke in die Entwicklung von Software sammeln und
erhalten. Es soll jeweils über jedes Projekt bzw. Thema ein Softwareprodukt in einem
zeitlich begrenzten Rahmen erstellt werden. Besonderer Wert ist auf den
Softwareentwicklungsprozess zu legen, wodurch ein Bewusstsein für diejenigen Probleme
geweckt werden soll, die bei der Entwicklung von Software auftreten können. Dazu sollen
viele Verfahren und Techniken, die in der Vorlesung „Softwaretechnik und
Softwarequalität“ behandelt wurden, praktisch angewendet werden.
Um den Verwaltungsaufwand für alle Projekte in der Veranstaltung zu erleichtern, wird die
Unterstützung von Werkzeugen benötigt. Der Verwaltungsaufwand resultiert aus den
folgenden Punkten:
Verwaltung von Studierenden und ihren Teams: Zur Veranstaltung werden die
Informationen aller teilnehmenden Studierenden gesammelt, wobei die Studierenden
in Abhängigkeit von diesen Informationen auf Projekte verteilt werden. Um
Studierende auf Projekte verteilen zu können, muss für jedes Projekt ein Team
gebildet werden. Die Sammlung solcher Informationen, die Bildung von Teams und
die Verwaltung von Studierenden mit den dazu gehörenden Teams machen den
Aufwand aus, der für die Veranstaltung reduziert werden kann.
Wiederkehrende Kommunikation: Die Softwareprojekt-Veranstaltung wird alle zwei
Semester angeboten und läuft jeweils in ähnlicher Reihenfolge mit Einführung,
Analyse, Entwurf, Implementierung und Abnahmetest ab. In jedem Prozess wird die
wiederkehrende Kommunikation zwischen Projektleiter und Studierenden
durchgeführt. In der Kommunikation werden Basis-Emails mit gleichen Inhalten an die
Studierenden geschickt. Nur solche Studierenden sind neue Elemente, die für die
Kommunikation mit Email in jedem Jahr angepasst werden. Die neu zu verfassenden
1 Einleitung
2
Emails mit ähnlichen Inhalten erzeugen den Aufwand, der mit einem Werkzeug
erleichtert werden kann. Mit dem Werkzeug kann der Inhalt der Email vorher
eingestellt werden.
Verwaltung von Prozessen: Die Prozesse im Laufe der Softwareprojekt-
Veranstaltung sollten verwaltet werden, damit man immer die Übersicht über die
gesamte Veranstaltung hat und die Prozesse verfolgen kann.
Zur Arbeitserleichterung soll daher ein Projektmanagement-Werkzeug (PMW) entwickelt
werden. Vor der Entwicklung des Werkzeuges sollen folgende auf dem Markt im
Projektmanagement eingesetzte Werkzeuge analysiert werden.
PHProject
OpenProj
MS Project 2007
Das PHProject gehört zur Gruppe der webbasierten Produkten, während OpenProj zur
Familie der Open Source-Software und MS Project zur Familie des Marktführers und
kostenpflichtigen Software zählt. Durch die Analyse von möglichst ähnlichen Werkzeugen
können die wichtigsten Funktionen, die zur Unterstützung der Verwaltung einer
Softwareprojekt-Veranstaltung dienen, von einem allgemeinen Projektmanagement-
Werkzeug abgegrenzt werden.
1.2 Ziel und Aufbau der Arbeit
Das Ziel der vorliegenden Arbeit ist es, einen Literaturüberblick über die Konzepte,
Funktionen und Instrumente des Projektmanagement-Werkzeuges zu geben und
anschließend ein eigenes Projektmanagement-Werkzeug zu entwickeln, das die
Softwareprojekt-Veranstaltung unterstützt. Dabei wird der Schwerpunkt auf das PMW im
Hinblick auf das aktuell vorherrschende PMW-Verständnis gelegt. Die Hauptaspekte, die
in dieser Arbeit näher erläutert werden, sind:
1. das Verständnis von Projektmanagement-Tools
2. Analyse der bereits eingesetzten Projektmanagement-Tools
3. Iterative Entwicklung eines Projektmanagement-Tools
Die vorliegende Arbeit gliedert sich in sechs Kapitel. Kapitel 1 beginnt mit der Einleitung,
die die Problemstellung, das Ziel und den Aufbau der Arbeit umfasst. In Kapitel 2 wird
zunächst die Softwareprojekt-Veranstaltung genauer erläutert, um danach die Grundlagen
1 Einleitung
3
und Konzepte in Bezug auf die Softwareprojekt-Veranstaltung zu behandeln. In Kapitel 3
werden die Schritte zu den einzelnen Anforderungen skizziert. Die wichtigsten
Anforderungen eines Projektmanagement-Werkzeuges werden dabei ausführlich
beschrieben. Außerdem sollen hier auch die Risiken analysiert werden.
In Kapitel 4 werden zuerst die Ergebnisse von Prototypen und anschließend die Struktur
des Programms erläutert. Die Beziehungen zwischen Entities und die Paketeverteilung
werden mit Beispielen erklärt werden. Dazu werden die Prototypen untersucht und ihre
Ergebnisse analysiert. Danach wird die Realisierung der wichtigsten Schritte der
Applikation anhand konkreter Beispiele erläutert. Gegenstand von Kapitel 5 sind dann die
verschiedenen Erweiterungsmöglichkeiten. In Kapitel 6 wird ein Fazit aus den
Ausarbeitungen gezogen. Darüber hinaus werden Vorschläge und Ideen für die
zukünftige Arbeit im Bereich des Projektmanagement-Werkzeuges formuliert.
2 Konzepte
4
2 Konzepte
In diesem Kapitel wird zuerst der Ablauf der Softwareprojekt-Veranstaltung beschrieben,
bevor dann die Begriffe und die Aspekte von Projektmanagement im Bezug auf die
Softwareprojekt-Veranstaltung erläutert werden. Danach werden drei auf dem Markt
eingesetzte Projektmanagement-Werkzeuge untersucht.
2.1 Softwareprojekt
Wie in der Einleitung kurz beschrieben, ist das Softwareprojekt eine
Veranstaltung, die von SE-Institut jährlich angeboten wird. Die ganze
Veranstaltung wird von der sogenannten „Fungate“-Firma verwaltet. Jeder
Studierende hat die Rolle von Mitarbeitern, und der Betreuer übernimmt entweder
die Funktion des Coachs oder des Kunden. Der Ablauf des gesamten Projekts
wird mit folgenden Prozessen beschrieben (vgl. Abbildung 1).
Abbildung 1: Beispiel für den Ablauf des Softwareprojekts
Quelle: Folien vom Softwareprojekt beim SE-Institut an der LUH.
Vorbereitung vor dem Beginn der Veranstaltung: Wie oben kurz beschrieben, wird
für jedes Projekt bzw. Thema ein Software-Produkt erstellt. Die Themen werden vor
Beginn der Veranstaltung überlegt und ausgewählt. Danach wird für jedes Thema ein
Mitarbeiter vom SE-Institut ausgesucht, um zum Thema beizusteuern. Die
2 Konzepte
5
organisatorischen Fragen wie Raumreservierung, Folienvorbereitung und Planung der
Einführungsveranstaltung müssen (natürlich) auch erledigt werden. Danach werden
alle im Laufe der Veranstaltung verwendeten Werkzeuge wie etwa NetQGate1 und
Registrierungstool in den Startzustand gebracht.
Einführung: Zum Start der Veranstaltung findet die Einführungsveranstaltung statt, in
der die ausgewählten Themen nacheinander vorgestellt werden. Außerdem werden
die organisatorischen Fragen und Rahmenbedingungen, unter denen die
Studierenden an der Veranstaltung teilnehmen dürfen, erklärt. Im Laufe der
Veranstaltung haben Studierende die Möglichkeit, allgemeine Fragen zum
gewünschten Thema sowie zum Ablauf des Projekts zu stellen.
Anmeldung: Unmittelbar nach der Einführungsveranstaltung wird der
Anmeldungsprozess ausgeführt. Die Studierenden, die an der Veranstaltung
teilnehmen möchten, müssen sich bei dem vom SE-Institut bereitgestellten System
registrieren. Durch das Anmeldungssystem werden Informationen aller Studierenden
als Kriterien für die Gruppeneinteilung gesammelt. Jeder Studierende hat bestimmte,
vorher definierte Informationstypen wie zum Beispiel Name, Matrikelnummer, Email,
belegte Veranstaltungen, Erfahrungen usw. Jeder Studierende darf zwei von den
vorgestellten Themen wählen. Die Mitarbeiter des SE-Instituts werden auf Grundlage
der Erfahrungen, Fähigkeiten und Wünsche jedes Studierenden und mit Blick auf den
jeweiligen Schwierigkeitsgrad der Themen die Studierenden den Gruppen zuteilen.
Jede Gruppe wird als ein Team gekennzeichnet.
Willkommen bei Fungate: Der Anmeldungsprozess endet mit der Gruppeneinteilung.
Jeder Studierende gehört zu einem Team bzw. zu einer Gruppe und bekommt
dadurch eine „Willkommen“-Email, dessen Inhalt jedes Jahr ähnlich ist. In jedem
Team werden zwei Personen nach Vereinbarung freiwillig ausgewählt. Eine spielt die
Rolle des Projektleiters, der direkt Kontakt mit dem Kunden und Betreuer aufnimmt
und danach die Arbeit an andere Mitglieder nach Vereinbarung verteilt. Die andere
Person spielt die Rolle des Qualitätsbeauftragten, der für die Qualität des Produkts
zuständig ist. Er kümmert sich um alle zu dem Projekt gehörenden Dokumente und
die Checkliste.
Analyse: Nachdem die Studierenden die Mitglieder ihrer Gruppe kennengelernt
haben, werden alle Themen mit einem systematischen Vorgehen in Prozessen eines
gewöhnlichen Vorgehensmodells aus der Softwaretechnik bearbeitet. Die einzelne
Software Engineering-Methode wie etwa die objektorientierte Analyse soll in diesem
1 Ein durch die Bachelorarbeit beim SE-Institut erstelltes Programm.
2 Konzepte
6
Prozess angewendet werden, um das Thema systematisch zu erschließen [SWT-
Zuser, S. 49]. Die Phase soll sich in einem bestimmten Zeitraum abspielen, in dem
eine Anforderungsspezifikation erstellt werden muss. Am Ende jeder Phase gibt es ein
Quality Gate, bei dem anhand vorher definierter Erfüllungskriterien über die Freigabe
des nächsten Projektprozesses entschieden wird. Die Abbildung der realen Quality
Gate-Sitzungen in einen virtuellen Quality Gate-Prozess wird mit Hilfe einer durch die
Bachelorarbeit am Institut für Praktische Informatik an der Leibniz-Universität
Hannover erstellten Webanwendung realisiert2. In dieser Phase wird die
Anforderungsspezifikation als Erfüllungskriterium von dem Betreuer geprüft. Wenn die
Arbeit erfolgreich ausgeführt worden ist, wird die nächste Entwurfphase freigeschaltet.
Im Misserfolgsfall darf jede Gruppe einmal wiederholen. Wenn auch die Wiederholung
nicht erfolgreich war, wird die Gruppe sofort von der Veranstaltung disqualifiziert.
Entwurf: In dieser Phase hat jede Gruppe die Möglichkeit, einen „klassischen“
Entwurf oder Prototyp auszuwählen. Vor dem zweiten Quality Gate werden
Walkthroughs3 durchgeführt, bei dem jede Gruppe die Möglichkeit hat, mittels der
Vorstellung ihrer Arbeit ein Feedback von Seiten der anderen Gruppen und
Gutachtern zu erhalten. Das Erfüllungskriterium für den zweiten Quality Gate sind die
Dokumente, die entweder Entwürfe oder Prototypen beschreiben. Pseudo Code oder
Codes der Prototypen gehören ebenfalls dazu.
Implementierung und Test: Das zu entwickelnde Programm wird in dieser Phase
kodiert. Anschließend wird das Programm getestet. Die Testmethoden der Software
Engineering wie Äquivalenzklassen oder Grenzwertanalyse sollen in dieser Phase
verwendet werden. Bei dem Quality Gate muss ein lauffähiges Programm erstellt
werden.
Inbetriebnahmephase: Nach der Implementierungsphase wird das von jeder Gruppe
entwickelte Software-Produkt von dem Betreuer in Betrieb genommen und danach
abgenommen.
LIDs:4 Kurz vor dem Abschluss wird das LID durchgeführt, um die Erfahrungen der
Studierenden zu sammeln. Darüber hinaus haben die Studierenden die Möglichkeit,
den Ablauf des ganzen Projekts anzusehen. Viele Aspekte wie z.B. Typ, Häufigkeit,
Ziele, Erwartungen, Hoffnungen und Risiken der Aktivitäten werden bewertet und
2 Greive, J., Entwurf und Implementierung eines Systems zur netzbasierten. S. 1 ff.
3 Beschreibung des Verifizierens von Algorithmen und Quellcode. Dadurch soll festgestellt werden, ob der Algorithmus bzw. Quellcode den gestellten Anforderungen genügt. 4 Ein Modell zur systematischen Software-Prozessverbesserung.
2 Konzepte
7
dokumentiert, und die Berichte werden verwendet, um die nächste Veranstaltung zu
verbessern5.
Um die Veranstaltung erfolgreich zu bestehen, muss jede Gruppe alle Quality Gates
erfüllen und an der Abschlussveranstaltung teilnehmen.
2.2 Grundlagen
2.2.1 Definitionen
Im Folgenden werden kurz zwei Begriffe definiert und erläutert, die in dieser
Bachelorarbeit verwendet werden.
Das Projekt ist ein Vorhaben, das in seiner Wesenheit durch eine Einmaligkeit der
Bedingungen in ihrer Gesamtheit gekennzeichnet ist, z.B. durch Zielvorgabe, zeitliche,
finanzielle, personelle und andere Begrenzungen, Abgrenzungen gegenüber anderen
Vorhaben und projektspezifische Organisation [DIN-Norm 69901].
Der Begriff „Projekt“ wird von Josef Schwab anders interpretiert. Nach ihm existiert das
Projekt nur, wenn ein Planungsbedarf vorhanden ist. Ohne Planungsbedarf gibt es kein
Vorhaben zu planen und durchzuführen. Vielmehr wird die Projektorganisation aufgebaut
und die Abfolge der Vorgänge definiert und erbracht, wenn ein Planungsbedarf vorhanden
ist. Mit anderen Worten. Es ergibt sich der Planungsbedarf aus der Notwendigkeit, ein
Projekt zu planen.
Das Projekt im Rahmen der Softwareprojekt-Veranstaltung wird mit den Aspekten von
Zielvorgabe, zeitlicher und personeller Begrenzung berücksichtigt.
Bei der Zielvorgabe sollen Studierende durch die Veranstaltung praktische
Erfahrungen mit der Softwareentwicklung erwerben.
Das ganze Projekt findet in einem festgelegten Zeitraum statt.
Die Anzahl von Mitarbeitern und Studierenden wird im Rahmen des Projekts
begrenzt.
Das Projektmanagement geht von zwei Konzepten aus: „einmal das Leitungskonzept, das
die zur Projektdurchführung notwendigen Aufgaben definieren hilft und die zur Lösung
dieser Aufgaben notwendigen Methoden zur Verfügung stellt, Sowohl die
5 Schneider, K., Abenteuer Software-Qualität. S. 43.
2 Konzepte
8
Systemgestaltung als auch das Projektmanagement stützen sich dabei auf bewährte
Techniken, Hilfsmittel und Verfahren ab“.6
Der Begriff „Projektmanagement“ im engeren Sinn der Softwareprojekt-Veranstaltung
bezieht sich auf die Aufgabe, mit notwendigen Methoden im Bereich von
Personalverwaltung und Aktivitätsverwaltung den Verwaltungsaufwand zu verringern.
2.2.2 Personalplanung
Im Rahmen der Softwareprojekt-Veranstaltung spielen die Erfahrungen und Fähigkeiten
der Studierenden eine entscheidende Rolle und müssen bei der Schätzung berücksichtigt
werden. Für die Auswahl von Studierenden für jedes Team werden die teilnehmenden
Vorlesungen und Erfahrungen zusammengefasst, um daran orientiert die Zuweisung
vorzunehmen. Die Rolle von Projektleiter und Qualitätsbeauftragtem in jedem Team wird
demselben Team nach Vereinbarung mit den anderen Teammitgliedern zugewiesen.
Dadurch hat aber der Projektleiter die Übersicht über einem Team mit den zuständigen
Personen. Durch die Erfahrungen und Fähigkeiten der Teammitglieder und die
Schwierigkeiten des Projekts sowie andere Kriterien kann die Anzahl von Mitgliedern
jedes Teams unterschiedlich sein. Um das Projekt zum Erfolg zu bringen, sollten die
Studierenden fair und sinnvoll auf die einzelnen Teams verteilt werden.
2.2.3 Zeitplanung
Im Allgemeinen stellt die Grundlage der Zeitplanung zunächst das Definieren einer
Zeiteinheit dar, die zum Beispiel Tage, Wochen oder Monate sein kann. Die Zeitplanung
wird im Rahmen dieser Bachelorarbeit mit Hilfe des Gantt-Charts7 veranschaulicht.
6 Hans-D. Litke: Projektmanagement. Methode, Techniken, Verhaltensweisen, S. 11.
7 Oder als Balken-Diagramm benannt. Das Diagramm ist die beim Projektmanagement am häufigsten benutzte Präsentationsform, Kerzner, H., Projektmanagement. Ein systemorientierter Ansatz zur Planung und Steuerung, S. 508.
2 Konzepte
9
Abbildung 2: Screenshot eines Beispiels für Prozessverwaltung von entwickeltem
PMW
Die Aufgabe der Zeitplanung im Rahmen der Softwareprojekt-Veranstaltung lautet, die
Prozesse zeitlich zu zuordnen und zu definieren. Dadurch werden das Beginn, das Ende
und die Ausführungsdauer eines jeden Prozesses und des gesamten Projekts erfasst.
Jeder Prozess hat bestimmte Zeitbedingungen und Terminvorgabe, die ermittelt werden
sollen. Die Zeitbedingungen werden von dem Mitarbeiter des SE-Instituts bestimmt. Es
gibt viele Aspekte wie zum Beispiel den Urlaub der SE-Mitarbeiter, die Feiertage usw. die
die Terminvorgabe beeinflussen. Damit fließen Abweichungen vom Beginn und Ende
eines jeden Prozesses in die Gesamtplanung ein. Die Softwareprojekt-Veranstaltung
findet alle zwei Semester in dem gleichen Zeitraum jedes Jahres statt. Dadurch hängt die
Schätzung der bestimmten Dauer für die Prozesse meist von der Zuständigkeit der SE-
Mitarbeiter ab8.
2.3 Analyse von verschiedenen Werkzeugen
2.3.1 PHProject
PHProject ist eine PHP9-basierte Open source-Software unter der GPL10 und wird in
kleinen bis mittelgroßen Projektteams eingesetzt. Das Programm läuft auf einem Server
als eine Web-Applikation und benötigt auf der Seite des Clients keine Software. Diese
8 Wenzel, J., Meusel, J., Schlomm, O., Netzplantechnik im Eventmanagement, S. 7. 9 Zum Begriff PHP vgl. Beisecker, M.A., Das Lexikon der PC-Fachbegriffe 2005/2006, S. 270.
10 Zum Begriff GPL vgl. ebenda, S. 170.
2 Konzepte
10
Applikation funktioniert mit verschiedenen Benutzergruppen und mit verschiedenen
Rollen. Es gibt insgesamt drei Arten von Benutzern:11
Administrator
Nutzer mit Chefrechten
Normale Nutzer
Abbildung 3: Screenshot für PHProjekt
Quelle: www.phprojekt.com
Die Applikation löst viele Kernaufgaben des Projektmanagements12 wie Terminplanung,
Personalmanagement und Projektsteuerung. Die Applikation ermöglicht den Ablauf mit
Hilfe des Gantt-Diagramms. Die Applikation hat aber einen großen Vorteil bei der
Kommunikation zwischen allen Projektmitarbeitern. Es gibt viele Werkzeuge, die der
Kommunikation via Emails, Foren, File-Sharing und Chat-Room dienen. Mit Hilfe eines
Mail-Client wie Microsoft Outlook können Email-Daten verwaltet werden. Mit der
Unterstützung von Foren und Chat werden die Nachrichten zwischen Projektteilnehmern
direkt ausgetauscht. Die Kontakte eines Projektteilnehmers mit anderen werden über die
Kontaktverwaltung zusammengefasst und danach in Terminen, Aufgabe und Projekten
abgelegt.
Diese Software bietet aber keine Schnittstelle an, mit der die Informationen von allen
Studierenden in die Software importiert werden können. Die Erstellung der Vorlage wird in
11 Janke, S., Günther, A., PHProjekt – ein Open Source Groupware Suite, unter: http://fmr.ilr.tu-
berlin.de/manual-0.8.html. 12
Buhl, A., Grundkurs Software-Projektmanagement, S. 3.
2 Konzepte
11
der Software nicht integriert, und die Email kann auch nicht zu einem festgelegten
Zeitpunkt gesendet werden.
2.3.2 OpenProj
OpenProj ist eine Open Source-Alternative zu Microsoft Project. OpenProj ist ein sehr
umfangreiches und vielseitiges Projektmanagement-Werkzeug. Im Gegensatz zu
PHProject ist OpenProj eine Desktop-Applikation, die mit Java entwickelt wurde. Der erste
Vorteil von OpenProj ist die Schnittstelle mit einem anderen Projektmanagement-
Werkzeug wie Microsoft Project. Das Programm bietet eine Schnittstelle an, mit der der
Benutzer die Projekte von Microsoft (MS) Project öffnen kann. Die Oberfläche ist nicht
sonderlich verschieden von derjenigen von MS Project. Im Vergleich mit PHProject hat
OpenProj viele Aspekte des Projektmanagements abgedeckt. Die Strukturplanung,
Termin- und Zeitverwaltung ist ausführlich dargestellt und ist mit Hilfe von Balken-
Diagrammen auch sehr übersichtlich. Ressourcen-, Personal- und Kostenverwaltung
werden ebenfalls berücksichtigt. Das Programm verfügt über viele Diagramme wie z.B.
Work Breakdown Structure (WBS) in Kostenverwaltung, Resource Breakdown Structure
in Ressourcenverwaltung und Aufwanddiagramm. Mit Hilfe der Berichte-Funktion bietet
das Programm einen Überblick mit den wichtigsten Informationen für Projektleiter. Das
Programm hat viele allgemeine Vorteile hinsichtlich des Projektmanagements, doch im
Rahmen der Software-Projekt-Veranstaltung bringt das Programm nicht viel. Die Import-
Funktionen mit einer vom SE-Institut formatierten Datei sind nicht möglich, weshalb kann
der Projektleiter die Studierenden und Gruppen nicht vernünftig verwalten kann. Eine
Email-Vorlage kann bei dem Programm ebenfalls nicht erstellt und verwendet werden.13
13 SERENA Software, Inc. OpenProj. http://www.serena.com/ products/openproj/
2 Konzepte
12
Abbildung 4: Screenshot für OpenProj
2.3.3 Microsoft Project
Microsoft Project ist eine auf dem Markt bekannte Projektmanagement-Software. Diese
Software wird bei vielen kleinen und mittelständischen Unternehmen eingesetzt. Mit der
Kombination von Microsoft Project und Microsoft Project Server werden sowohl die
Einzelprojektplanung und -steuerung als auch die Verwaltung einer Vielzahl von Projekten
unterstützt.14 Folgende Punkte des Microsoft Project werden berücksichtigt:
MS Project unterstützt die Prozessoptimierung. Der Ablauf der Prozesse in einem
Projekt wird über das Programm sehr ausführlich beschrieben. Mit der Export-
Funktion werden die Prozesse in ein Programm exportiert, und danach werden die
Zeiten mittels Netzplantechnik berechnet.15
Auch die Kostenplanung wird in MS Project ausführlich beschrieben. Diese hat aber
im Rahmen der Softwareprojekt-Veranstaltung keine Bedeutung.
14GPM InfoCenter. „Auf dem Weg zu Mitliprojektmanagement als Unternehmensstrategie.
http://www.pmaktuell.org/uploads/PMAktuell-200204/PMAktuell-200204-034-Public.pdf (Zugriff am 21. 08 2012). 15
Schwab, J., Geschäftsprozessmanagement mit Visio, ViFlow und MS Project, S. 206.
2 Konzepte
13
Die Personalverwaltung wird ausführlich und mit Unterstützung von vielen
Diagrammen veranschaulicht.16
Unterstützung von verwandten Produkten von Microsoft: Die Daten und Berichte eines
Projekt können in eine Excel-Datei oder nach Microsoft Visio exportiert werden.
Das Programm ist jedoch für folgende Aspekte der Softwareprojekt-Veranstaltung nicht
geeignet:
Das Programm bietet viele Funktionen, um Personen in einem Projekt zu verwalten.
Es gibt aber viele zu einer Person gehörende Informationen wie Arbeitsstunden,
Kosten pro Person usw., die im Rahmen der Softwareprojekt Veranstaltung unnötig
sind. Mit solchen Informationen könnte der Projektleiter die Übersicht und die
wichtigsten Informationen über die Studierenden verunklaren.
Die Importierung von Studierenden über eine CSV-Datei mit einem vom SE-Institut
bestimmten Format ist nicht möglich. Der Aufwand, um Informationen von
Studierenden zu sammeln und zu verwalten, kann nicht verringert werden.
Mit der Kombination mit anderen Produkten von Microsoft kann das Programm auch
Emails senden. Die Inhalte der Emails werden aber manuell erfasst. Die
wiederkehrende Kommunikation, die in der Einleitung erläutert wird, kann in diesem
Fall nicht erleichtert werden.
Von daher soll ein eigenes, Projektmanagementwerkzeug-spezifisches Software-Projekt
entwickelt werden.
16 Schwab, J., Projektplanung realisieren mit Project 2007. Das Praxisbuch für alle Project-
Anwender, S. 178-188.
2 Konzepte
14
Abbildung 5: Screenshot für MS Project
Quelle: http://upload.wikimedia.org/wikipedia/en/thumb/0/0b/MSProj2010.PNG/640px-MSProj-
2010.PNG
3 Anforderungen
15
3 Anforderungen
In diesem Kapitel werden alle Anforderungen aufgelistet und nacheinander erläutert.
3.1 Anforderungen
Anforderungen lassen sich vor allem aus zwei verschiedenen Quellen ableiten – und zwar
einerseits aus dem Ablauf eines tatsächlich durchgeführten Softwareprojektes an der
Leibniz-Universität Hannover. Weitere Anforderungen ergeben sich aus der Definition
sowie den Aufgaben und Aspekten des Projektmanagements.
Folgende grundlegende Anforderungen werden an den PMW gestellt:
1. Es soll ein Projekt mit dazugehörigen Informationen wie Projektleiter,
Anfangstermin, Endtermin und Beschreibung stellen:
Die zu den allgemeinen Informationen des Projekts gehörenden müssen unbedingt
angegeben werden, um das Projekt in jedem Jahr zu unterscheiden. Das Wort
„Projekt“, das in dem PMW verwendet wird, ist im Sinn jeder jährlichen
Softwareprojekt-Veranstaltung.
2. Jedes Projekt soll Personen und die dazugehörigen Informationen verwalten:
Diese Anforderung beinhaltet, dass die Informationen von Studenten bearbeitet und
aktualisiert werden können.
3. Es soll Personen von einer CSV-Datei importieren:
Nach dem im Kapitel 2.1 beschriebenen Anmeldungsprozess werden sich alle
Studierenden über ein vom SE-Institut bereitgestelltes Registrierungswerkzeug
anmelden. Die Informationen werden im System gespeichert. Das System kann
solche Informationen in Form einer CSV-Datei exportieren. Mit dem Importieren
solcher Dateien werden Informationen aller Studierenden in dem Programm
gespeichert.
4. Es soll von der importierten CSV-Datei aus die Gruppe anlegen:
In der oben genannten CSV-Datei sind die verschiedenen Themen enthalten. Jedes
Thema kann mehrmals auftauchen, weil jeder Studierende zwei Themen auswählen
kann. Davon soll zuerst eine Liste von Themen erstellt und danach für jedes
eindeutige Thema eine Gruppe bzw. ein Team automatisch erstellt werden.
3 Anforderungen
16
5. Es soll eine neue Person mit den dazu gehörenden Informationen erstellt
werden:
Es könnte passieren, dass ein Student sich erst spät anmeldet und seine
Informationen nicht in oben genannter CSV-Datei enthalten sind. Parallel zur dritten
Anforderung soll das Programm eine Möglichkeit anbieten, dass der Projektleiter neue
Studierende anlegen kann.
6. Die Gruppe soll manuell erstellt werden:
Es könnte passieren, dass z.B. die Anzahl von Studierenden nicht zu der Anzahl von
Themen passt. Dann soll eine neue Gruppe manuell angelegt werden können, was
das Programm ebenfalls leisten sollte.
7. Jede Person soll zu einer bestimmten Gruppe zugeordnet werden:
Jeder Studierende gehört zu einer bestimmten Gruppe. Das Programm soll dem
Projektleiter die Möglichkeit bieten, dass er die Studierenden in die Gruppen einteilen
kann.
8. In jeder Gruppe soll die PL- und die QA-Rolle an einen bestimmten Studenten
zugewiesen werden:
In jeder Gruppe gibt es zwei zuständige Personen mit zugewiesener Rolle: einen
Projektleiter und einen Qualitätsbeauftragten. Das Programm soll die Rolle den
Studierenden zuweisen. Es soll nur jeweils einen Projektleiter und einen
Qualitätsbeauftragten in jeder Gruppe geben. Jedem Studierenden soll maximal eine
Rolle zugewiesen werden.
9. Es soll eine „Send Mail“-Funktion geben:
Im Laufe eines Projektes soll der Projektleiter viele Emails an die Studenten zu den
verschiedenen Aktivitäten und aus den entsprechend unterschiedlichen Gründen
schicken. Eine „Send Mail“-Funktion soll geboten werden.
10. Um Emails zu senden, soll die Vorlage verwendet werden:
Der Projektleiter hat zwei Möglichkeiten, eine Email zu senden. Er kann neue Emails
verfassen. Für die Emails, deren Inhalt denen der vorherigen Veranstaltung ähnlich
ist, kann der Projektleiter eine Vorlage verwenden. Der Inhalt der Emails lässt sich
vorher einstellen.
3 Anforderungen
17
11. Emailvorlage soll verwaltet und bearbeitet werden:
Jede Emailvorlage hat einen eindeutigen Inhalt. Der Inhalt jeder Vorlage soll in jeder
Zeit bearbeitet und aktualisiert werden können.
12. Prozesse sollen mit Anfang- und Endtermin erstellt und verwaltet werden:
Jeder Prozess findet in einem bestimmten Zeitraum statt. Um die Prozesse zu
verwalten, soll der Anfangs- und Endtermin beim Ablauf des Prozesses angegeben
werden.
13. Für die „Send Mail“-Funktion soll es eine Vorschaumöglichkeit geben:
Vor dem Senden der Emails soll der Projektleiter die Möglichkeit haben, die Inhalte
der Email zu kontrollieren. Alle zu sendenden Emails mit den dazu gehörenden
Informationen wie Betreff, Empfänger oder Anhänge sollen anschaulich aufgelistet
werden.
Niedrigere Priorität haben folgende Anforderungen:
14. Die Installation soll einfach und schnell ermöglicht werden:
Der Projektleiter soll in wenigen Schritten das Programm konfigurieren und in den
Betriebszustand bringen können.
15. Für die „Send Mail“-Funktion soll es eine Statistik der gesendeten Emails
geben:
Um die Kommunikation mit Studierenden über Emails zu kontrollieren, soll der
Projektleiter die Möglichkeit haben, die Statistik zu den gesendeten Emails (wie z.B.
die Anzahl von gesendeten Emails, die Anzahl von Gruppen, an die Emails gesendet
wurden, und die Anzahl von gesendeten Emails je Gruppe) anschauen zu können.
3.2 Anwendungsfälle
In diesem Kapitel werden die vom Kunden gewünschten Funktionen zur Verwaltung des
Softwareprojekts in Form von Anwendungsfällen beschrieben. Die Abbildung 6 beschreibt
den Zusammenhang zwischen den wichtigsten Teilen des Programms. Dabei bezieht sich
der Abschnitt 3.2.1 auf die Durchführung der Personalverwaltung, während die
Anwendungsfälle in Abschnitt 3.2.2 die Aktivitätsverwaltung betreffen. Alle
Anwendungsfälle wurden mit dem Kunden abgestimmt und von ihm abgenommen.
3 Anforderungen
18
Abbildung 6: Zusammenhang von wichtigen use-cases
3.2.1 Personalverwaltung
Die Anwendungsfälle, die unten beschrieben werden, beziehen sich auf das UML17-
Anwendungsfalldiagramm in Abbildung 3.
Anwendungsfall PV1: Student anlegen
In der Ansicht der Personalverwaltung kann der Projektleiter einen neuen Studenten
anlegen. Dazu muss er folgende Informationen angeben:
Vorname und Nachname der Studierenden
17 Unified Modelling Language, Modellierungssprache.
3 Anforderungen
19
Email und Matrikel der Studierenden
Erste und zweite Wahl der Studierenden
Die Vorlesungen, an denen die Studierenden teilgenommen haben.
Die Erfahrungen der Studierenden
Teamzugehörigkeit der Studierenden
Beim Anlegen werden Informationen direkt in die Datenbank hinzugefügt, bevor danach
die Hauptansicht aktualisiert wird.
Anwendungsfall PV2: Student bearbeiten
Zu jedem bereits vorhandenen Studierenden kann der Projektleiter die Informationen
bearbeiten. Die Informationen werden in der Datenbank aktualisiert, und danach wird die
Ansicht aktualisiert.
Abbildung 7: Screenshot für die Informationsverwaltung einer Studierenden
Anwendungsfall PV3: Team anlegen
Jeder Studierende soll einem Team zugewiesen werden. Deswegen soll der Projektleiter
auch die Möglichkeit haben, um ein neues Team anzulegen. Das neue Team beinhaltet
am Anfang nur den Namen. Der Entwurfstyp wird als „default“ dem klassischen Entwurf
zugewiesen. Die Studierenden, die zu dem neuen Team gehören, können
Anwendungsfall 1 oder 2 zugewiesen werden.
Anwendungsfall PV4: Team bearbeiten
Der Projektleiter soll die Möglichkeit haben, ein Team zu bearbeiten. Für jedes Team
kann der Projektleiter einer Person die Projektleiter-Funktion und einer anderen die
Qualitätsbeauftragten-Rolle im Team zuweisen. Außerdem kann der Entwurfstyp für jedes
Team verändert werden. Der Name des Teams soll ebenfalls verändert werden können.
3 Anforderungen
20
Abbildung 8: Screenshot für die Verwaltung eines Teams
Anwendungsfall PV5: Email an Team senden
Eine Email an ein Team zu senden ist eine Möglichkeit zur Verbesserung der
Kommunikation zwischen Projektleiter und Studierenden. Die Email-Adressen der
Teammitglieder werden an Übersicht über die Email-Versendung weitergeleitet. Danach
kann der Projektleiter die Inhalte der Emails verfassen und sie an die Teammitglieder
senden.
Abbildung 9: Anwendungsfalldiagramm der Personalverwaltung
3 Anforderungen
21
3.2.2 Aktivitätsverwaltung
Nach dem Öffnen des Projekts soll die Hauptsicht von der Aktivitätsverwaltung geöffnet
werden können. Die Anwendungsfälle beziehen sich auf die Abbildung 10
Anwendungsfall AV1: Aktivität anlegen
In der Hauptsicht der Aktivitätsverwaltung hat der Projektleiter die Möglichkeit eine neue
Aktivität anzulegen. Die neue anlegende Aktivität kann entweder Root-Akvitität18 oder
auch ein Kind-Aktivität19 sein. Dazu werden allgemeine Informationen wie Name, Anfang-
und Enddatum der Aktivität angegeben.
Anwendungsfall AV2: Aktivität bearbeiten
Neben den bereits vorhandenen Aktivitäten soll der Projektleiter die zu einer Aktivität
gehörenden Informationen auch verändern können. Die veränderten Informationen
werden in der Datenbank aktualisiert danach wird die Ansicht mit Konfigurationen
aktualisiert.
Anwendungsfall AV3: Konfigurieren der Sicht
Die Übersicht über die Aktivitäten kann mittels der Konfigurationen unterschiedlich
angezeigt werden. Wenn der Projektleiter die Aktivitäten zeitlich unterschiedlich anzeigen
möchte, kann er die Konfiguration der Spalte verändern. Dazu kann auch die Breite von
Zeilen verändert werden.
18 Die oberste Aktivität und hat keine andere Aktivität, die mit der abhängt.
19 Die hat noch eine obere Aktivität, mit der die verbindet.
3 Anforderungen
22
Abbildung 10: Anwendungsfalldiagramm der Aktivitätsverwaltung
3.3 Qualitätsanforderungen
In diesem Abschnitt werden die Anforderungen an die Qualität des zu entwickelnden
Projektmanagement-Werkzeugs aufgelistet und erläutert. Diese sind Benutzbarkeit,
Wartbarkeit und Zuverlässigkeit.
3.3.1 Benutzbarkeit
Die Anwendung soll mit der aktuellen Java 1.7-Software ohne Probleme verwendbar sein;
ebenso soll mit kontextspezifischer Hilfe die Einarbeitung für Anwender verkürzt werden.
Die Oberfläche soll einfach und effizient zu benutzen und konsistent sein. Dazu sollen die
folgenden Qualitätsfaktoren betrachtet werden:
Eine kurze Anleitung soll in gut lesbarer Form vorhanden sein.
Die Oberflächenelemente sollen sprachlich verständlich sein und kurz beschrieben
werden.
3 Anforderungen
23
Beim Hinzufügen eines neuen Oberflächenelements sollen die anderen Elemente
nicht verschoben werden.
Die Schaltflächen und Checkbox sind groß genug, damit der Benutzer diese ohne
Mühe anklicken kann.
Beim Verbindungsaufbau mit dem Mail-Server soll die Rückmeldung zurückgegeben
werden.
Im Fall eines Fehlers soll eine Fehlermeldung angezeigt werden, damit der Benutzer
wenigstens weiß, woher der Fehler stammt.
3.3.2 Wartbarkeit
Das System soll leicht erweiterbar sein, um künftige Entwicklungen einfach integrieren zu
können. Dabei werden folgende Faktoren betrachtet:
Neue Komponenten sollen in das Programm integriert werden können, ohne andere
vorhandene Komponenten umzustrukturieren.
Das Verhalten zwischen Oberflächenelementen (wie z.B. die Größe der Schaltflächen,
die Reihenfolge der Spalten in einer Tabelle, die Schriftgröße, der Abstand zwischen
Elementen) innerhalb einer Komponente soll leicht verändert werden können, ohne
andere Komponenten zu beeinflussen.
Die neuen Tabellen oder die neuen Spalten der vorhandenen Tabellen in der
Datenbank sollen ohne Einfluss auf andere Tabellen oder Spalten angelegt werden
können.
Technische Dokumentationen sollen vorhanden sein, um die Einarbeitungszeit zu
verkürzen.
3.3.3 Zuverlässigkeit
Weil die Anwendung die Veranstaltung „Softwareprojekt“ unterstützt, um mit weniger
Aufwand das Projekt zu verwalten, soll die Applikation zuverlässig laufen. Folgende
Faktoren werden berücksichtigt:
Bei dem Import muss die Import-Datei geprüft werden, wobei die Änderungen, welche
die Integrität der Daten verletzen würden, unterbunden sein müssen.
Die Email-Vorlagen müssen konsistent sein, und die „Send Mail“-Funktion soll vor
dem Senden geprüft werden, um die Emails an die richtige Adresse senden zu
können.
3 Anforderungen
24
Die von der Datenbank abgefragten Daten sollen richtig und genug auf der Oberfläche
angezeigt werden.
Bei einem zweiten Zugriff auf die Datenbank wird eine Fehlermeldung zurückgegeben,
damit die Richtigkeit und die Sicherheit der Daten gewährleistet sind.
3.4 Risiken
Vor der Implementierung sind gewisse Risiken vorhersehbar, die mit dem Prototyp
untersucht werden, um die Hauptfunktionen des Programms richtig umsetzen zu können.
Folgende mögliche Risiken können auftreten:
Prototyp PT1: Die Oberfläche der Software ist nicht konsistent. Durch Vorlage eines
Oberflächenprototyps lassen sich eventuelle Differenzen zwischen der Vorstellung
über die Oberfläche und der Konsistenz der Oberfläche beim Laufen des Programms
frühzeitig erkennen.
Prototyp PT2: Die Netzwerkverbindung kann nicht hergestellt werden (z.B. wegen
Problemen bezüglich der Firewall, der Internetgeschwindigkeit, nicht unterstützter
Ports beim Mail-Server). Durch den zweiten Prototyp wird die Netzwerkverbindung mit
einem Mail-Server genauer untersucht: Vor allem ist eine Methode gesucht, die
unkompliziert die Verbindung mit einem Mail-Server herstellen, um damit Emails
senden zu können.
Prototyp PT3: Der in Emails verwendete gekoppelte Schlüssel-Wert liefert ein
falsches Ergebnis. Der gekoppelte Schlüssel-Wert sollte untersucht werden, um die
Genauigkeit zu gewährleisten. Weil die Werte von SQL-Anfragen in der Laufzeit des
Programms ausgewertet werden, soll die Stabilität des Algorithmus untersucht
werden.
Prototyp PT4: Verlust von Daten oder falsche Daten beim CSV-Importieren. Beim
Importieren einer CSV-Datei könnte es passieren, dass die zu importierende Datei
beschädigt ist oder das falsche Format hat. Um die Daten zu überprüfen und mögliche
Datenverluste zu vermeiden, sollte das Verfahren des Importierens untersucht
werden.
Prototyp PT5: Die integrierte Datenbank (HSQL) funktioniert nicht richtig, so dass die
Daten nicht gespeichert werden können. Eine kleine Datenbank wird in der
3 Anforderungen
25
Anwendung integriert. Die Datenbank braucht keinen Server zu treiben, weshalb es
notwendig ist, die Funktionen mit der Datenbank zu untersuchen, um die Konsistenz
des Datenaustauschs zu sichern.
Die Ergebnisse der Prototypentwicklung werden im Kapitel 4.1 erläutert und analysiert.
4 Projektumsetzung
26
4 Projektumsetzung
In diesem Kapitel werden die Strukturen des Programms mit den Paketen und
Beziehungen zwischen Entities detailliert erläutert. Anschließend werden die
Implementierung des wichtigsten Teils und die dazu verwendeten Werkzeuge und
Bibliotheken erläutert.
4.1 Ergebnisse der Prototypenentwicklung
Vor der Implementierung werden in diesem Abschnitt die Ergebnisse der Prototypen, die
im Abschnitt 3.4 aufgelistet wurden, erläutert und analysiert, um die vorhergesehenen
Risiken zu beseitigen.
Ergebnisse von Prototyp PT1: Durch den Oberflächenprototypen wurden die
Anforderungen an die Oberfläche des Programm erneut verfeinert.
Um die Oberfläche zu erstellen, wird das Eclipse-Plugin „Window Builder“ verwendet. Mit
Hilfe dieses Plugin kann Java GUI einfach und schnell erstellt werden. Dieses Plugin
verwendet WYSIWYG visuell Designer und Layout-Werkzeuge um von einfacher Form bis
komplizierter Windows zu erstellen. Alle Oberflächenkomponenten können ganz einfach
mit „Drag-and-Drop“ positioniert werden. Daneben gibt es viele Eigenschaften der
Komponenten, die mit Hilfe des Eigenschaften-Editors verändert werden können.
Ergebnisse von Prototyp PT2: Die Netzwerkverbindung mit einem Mail-Server wird mit
Hilfe von JavaMail API erstellt. Das JavaMail API ist ein optionales Paket zum Lesen,
Erstellen und Versenden von elektronischen Meldungen. JavaMail stellt einen
protokollunabhängigen Zugriff auf Message dar, und zwar zum Senden und Empfangen.
Das API besteht aus zwei Teilen:
Der erste Teil des APIs wird in diesem Modul behandelt. Dabei geht es um das
Senden und Empfangen von Messages, unabhängig vom Provider/Protokoll.
Der zweite Teil behandelt protokollabhängige Fragen wie SMTP, POP3 und IMAP.
Das Simple Mail Transfer Protocol (SMTP) wird im RFC 821 definiert. Das Protokoll
definiert die grundlegenden Mechanismen zum Abliefern einer Email. Das auf JavaMail
API bzw. JavaMail basierende Test-Programm wird mit dem Internet Service Provider
(ISP)-SMTP-Server kommunizieren. In dem Test-Programm wird der SMTP-Server von
Google verwendet. Mit dem TLS-Port 587 wird eine Verbindung in 1 bis 3 Sekunden
aufgebaut. Es braucht genauso viel Zeit, eine normale Text-Mail ohne Anhang zu senden.
4 Projektumsetzung
27
Die Zeit, die eine Email mit Anhang zu senden ist, ist von der Anzahl und Größe der
Anhänge abhängig. Bei falschem Benutzernamen oder Passwort braucht das Test-
Programm 3 bis 5 Sekunden, um Fehler-Fenster anzuzeigen. Es dauert aber deutlich
länger, wenn ein falscher Port angegeben wird. Es dauert dann 20 bis 25 Sekunden, um
in diesem Fall ein Fehler-Fenster anzuzeigen. Darüber hinaus wird die
Netzwerkverbindung mit einem Mail-Server erfolgreich untersucht. Mit diesem Prototyp
wird gewährleistet, dass das Programm mit einem Mail-Server kommunizieren kann,
damit die „Send Mail“-Funktion realisiert werden kann.
Ergebnisse von Prototyp PT3: Das Schlüssel-Wort wird für die Email-Vorlage
verwendet. Dies spielt die Rolle von einem Platzhalter. Vor dem Senden einer Email
stehen im Email-Inhalt diese Schlüssl-Worte. Bei dem Senden wird Email-Inhalt noch mal
ausgewertet. Alle Schlüssel-Worte werden mit ihren Werten ersetzt. Dies Schlüssel-Wort
hat vordefinierte „Werte“. Der Wert kann entweder ein normaler Wert in der Form von
einer Zeichenkette vom Typ String oder eine SQL-Anfrage sein. Die SQL-Anfrage kann
zum anderen Zeitpunkt ausgewertet. Es gibt drei Typen von dieser SQL-Anfrage
Eine normale SQL-Anfrage hat keine verbundene Variable und Schlüssel-Worte und
kann sofort ausgewertet werden. Mit Hilfe dieser Anfrage kann man die Werte von der
Datenbank direkt in ein Schlüssel-Wort auslagern und dieses danach in der Email-
Vorlage verwenden.
4 Projektumsetzung
28
Abbildung 11: Screenshot für SQL-Typ 1
Eine SQL-Anfrage, in der ein anderes Schlüssel-Wort verwendet wird: Bei der
Auswertung solcher Anfragen wird das innere Schlüssel-Wort zuerst ausgewertet,
bevor die Werte vom Schlüssel-Wort in seiner Position ersetzt werden. Zum Schluss
wird die Anfrage mit ersetzten Werten vom Schlüssel-Wort ausgewertet. Diese
Anfrage kann sofort ausgewertet werden.
4 Projektumsetzung
29
Abbildung 12: Screenshot für SQL-Typ 2
Eine SQL-Anfrage, in der eine Variable verwendet wird: Diese Variable ist im Grunde
die Email-Adresse, die in der Laufzeit des Programms zugewiesen wird. Die
Auswertung solcher Anfragen verläuft an sich genauso wie der zweite Typ. Sie kann
aber nicht sofort ausgewertet werden, weil die Anfrage von der Variable abhängt.
Nachdem die Werte der Variable zugewiesen werden, kann die Anfrage ausgewertet
werden.
4 Projektumsetzung
30
Abbildung 13: Screenshot für SQL-Typ 3
Das Ersetzen des Schlüssel-Wortes oder der Variable mit ihren Werten muss richtig sein
und in allen Positionen in der Anfrage geschehen, wo diese auftauchen. Wenn eine
Position fehlt oder die zurückgelieferten Werte des Schlüssel-Wortes oder der Variable
falsch sind, stimmt die Auswertung der Anfrage nicht mehr. Um diese Verfälschung zu
vermeiden, wird die Email-Vorschau bereitgestellt. Der Prototyp wurde erfolgreich
untersucht. Das Schlüssel-Wort gibt die Werte an, wie es sein soll. Dies gewährleistet,
dass die versendeten Email-Inhalte korrekt sind.
Ergebnisse von Prototyp PT4: Die vom SE-Institut bereitgestellte CSV-Datei hat ein
bestimmtes Format, und bei der Importierung sollen die Daten in die entsprechende
Tabelle in der Datenbank übertragen werden. Der Inhalt der CSV-Datei wird bei der
Importierung geprüft. Wenn das Format nicht richtig ist, wird die Importierung sofort
abgebrochen. Die Datensätze werden Zeile für Zeile ausgelesen und in die Datenbank
übertragen. Auch die Laufzeit der Importierung wird untersucht. Da die Anzahl der
4 Projektumsetzung
31
Studenten, die an der Software-Projekt-Veranstaltung teilnehmen, nicht sonderlich groß
ist, wird das Importieren sehr rasch abgeschlossen sein.
Ergebnisse von Prototyp PT5: Um die HSQL-Datenbank zum Laufen zu bringen, muss
man den richtigen Pfad angeben. Die Verbindung wird in einem kurzen Augenblick
aufgebaut, und die Tabelle kann problemlos erstellt werden. HSQL unterstützt große Teile
der SQL-Standards 92, 93 und 2003. Die Typen von Spalten und Constraints werden
ebenfalls standardisiert. Die Daten wurden richtig und schnell zurückgeliefert. Auch bei
der Aktualisierung oder beim Hinzufügen eines Datensatzes wurde der Fehler mit
Foreign-Key- und Unique-Constraint richtig behandelt. Mit der erfolgreichen Untersuchung
dieses Prototyps wird sichergestellt, dass alle Funktionen, die die Daten in der Datenbank
manipulieren, realisiert werden können.
4.2 Software
Das Programm wird als Desktop-Applikation entwickelt. Um die Programmierungsarbeit
zu erleichtern, werden folgende Open-Source-Bibliotheken verwendet:
Jcalendar ist eine Bibliothek, mit der über eine einfache GUI das Datum schnell
ausgewählt werden kann.
Javamail API stellt die Klassen bereit, die ein Mail-System modellieren. Mit Hilfe
dieser API kann das Programm Email-basiert auf Internet-Standards wie MIME
und SMTP senden.
JaretTimebar stellt viele Funktionen bereit, um ein Gantt-Chart zu gestalten.
Dadurch werden die Aktivitäten des Projekts einfach und intuitiv dargestellt.
JaretTimebar stellt viele Funktionen bereit, um ein Gantt-Chart zu gestalten.
Dadurch werden die Aktivitäten des Projekts einfach und intuitiv dargestellt.
Als Datenbank wird eine HSQL-Datenbank verwendet, die keine Installation erfordert.
Diese Datenbank braucht keinen Server zu betreiben, ist aber klein (lediglich 1 MB groß)
und schnell im Vergleich mit anderen Datenbank-Servern.
4.3 Struktur des Modells
Die Daten von Datenbank werden geholt und in einer Schicht gelagert. Diese Schicht
besteht aus Daten-Objekten, die für jede Entity in der Datenbank erstellt wird. Im
Folgenden werden zunächst die Beziehungen in einer Übersicht dargestellt, und danach
werden die Pakete und einzelne Klassen näher betrachtet.
4 Projektumsetzung
32
4.3.1 Beziehungen
Die Assoziationen zwischen den Entities sind in dem folgenden Diagramm ersichtlich:
Abbildung 14: ER-Diagramm
Das Projekt hat mindestens eine Person und ein Team, das aus mindestens einer Person
besteht. Jedes Team hat genau einen Entwurfstyp (entweder Prototyp oder klassischer
Entwurf).
Jedes Projekt hat mindestens eine Aktivität (den sogenannten Ablauf des Projektes) und
ein oder mehrere Email-Watcher, die aus in einer Warteschlange stehenden Emails
bestehen. Für diese Emails wurde im Laufe des Projekts festgestellt, wann sie gesendet
wurden. Bevor sie gesendet wurden, wurden sie in der Datenbank gespeichert.
EmailsConfig ist von dem Projekt unabhängig. Diese Konfiguration wird von dem
Programm eingestellt.
4 Projektumsetzung
33
Email-Vorlagen sind ebenfalls vom Projekt unabhängig. Jede Vorlage kann für viele
Projekte wiederverwendet werden.
Keyval besteht aus Schlüsseln und Werten, die in einer Email-Vorlage verwendet werden.
Diese sind aber von Vorlagen unabhängig, deswegen ein Schlüssel-Wert-Paar für
verschiedene Vorlagen verwendet werden kann.
4.3.2 Pakete
Abbildung 15: Paketezusammenhang
4 Projektumsetzung
34
Die drei Hauptkomponenten (Personalverwaltung, Aktivitätsverwaltung und
Projektallgemeinverwaltung) mit den zugehörigen Klassen werden im Paket
pmt.component abgelegt.
Abbildung 16: Model-View-Controller in Personal-Paket
Unter diesem Paket wird jede Komponente noch einmal auf Model-View-Controller-
Subpaketen aufgeteilt. Jede Komponente hat geschlossene Views und Controllers. In der
Abbildung 16 sind die Pakete unter Personal-Komponenten zu sehen. Die
Logikfunktionen werden im Paket models abgelegt. Für jede View-Klasse im Paket views
gibt es eine entsprechende Controller-Klasse im Paket controllers, die die Verwaltung
übernimmt und die Logik enthält. Das Controller-Objekt hat zu einem beliebigen Zeitpunkt
immer einen Kontext, wie der Stand des Main-View-Objekts und des Projekt-Objekts ist.
Das Controller-Objekt kann selbst Objekte aus der Datenbank laden, verändern, wieder
speichern und auch löschen.
Das Paket pmt.db besteht aus einem Datenbank-Connector, der die Verbindung mit der
Datenbank erstellt, und aus der abstrakten Klasse Entity und der konkreten Entity-Klasse,
die die Entity in der Datenbank abbilden. Die abstrakte Klasse Entity implementiert die
4 Projektumsetzung
35
allgemeinen Funktionen wie insert, update, delete, select, die auf jedem Entity verwendet
werden. Die konkreten Entity-Klassen werden die oberen allgemeinen Funktionen für
bestimmte Entity implementieren. Mit Hilfe dieser Entity-Klasse können die Daten aus der
Datenbank in einem entsprechenden Daten-Objekt gelagert und die von diesem Objekt
bearbeiteten Daten wieder in die Datenbank zurückgeführt werden.
Die allgemeinen Hilfsfunktionen wie StringHelper-Klasse, DateTimeHelper-Klasse usw.
werden im Paket pmt.lib abgelegt. Dazu gehören auch noch die Klassen, mit deren Hilfe
das Gantt-Diagramm erstellt werden kann. Im Paket pmt.plugins werden Model-View-
Controller-Subpakete von Email-Plugin abgelegt. Unter diesem Paket werden alle
Funktionen des Email-Plugins implementiert.
Im Paket pmt.common werden wieder Model-View-Controller-Subpakete eingeteilt. Im
Paket views werden erneut die Hauptteile des Main-Views wie Hauptmenü, Barmenü,
Viewmanager usw. abgelegt.
4.3.3 Klassenstruktur
Alle Klasse aus dem Paket pmt.db.entites haben gemeinsame, von der abstrakten Klasse
Entity bereits implementierte Methoden. Die Methoden bieten die Möglichkeit an, mit der
die Daten aus der Datenbank herausgeholt, aktualisiert und wieder in die Datenbank
eingefügt werden können. Die bereit implementierten Methoden sind:
createEntity (String sql): Diese Methode wird eine neue Entity in der Datenbank
erstellen.
insert (String columns, String values): Eine Folge von Werten wird mit
entsprechenden Spalten in der Datenbank hinzugefügt.
update (String set, String where): Eine Folge von Werten wird mit
entsprechenden Bedingungen in der Datenbank aktualisiert.
delete (where): Eine oder mehrere bestimmte Zeilen werden von der Datenbank
gelöscht.
deleteAll(): Alle Zeilen von einer Tabelle in der Datenbank werden gelöscht.
getNumberOfEntries(): Diese Methode gibt die Anzahl von Datensätzen zurück.
getMaxId(): Die maximale ID-Nummer wird mit Hilfe dieser Methode
zurückgeliefert. Wenn eine neue Zeile in der Datenbank hinzugefügt wird, wird
diese Nummer aufgerufen und um 1 erhöht, um eine neue ID-Nummer zu
erstellen.
4 Projektumsetzung
36
getObject() Diese Methode ist abstrakt und muss von der Subklasse mit dem
konkreten Rückgabetyp überschrieben werden.
Die konkreten Entity-Klassen werden mit Hilfe dieser bereits implementierten Methoden
den Datenaustauch zwischen Datenbank und Objekten implementieren.
Abbildung 17: Klassenstruktur von Entities
Die aus der Datenbank herausgeholten Daten werden in Daten-Objekten gelagert. In der
Abbildung 17 spielen Projekt-Objekt und Activity-Objekt die Rolle des Daten-Objekts.
Diese Objekte haben die Attribute, die den Spalten von jeder Entity entsprechen. Die
Project-Entity hat folgende Spalten:
id Eindeutige fortlaufende Nummer
leader Name der Projektleiter
start_date Anfangsdatum des Projekts
end_date Enddatum des Projekts
notice Beschreibung des Projekts
pname Der Titel des Projekts
4 Projektumsetzung
37
Entsprechend hat das Project-Objekt die Attribute id, leader, startDate, endDate, notice
und pname.
Alle Main-View-Klassen der Hauptkomponenten implementieren Interface Iview mit
folgender Methode:
getController(): Er gibt den entsprechenden Controller für diesen View zurück.
Der zurückgelieferte Typ ist ein Typ, der Interface IController implementiert.
getName(): Er gibt den Name des Views zurück. Der zurückgelieferte Typ ist
String.
getView(): Er gibt den Inhalt des Views zurück. Der zurückgelieferte Typ wird von
der konkreten Klasse überschrieben.
Abbildung 18: Interface IView und konkrete Klasse, die dieses Interface
implementieren
Die Hauptansichten der Komponenten werden von der VManager-Klasse verwaltet. Die
Logiken in jeder Komponente sind aber voneinander unabhängig. Deswegen kann jede
Komponente möglichst fehlerfrei und leicht veränderbar sein.
4 Projektumsetzung
38
4.4 Implementierung
In diesem Abschnitt werden die wichtigsten Funktionen des Programms mit Beispielen
erläutert.
4.4.1 Laden von Objekten
Ein Objekt kann im einfachsten Fall über die ID geladen werden. Für jede konkrete
Klasse, die die Entity-Klasse erbt, gibt es eine entsprechende Klasse, die alle Daten der
konkreten Tabelle in ein Objekt auslagert.
Wir nehmen uns Klasse Project als Beispiel:
/** * contructor */ public ProjectEntity() { super.table = "project"; } @Override public Project getObject(int id) { ResultSet rs = this.selectAllWithCondition(" id = "+id); Project project = new Project(); try { while(rs.next()){ project.setId(rs.getInt(1)); project.setLeader(rs.getString(2)); project.setStartDate(DateTimeHelper.DateToString(rs.getDate(3))); project.setEndDate(DateTimeHelper.DateToString(rs.getDate(4))); project.setNotice(rs.getString(6)); project.setPname(rs.getString(7)); } } catch (SQLException e) { e.printStackTrace(); } return project;
}
Der Tabellenname „project“ wird im Konstruktor angegeben. Anschließend wird die
abstrakte Methode getObject() implementiert. Mit eindeutiger ID-Nummer werden die
Daten von der Tabelle in das Project-Objekt übertragen. Dieses Project-Objekt wird von
einer anderen Funktion verwendet. Die Daten können direkt in der GUI angezeigt oder
weiter mit Logikfunktionen bearbeitet werden.
4 Projektumsetzung
39
4.4.2 Inhalt der Emails mit Schlüssel-Worten als Platzhaltern auswerten
Der Inhalt der Email-Vorlage enthält die Schlüssel-Worte als Platzhalter. Vor dem Senden
werden diese Schlüssel-Worte mit den entsprechenden Werten ersetzt. Der Inhalt der
Email wird mit Hilfe der Methode evaluateBody(String body, String receiver)
ausgewertet. Dabei ist body der Inhalt der Email und receiver die Email-Adresse des
Empfängers. Diese Methode kann auf drei Schritte aufgeteilt werden:
private String evaluateBody(String body, String receiver) { // get all vars String[] vars = KeyVal.getVars(body); KeyVal[] kvs = new KeyVal[vars.length]; int index = 0; for (String var : vars) { KeyVal kv = kvEntity.getObjectFromKey(var); if (kv.getKey() == null) { PopUpError.displayError(null, "Der Schlüssel-Wert: " + var + " wurde nicht gefunden! " + "Bitte korrigieren Sie seine Definition ", "System Fehler"); } kvs[index] = kv; index++; }
Schritt 1: alle Schlüssel-Worte, die sich im Email-Inhalt als Platzhalter befinden,
werden ausgesucht und in einer String-Array gespeichert. Diese Array wird
durchlaufen, wobei für jedes Element der Array ein entsprechendes Schlüssel-Wort-
Objekt aus der Datenbank geholt und in einer anderen KeyVal-Array gespeichert
wird.
4 Projektumsetzung
40
// replace var with email and save old key for (int i = 0; i < kvs.length; i++) { int oPos = kvs[i].getKey().indexOf("("); int cPos = kvs[i].getKey().indexOf(")"); if (cPos > 0 && oPos > 0) { String varInKey = kvs[i].getKey().substring(oPos + 1, cPos); String oldKey = kvs[i].getKey(); kvs[i].setOldKey(oldKey); String newKeyWithVal = oldKey.replaceAll(varInKey, receiver); kvs[i].setKey(newKeyWithVal); } else { // oldkey is null as default // for other keyval, which not related with email // need to set oldkey = key , so the replacement can be well // done; kvs[i].setOldKey(kvs[i].getKey()); } }
Schritt 2: Die KeyVal-Array wird durchgelaufen, und für jedes Element der Array wird die Email-Adresse als newKey gespeichert. Die Variable wird als oldKey gespeichert, damit diese wieder in Schritt 3 verwendet wird.
// evaluate body for (KeyVal kv : kvs) { body = body.replace("[" + kv.getOldKey() + "]", StringHelper.ArrayToString(kv.getVal(), ",")); } return body;
Schritt 3: Nachdem jedes KeyVal-Objekt newKey gesetzt worden ist, wird der Inhalt
der Email ausgewertet. Jedes KeyVal-Objekt wird zuerst ausgewertet und mit Hilfe
von oldKey an die richtige Position im Inhalt zurückgesetzt.
5 Erweiterungsmöglichkeiten
41
5 Erweiterungsmöglichkeiten
Eine Schnittstelle mit einer anderen Plattform ist eine Erweiterungsmöglichkeit für das
Werkzeug. Beim SE-Institut wird gerade eine Software, ein sogenanntes NetQGate, für
die Software-Projekt-Veranstaltung eingesetzt, um ein projektübergreifendes
Management zu haben und um eine grundlegende Qualität zu sichern. Die Informationen
der gesamten Veranstaltung werden in diesem Programm verwendet. Über eine
Schnittstelle kann das Projektmanagement-Werkzeug die Daten mit NetQGate
austauschen. Daher kann die Gruppe mit den zugewiesenen Studierenden direkt in
NetQGate beim Starten importiert werden. Umgekehrt können die Zustände der
Aktivitäten wieder in das Projektmanagement-Werkzeug übertragen werden.
Über eine Schnittstelle kann der Projektleiter auf den SVN-Repository zugreifen und die
Dateien jeder Gruppe betrachten. Die angeforderten Dateien werden zu einem
bestimmten Zeitpunkt kontrolliert. Ein HTML-Editor für die Erstellung einer Email-Vorlage
kann integriert werden. Mit Hilfe dieses Editors kann der Projektleiter den Email-Inhalt in
der üblichen Form schneller erarbeiten. Ein Gesamtbericht wird am Ende der
Veranstaltung angefertigt. Im Bericht sollen alle Aktivitäten und statistische Informationen
angezeigt werden. Daher kann der Projektleiter den Bericht im LID wieder verwenden, um
Erfahrungen zu sammeln.
6 Zusammenfassung und Ausblick
42
6 Zusammenfassung und Ausblick
Zusammenfassung
Vor dem Fazit und dem Ausblick werden im Folgenden die Schwerpunkte und
Erkenntnisse der Kapitel zwei bis sechs zusammengefasst:
Im Kapitel 2 habe ich die Grundlagen für einen neuen Entwurf des Projektmanagement-
Werkzeuges gelegt und zunächst die am meisten eingesetzten Projektmanagement-
Werkzeuge betrachtet. Als unverzichtbare Grundlage diente die Beschreibung von
wichtigen Aspekten des Projektmanagements. Im folgenden Kapitel 3 habe ich die
Anforderungen an zu entwickelndem Projektmanagement-Werkzeug aufgelistet und die
zentralen Risiken beschrieben.
Im Kapitel 4 wurde die Abhängigkeit zwischen Entities erläutert. Davor wurden fünf
Prototypen erläutert und ihre Ergebnisse analysiert. Zuerst wurde die Konsistenz der
Oberfläche untersucht, damit die Oberfläche nicht zerstört wird, wenn die Größe und
Position der anderen graphischen Elemente verändert werden. Auch die für erfolgreiche
und gescheiterte Verbindungen mit einem Mail-Server angefallenen Zeiten wurden
untersucht. Danach wurden das gekoppelte Schlüssel-Wort und die HSQL-Datenbank
betrachtet. Das Schlüssel-Wort ist einer der wichtigste Teile für das Erstellen und Senden
einer Email-Vorlage. Bei der Erstellung einer Email-Vorlage werden Schlüssel-Worte
verwendet, die jedoch beim Senden mit dem gesamten Email-Inhalt ausgewertet werden.
Wenn der Prototyp erfolgreich untersucht wird, wird die Sendungsfunktion teilweise
indirekt erfolgreich untersucht.
Im letzten Kapitel stelle ich abschließend die Erweiterungsmöglichkeiten des
Projektmanagement-Werkzeugs dar.
Ausblick
Es gibt immer noch viele Spielräume für die neue Version des Projektmanagement-
Werkzeuges bei der Personalverwaltung und bei der Kommunikation mit Studierenden. Im
Bereich der Personalverwaltung wurden die Informationen von Studierenden und ihren
Teams verwaltet. Es ist aber noch Verbesserungspotential vorhanden, und zwar
dahingehend, dass nicht nur Informationen von Studierenden vorhanden sind, sondern
auch solche von den SE-Mitarbeitern, die für jedes Team zuständig sind. Außerdem
könnten neue Plugins in das Programm integriert werden, um die Kommunikation nicht
6 Zusammenfassung und Ausblick
43
nur über Email, sondern auch über andere Formen wie etwa Chat und Sofort-Feedback
zu verbessern.
7 Literaturverzeichnis
44
Literaturverzeichnis
Beisecker, M-A. Das Lexikon der PC-Fachbegriffe . Bonn: Fachverlag für die Deutsche
Wirtschaft AG, 2005/2006.
Buhl, A. Grundkurs Software-Projektmanagement, Aufl.1. München: Carl Hanser Verlag
GmbH & CO. KG, 2004.
GPM InfoCenter. „Auf dem Weg zu Mitliprojektmanagement als Unternehmensstrategie.“
Projektmanagement . 02 2004. http://www.pmaktuell.org/uploads/PMAktuell-
200204/PMAktuell-200204-034-Public.pdf (Zugriff am 21. 08 2012).
Greive, J. „Entwurf und Implementierung eines Systems zur netzbasierten Durchführung
von Quality-Gates, Fachgebiet Software Engineering.“ 2005. http://www.se.uni-
hannover.de/pub/File/pdfpapers/Greive2005.pdf (Zugriff am 22. 8 2012).
Janke, S., Günther, A. „PHProjekt eine Open Source Groupware Suite Version 3.3 -
Handbuch.“ 10 2002. http://fmr.ilr.tu-berlin.de/manual-0.8.html (Zugriff am 20. 08
2012).
Kerzner, H. Projektmanagement. Ein systemorientierter Ansatz zur Planung und
Steuerung, Aufl. 2. Bonn: Mitp-Verlag, 2008.
Litke, H-D. Projektmanagement: Methode, Techniken, Verhaltensweisen. Evolutionäres
Projektmanagement, Aufl. 5. München: Carl Hanser Verlag GmbH & CO. KG,
2007.
Schneider, K. Abenteuer Software-Qualität, Aufl. 2., überarb. u. erw. Aufl. . Heidelberg:
dpunkt.verlag GmbH, 2012.
Schwab, J. Geschäftsprozessmanagement mit Visio, ViFlow und MS Project, Aufl. 1.
München: Hanser Fachbuch, 2003.
—. Projektplanung realisieren mit Project 2007: Das Praxisbuch für alle Project-
Anwender, Aufl.1 . München, Wien: Carl Hanser Verlag GmbH & CO. KG, 2008.
SERENA Software, Inc. OpenProj. http://www.serena.com/ products/openproj/ (Zugriff
am 20. 8 2012).
Wenzel, J., Meusel, J., Schlomm, O. Netzplantechnik im Eventmanagement. München:
GRIN Verlag, 2006.
Zuser, W., Grechenig, T., Köhle, M. Software Engineering mit UML und dem Unified
Process, überarbeitete Aufl. 2. München: Addison-Wesley Verlag, 2004.
Erklärung der Selbstständigkeit
Hiermit versichere ich, dass ich die vorliegende Bachelorarbeit selbständig und ohne
fremde Hilfe verfasst und keine anderen als die in der Arbeit angegebenen Quellen und
Hilfsmittel verwendet habe. Die Arbeit hat in gleicher oder ähnlicher Form noch keinem
anderen Prüfungsamt vorgelegen.
Hannover, den 04.09.2012
Toan Vu
