28.10.2015 Views

Digitalisierung von Workflows mit JIRA

1KFnfTH

1KFnfTH

SHOW MORE
SHOW LESS

You also want an ePaper? Increase the reach of your titles

YUMPU automatically turns print PDFs into web optimized ePapers that Google loves.

14 BTS NR. 26<br />

le Sicherheitslücken. Zu einem Problem werden solche Lücken<br />

immer dann, wenn sie zwar jemand entdeckt, sie aber geheim<br />

hält, weil er keine guten Absichten hat oder sie zu kriminellen<br />

Zwecken nutzen will. Gerüchten zufolge bezahlen sogar Geheimdienste<br />

Hacker dafür in bestimmten IT-Systemen nach unbekannten<br />

Sicherheitslücken zu suchen. Aber nicht, um diese öffentlich<br />

zu machen, sondern um sich darüber unbemerkt Zugriff<br />

auf Daten zu verschaffen. Die Krux an dieser Sache: In solchen<br />

Fällen erfahren die Hersteller oder die Open Source Community<br />

gar nicht oder erst sehr spät <strong>von</strong> der Lücke und können diese<br />

auch nicht zeitgerecht schließen. Nur wenn die Sicherheitslücke<br />

bekannt wird, kann der Hersteller Gegenmaßnahmen ergreifen<br />

und sie schließen. In der Realität dauert dieser Vorgang vielfach<br />

Wochen oder Monate.<br />

Je bekannter eine Lücke wird, desto mehr Informationen erhalten<br />

potenzielle Angreifer im Internet über die Schwachstelle.<br />

Ab einem gewissen Bekanntheitsgrad sind selbst Hobby-Hacker<br />

in der Lage eine Sicherheitslücke zu überwinden und Schaden<br />

anzurichten. Positiv ist auf der anderen Seite, dass immer mehr<br />

Nutzer informiert werden. Sie können sich anschließend gegen<br />

mögliche Angriffe schützen oder die betroffene Software temporär<br />

nicht benutzen. In diesen Fällen spielt der Hersteller in der<br />

Regel kurzfristig einen Patch ein, wobei es trotzdem oft sehr<br />

lange dauert, bis die Gefahr gebannt und eine Sicherheitslücke<br />

komplett geschlossen wird.<br />

Bei den vielen Problemen, die durch Bugs verursacht<br />

werden, steht der bestmögliche Schutz vor Problemen, die <strong>mit</strong><br />

Softwarefehlern im Zusammenhang stehen, nicht nur bei der<br />

ADACOR, sondern in jeder Unternehmens-IT im Mittelpunkt.<br />

Software Bugs – alles Definitionssache?<br />

Neben der korrekten Einteilung <strong>von</strong> Bugs in verschiedene Kategorien,<br />

besteht eine weitere Herausforderung in der Definition<br />

eines Softwarefehlers. Über die korrekte Begriffsbestimmung<br />

herrschen unterschiedliche Meinungen. Sebastian Krack, Leiter<br />

der Softwareentwicklung bei ADACOR, definiert einen Bug zum<br />

Beispiel wie folgt:<br />

„Wenn der Quellcode nicht genauso<br />

abläuft, wie der Entwickler es sich<br />

gedacht hat oder entscheidende<br />

Gegebenheiten bei der Programmierung<br />

nicht bedacht wurden, ist es ein Bug“.<br />

Neben der Programmierersicht lautet eine Definition aus der<br />

Businessperspektive so: „Um einen Softwarefehler als solchen<br />

zu definieren, bedarf es einer genauen Spezifikation der gewünschten<br />

Funktionsweise der Software und erst eine Abweichung<br />

<strong>von</strong> dieser stellt einen Fehler dar.“<br />

Ein typisches Beispiel für Probleme, die aus einer fehlenden<br />

Spezifikation entstehen können, ist die ungeplante Skalierung<br />

der Software. So wird etwa eine Software für einen kleinen<br />

Personenkreis <strong>mit</strong> überschaubarem Budget entwickelt und implementiert.<br />

Für diese Nutzergruppe funktioniert das Programm<br />

einwandfrei. Die Software begeistert nach und nach immer mehr<br />

Nutzer, sodass deren Anzahl steigt. Nachdem nicht mehr nur 15,<br />

sondern 200 Personen die Software regelmäßig nutzen, kommt<br />

es laufend zu Problemen und Abstürzen. Die dafür ursächlichen<br />

Softwarefehler sind dann eigentlich keine richtigen Fehler, sondern<br />

Teil der ursprünglichen Konzeption. Denn diese basiert auf<br />

einer kleinen Nutzergruppe, für die es weder die Anforderung<br />

noch das Budget für eine Skalierbarkeit gab. Folgerichtig wurde<br />

auf jeden Mehraufwand für Skalierbarkeit und entsprechende<br />

Performance-Optimierung verzichtet.<br />

Daraus lässt sich schlussfolgern, dass theoretisch bei jeder<br />

Softwarekonzeption <strong>von</strong> Anfang an genau klar sein müsste,<br />

wie die genauen Anforderungen an das Programm in Zukunft<br />

aussehen werden. In der Praxis ist diese Voraussicht in vielen<br />

Fällen nicht möglich. Es ist im Gegenteil sogar extrem schwierig,<br />

die genauen Vorgaben an eine Software vor Projektbeginn zu<br />

definieren. Diese Erkenntnisse berücksichtigen jedoch moderne<br />

agile Projektframeworks wie Scrum oder Kanban, die auch bei<br />

der ADACOR zum Einsatz kommen. Je mehr Planung also in die<br />

Definition <strong>von</strong> Anforderungen oder in deren Unschärfe in der<br />

Konzeptionsphase fließen und je besser die Projektmanagement-Methoden<br />

sind, desto weniger Probleme gibt es hinterher<br />

bei der Entwicklung.<br />

Kombinierte Testverfahren stellen<br />

Softwarequalität am ehesten sicher<br />

Grundsätzlich ist das ausgiebige Testen einer Software die offensichtlichste<br />

Methode, um Fehler möglichst frühzeitig zu erkennen.<br />

Neben verschiedenen anderen Prüfmethoden ist der<br />

manuelle Test am bekanntesten. Dabei handelt es sich um eine<br />

Variante des sogenannten Black-Box-Testings, bei dem ohne<br />

Kenntnis des Softwarecodes (wie in einer Black Box) gegen die<br />

Spezifikation getestet wird. Die Tester gehen die Anwendung<br />

Schritt für Schritt durch und überprüfen, ob alle Features wie<br />

erwartet funktionieren. Da<strong>mit</strong> der Tester aufgrund seiner eigenen<br />

Entwicklung nicht unbewusst Annahmen über die Nutzung<br />

der Software trifft, sollte ein Entwickler nicht gleichzeitig auch<br />

Tester sein. Der Nachteil dieser Testmöglichkeit besteht darin,<br />

dass nur Fehlerbilder geliefert werden, aber keine Ursachen.<br />

Um Fehler in größeren Projekten einer bestimmten Komponente<br />

zuweisen zu können, benötigt man sogenannte White-<br />

Box-Tests, bei denen der Quellcode selbst getestet wird. Da<br />

es bei größeren Projekten immer aufwendiger wird, den Code<br />

manuell zu testen, kommen in einem solchen Fall immer häufiger<br />

automatisierte Tests zum Einsatz. Ein weit verbreitetes<br />

Verfahren ist dabei der Unit-Test bzw. Modultest, bei dem jedes<br />

Softwaremodul einzeln getestet wird, um die Komplexität zu<br />

reduzieren. Das bedeutet konkret, dass für jedes Modul ein eigenes<br />

Testprogramm, welches die Funktionen des Moduls gegen<br />

die Spezifikation testet, geschrieben wird.<br />

Automatisierte Tests, die in der Regel vom selben Softwareentwickler<br />

geschrieben werden wie der Code, finden jedoch<br />

nur solche Fehler, die bereits bei der Testkonzeption berücksichtigt<br />

wurden. Ein grundlegender Denkfehler bezogen auf die Implementierung<br />

könnte sich hingegen in den Tests fortsetzen. Um<br />

diesen Nachteil auszugleichen, werden in der Praxis manuelle<br />

Black-Box-Tests <strong>mit</strong> einem unabhängigen Team <strong>mit</strong> automatisierten<br />

White-Box-Tests zur Fehlersuche kombiniert.

Hooray! Your file is uploaded and ready to be published.

Saved successfully!

Ooh no, something went wrong!