├── _config.yml ├── resources ├── readme.md ├── innoQ-logo.jpg ├── Beispiele-für-Qualitätsziele-short.docx ├── Beispiele-für-Qualitätsziele-short.docx └── Beispiele-fuer-Qualitaetsanforderungen-v0_7.docx ├── icon.png ├── .gitignore ├── doc ├── ISO-25010.mmap ├── ISO-25010-Map.png ├── ISO-25010-EN-Tree.png ├── QualityRequirements-Domain.vpp ├── iso-25010-definitions.txt ├── quality-requirements-icon.graffle ├── iso-25010-de.xml.drawio └── ISO-25010-EN.graffle ├── src ├── logo │ ├── qr42_logo.jpg │ ├── qr42_logo.graffle │ │ ├── image5.png │ │ └── data.plist │ └── quality-req-logo-380x380.jpg └── asciidoc │ ├── images │ ├── arc42-logo.png │ ├── innoQ-logo.jpg │ └── ISO-25010-EN-Tree.png │ ├── lizenz.adoc │ ├── bibliography.adoc │ ├── index.adoc │ ├── 06_betreibbarkeit.adoc │ ├── 01_intro.adoc │ ├── 04_effizienz_herangehensweise_zeitverhalten.adoc │ ├── uebersetzung_q_merkmale.adoc │ ├── 05_zuverlaessigkeit_herangehensweise_verfuegbarkeit.adoc │ ├── 07_sonstige_anforderungen.adoc │ ├── 04_effizienz.adoc │ ├── 05_zuverlaessigkeit.adoc │ ├── 03_benutzbarkeit.adoc │ ├── 02_aenderbarkeit.adoc │ └── tabelle_der_q_merkmale.adoc ├── gradle └── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradle.properties ├── readme.md ├── CHANGELOG.md ├── .github └── workflows │ ├── main.yml │ └── release.yml ├── create_docx_with_pandoc.sh ├── quality-requirements.code-workspace ├── gradlew.bat ├── gradlew └── license.txt /_config.yml: -------------------------------------------------------------------------------- 1 | theme: jekyll-theme-cayman -------------------------------------------------------------------------------- /resources/readme.md: -------------------------------------------------------------------------------- 1 | # Quality Requirements # -------------------------------------------------------------------------------- /icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arc42/quality-requirements/HEAD/icon.png -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | build 2 | .gradle 3 | .settings 4 | .project 5 | *.DS_Store 6 | 7 | .idea 8 | -------------------------------------------------------------------------------- /doc/ISO-25010.mmap: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arc42/quality-requirements/HEAD/doc/ISO-25010.mmap -------------------------------------------------------------------------------- /doc/ISO-25010-Map.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arc42/quality-requirements/HEAD/doc/ISO-25010-Map.png -------------------------------------------------------------------------------- /src/logo/qr42_logo.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arc42/quality-requirements/HEAD/src/logo/qr42_logo.jpg -------------------------------------------------------------------------------- /doc/ISO-25010-EN-Tree.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arc42/quality-requirements/HEAD/doc/ISO-25010-EN-Tree.png -------------------------------------------------------------------------------- /resources/innoQ-logo.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arc42/quality-requirements/HEAD/resources/innoQ-logo.jpg -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arc42/quality-requirements/HEAD/gradle/wrapper/gradle-wrapper.jar -------------------------------------------------------------------------------- /doc/QualityRequirements-Domain.vpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arc42/quality-requirements/HEAD/doc/QualityRequirements-Domain.vpp -------------------------------------------------------------------------------- /src/asciidoc/images/arc42-logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arc42/quality-requirements/HEAD/src/asciidoc/images/arc42-logo.png -------------------------------------------------------------------------------- /src/asciidoc/images/innoQ-logo.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arc42/quality-requirements/HEAD/src/asciidoc/images/innoQ-logo.jpg -------------------------------------------------------------------------------- /src/logo/qr42_logo.graffle/image5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arc42/quality-requirements/HEAD/src/logo/qr42_logo.graffle/image5.png -------------------------------------------------------------------------------- /src/logo/quality-req-logo-380x380.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arc42/quality-requirements/HEAD/src/logo/quality-req-logo-380x380.jpg -------------------------------------------------------------------------------- /src/asciidoc/images/ISO-25010-EN-Tree.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arc42/quality-requirements/HEAD/src/asciidoc/images/ISO-25010-EN-Tree.png -------------------------------------------------------------------------------- /gradle.properties: -------------------------------------------------------------------------------- 1 | project.description = "arc42 - Examples for Software Quality Requirements" 2 | project.name = "quality-requirements" 3 | project.version = "0.8.1" -------------------------------------------------------------------------------- /resources/Beispiele-für-Qualitätsziele-short.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arc42/quality-requirements/HEAD/resources/Beispiele-für-Qualitätsziele-short.docx -------------------------------------------------------------------------------- /resources/Beispiele-für-Qualitätsziele-short.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arc42/quality-requirements/HEAD/resources/Beispiele-für-Qualitätsziele-short.docx -------------------------------------------------------------------------------- /resources/Beispiele-fuer-Qualitaetsanforderungen-v0_7.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arc42/quality-requirements/HEAD/resources/Beispiele-fuer-Qualitaetsanforderungen-v0_7.docx -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | distributionBase=GRADLE_USER_HOME 2 | distributionPath=wrapper/dists 3 | distributionUrl=https\://services.gradle.org/distributions/gradle-6.8-bin.zip 4 | zipStoreBase=GRADLE_USER_HOME 5 | zipStorePath=wrapper/dists 6 | -------------------------------------------------------------------------------- /readme.md: -------------------------------------------------------------------------------- 1 | # Qualitätsanforderungen ![](icon.png) 2 | 3 | Dieses Repository ist **deprecated** und wird nicht weiter gepflegt. 4 | 5 | Eine deutlich verbesserte Form mit über 80 Beispielen finden Sie unter [quality.arc42.org](https://quality.arc42.org). 6 | 7 | ## Danke 8 | Alex Heusingfeld, Christoph Iserlohn, Roland Weisleder 9 | 10 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Changelog 2 | All notable changes to this project will be documented in this file. 3 | 4 | The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), 5 | and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). 6 | 7 | ## [Unreleased] 8 | ### :rocket: Added 9 | - [Issue 23](https://github.com/arc42/quality-requirements/issues/23): Create a release bundle with all release assets [@uniqueck](https://github.com/uniqueck) 10 | - [Issue 17](https://github.com/arc42/quality-requirements/issues/17): Push generated html output for a release to Github pages [@uniqueck](https://github.com/uniqueck) -------------------------------------------------------------------------------- /.github/workflows/main.yml: -------------------------------------------------------------------------------- 1 | # This workflow uses actions that are not certified by GitHub. 2 | # They are provided by a third-party and are governed by 3 | # separate terms of service, privacy policy, and support 4 | # documentation. 5 | 6 | name: Java CI 7 | 8 | on: [push] 9 | 10 | jobs: 11 | build: 12 | runs-on: ubuntu-latest 13 | 14 | steps: 15 | - uses: actions/checkout@v2 16 | - name: Set up JDK 11 17 | uses: actions/setup-java@v2 18 | with: 19 | java-version: '11' 20 | distribution: 'adopt' 21 | - name: Validate Gradle wrapper 22 | uses: gradle/wrapper-validation-action@e6e38bacfdf1a337459f332974bb2327a31aaf4b 23 | - name: Build with Gradle 24 | run: ./gradlew build 25 | -------------------------------------------------------------------------------- /create_docx_with_pandoc.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | TARGET="./build" 4 | 5 | FILENAME="index" 6 | INFILEXTENSION="xml" 7 | 8 | DOCXSTYLE="resources/arc42-style.docx" 9 | 10 | # 11 | echo "generate docx from docbook" 12 | cd $TARGET 13 | ################################# 14 | # 15 | # too bad, reference-docx does not work (produces illegal output) 16 | # pandoc --from docbook --to docx --reference-docx=$DOCXSTYLE --output $TARGET/$FILENAME.docx $TARGET/$FILENAME.$INFILEXTENSION 17 | pandoc --from docbook --to docx --output $FILENAME.docx $FILENAME.$INFILEXTENSION 18 | cd .. 19 | 20 | ########################################################### 21 | # 22 | # This is free software - use at your own risk. 23 | # Created by Gernot Starke 24 | # 25 | # Apache License, Version 2.0 26 | -------------------------------------------------------------------------------- /src/asciidoc/lizenz.adoc: -------------------------------------------------------------------------------- 1 | Copyright 2012-2021 the original author (Gernot Starke) or authors and contributors. 2 | 3 | Licensed under the Apache License, Version 2.0 (the "License"); 4 | you may not use this file except in compliance with the License. 5 | You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0[here:] 6 | 7 | 8 | http://www.apache.org/licenses/LICENSE-2.0 9 | 10 | 11 | Unless required by applicable law or agreed to in writing, software and documentation 12 | distributed under the License is distributed on an "AS IS" BASIS, 13 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | See the License for the specific language governing permissions and 15 | limitations under the License. 16 | 17 | 18 | 19 | 20 | -------------------------------------------------------------------------------- /quality-requirements.code-workspace: -------------------------------------------------------------------------------- 1 | { 2 | "folders": [ 3 | { 4 | "path": "." 5 | } 6 | ], 7 | "settings": { 8 | "workbench.colorCustomizations": { 9 | "activityBar.activeBackground": "#9cdefa", 10 | "activityBar.activeBorder": "#f649c2", 11 | "activityBar.background": "#9cdefa", 12 | "activityBar.foreground": "#15202b", 13 | "activityBar.inactiveForeground": "#15202b99", 14 | "activityBarBadge.background": "#f649c2", 15 | "activityBarBadge.foreground": "#15202b", 16 | "statusBar.background": "#6ccef7", 17 | "statusBar.foreground": "#15202b", 18 | "statusBarItem.hoverBackground": "#3cbef4", 19 | "titleBar.activeBackground": "#6ccef7", 20 | "titleBar.activeForeground": "#15202b", 21 | "titleBar.inactiveBackground": "#6ccef799", 22 | "titleBar.inactiveForeground": "#15202b99" 23 | }, 24 | "peacock.color": "#6ccef7" 25 | } 26 | } -------------------------------------------------------------------------------- /src/asciidoc/bibliography.adoc: -------------------------------------------------------------------------------- 1 | 2 | * [[bass09]] Len Bass et.al.: Software Architecture in Practice. Addision-Wesley, 2. Auflage 2009. 3 | 4 | * [[clements01]] Paul Clements et.al.: Evaluating Software Architectures. Addision-Wesley, 2001. 5 | 6 | * [[robertson12]] S. und J. Robertson: Mastering the Requirements Process - Getting Requirements Right. Addision-Wesley, 3. Auflage 2012. 7 | 8 | * [[rupp09]] Chris Rupp et.al: Requirements Engineering und -management. Hanser-Verlag, 5. Auflage 2009. 9 | 10 | * [[eeles05]] Peter Eeles: http://www.ibm.com/developerworks/rational/library/4706.html[Capturing Architectural Requirements]. Erläutert das FURPS+ Modell zur Erfassung von Qualitätsanforderungen an Software. 11 | 12 | * http://a2build.com/architectedagile/Architected%20Agile.html?ISO25010.html[Zusammenfassung 13 | von ISO-25010] 14 | 15 | * https://de.wikipedia.org/wiki/ISO/IEC_25000[ISO-25000 bei Wikipedia] 16 | -------------------------------------------------------------------------------- /src/asciidoc/index.adoc: -------------------------------------------------------------------------------- 1 | // header file for quality-requirements 2 | 3 | = Beispiele für Qualitätsanforderungen an Software 4 | :toc-title: Inhaltsverzeichnis 5 | // toc-title must follow document title without blank line 6 | 7 | 8 | :toc: 9 | 10 | :icons: font 11 | 12 | :caution-caption: Achtung 13 | :important-caption: Wichtig 14 | :note-caption: Hinweis 15 | :tip-caption: Tip 16 | :warning-caption: Warnung 17 | 18 | :appendix-caption: Anhang 19 | :example-caption: Beispiel 20 | :figure-caption: Abbildung 21 | :table-caption: Tabelle 22 | 23 | 24 | [small]#Dr. Gernot Starke 25 | Version {version}# 26 | 27 | 28 | 29 | include::01_intro.adoc[] 30 | 31 | include::02_aenderbarkeit.adoc[] 32 | 33 | include::03_benutzbarkeit.adoc[] 34 | 35 | include::04_effizienz.adoc[] 36 | 37 | include::05_zuverlaessigkeit.adoc[] 38 | 39 | include::06_betreibbarkeit.adoc[] 40 | 41 | include::07_sonstige_anforderungen.adoc[] 42 | 43 | [appendix] 44 | include::tabelle_der_q_merkmale.adoc[] 45 | -------------------------------------------------------------------------------- /.github/workflows/release.yml: -------------------------------------------------------------------------------- 1 | # This workflow uses actions that are not certified by GitHub. 2 | # They are provided by a third-party and are governed by 3 | # separate terms of service, privacy policy, and support 4 | # documentation. 5 | 6 | name: Release 7 | 8 | on: 9 | push: 10 | tags: 11 | - 'v*' 12 | 13 | jobs: 14 | release: 15 | runs-on: ubuntu-latest 16 | 17 | steps: 18 | - uses: actions/checkout@v2 19 | 20 | - name: Set up JDK 11 21 | uses: actions/setup-java@v2 22 | with: 23 | java-version: '11' 24 | distribution: 'adopt' 25 | 26 | - name: Validate Gradle wrapper 27 | uses: gradle/wrapper-validation-action@v1 28 | 29 | - name: Build with Gradle 30 | run: ./gradlew -Pversion=${GITHUB_REF##*/v} createReleaseBundle prepareGithubPagesContent 31 | 32 | - name: create Github Release 33 | uses: docker://ghcr.io/anton-yurchenko/git-release:v4 34 | env: 35 | GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} 36 | DRAFT_RELEASE: "false" 37 | PRE_RELEASE: "false" 38 | CHANGELOG_FILE: "CHANGELOG.md" 39 | ALLOW_EMPTY_CHANGELOG: "false" 40 | RELEASE_NAME_PREFIX: "Release: " 41 | with: 42 | args: | 43 | ./build/dist/quality-requirements.zip 44 | 45 | - name: deploy to gh-pages 46 | uses: peaceiris/actions-gh-pages@v3 47 | with: 48 | github_token: ${{ secrets.GITHUB_TOKEN }} 49 | publish_dir: ./build/gh-pages 50 | -------------------------------------------------------------------------------- /src/asciidoc/06_betreibbarkeit.adoc: -------------------------------------------------------------------------------- 1 | == Betreibbarkeit 2 | 3 | === Was bedeutet Betreibbarkeit? 4 | Betreibbarkeit wird in DIN/ISO 9126 nicht definiert. 5 | 6 | In der Praxis gehören hierzu folgende Teilmerkmale: 7 | 8 | *Analysierbarkeit:*:: Aufwand, um Mängel oder Ursachen von Versagen zu diagnostizieren oder um änderungsbedürftige Teile zu bestimmen. 9 | 10 | *Installierbarkeit:*:: Aufwand, der zum Installieren der Software in einer festgelegten Umgebung notwendig ist. 11 | 12 | *Übertragbarkeit:*:: Eignung der Software, von einer Umgebung in eine andere übertragen zu werden. Umgebung kann organisatorische Umgebung, Hardware- oder Software-Umgebung einschließen. Teilweise als "Portabilität" bezeichnet. 13 | 14 | *Austauschbarkeit:*:: Möglichkeit, diese Software anstelle einer spezifizierten anderen in der Umgebung jener Software zu verwenden, sowie der dafür notwendige Aufwand. 15 | 16 | *Koexistenz:*:: Fähigkeit der Software, neben einer anderen mit ähnlichen oder gleichen Funktionen zu arbeiten 17 | 18 | 19 | 20 | 21 | 22 | 23 | === Szenarien für Betreibbarkeit 24 | 25 | ==== Szenario: 26 | Das Werkzeug zur Messung der aktuellen Datenbank-Performance muss sowohl unter MySQL, Oracle und DB2 laufen. 27 | 28 | [horizontal] 29 | Geschäftsziel(e):: 30 | 31 | 32 | Reaktion:: 33 | Das Werkzeug muss eine Verbindung zu allen genannten Datenbanken aufbauen können und die jeweilige DB-Struktur anzeigen können. 34 | 35 | Zielwert:: 36 | Initialisierung und Erkennung des verbundenen DB-Typs erfolgt in weniger als 30 Sekunden. 37 | 38 | 39 | ==== Szenario: Automatische Installation 40 | Das XY-System lässt sich inklusive sämtlicher benötigten Softwarekomponenten vollständig automatisiert installieren. 41 | 42 | [horizontal] 43 | Geschäftsziel(e):: 44 | Kurze Releasezyklen, um schnelle Erweiterungen oder Fehlerbehebungen produktiv setzen zu können 45 | 46 | Auslöser:: 47 | Betreiber (oder Administrator) möchte neue Version von XY (innerhalb einer neuen virtuellen Maschine bzw. neuen Hardware) installieren 48 | 49 | Reaktion:: 50 | Ein automatischer Installer (Skript, Programm) installiert auf Basis einer Ubuntu-Linux Standardinstallation sowohl alle Teile des XY-Systems wie auch sämtliche benötigten zusätzlichen Software- komponenten (etwa: Datenbank, Middleware, Crypto-Module). Sämtliche benötigten Daten (etwa: Datenbank-Initialisierung, LDAP-Standardbenutzer) werden mit angelegt. 51 | 52 | Zielwert:: 53 | Die gesamte Installation dauert auf Basis eines bereits installierten Ubuntu-Linux höchstens 30 Minuten. 54 | 55 | 56 | ==== Szenario: Langlebigkeit 57 | 58 | Die Software kann über 20 Jahre hinweg auf jeweils aktueller Hardware und Software (Betriebssysteme, DB-Systeme usw.) portiert werden, wozu nicht mehr als 5 Personentage pro Monat investiert werden müssen. 59 | 60 | 61 | ==== Szenario: Installation ohne Internetzugang 62 | Unabhängigkeit der Installation von Zufällen des Internets 63 | 64 | Die Software lässt sich auf einem System installieren, ohne dass ein Internetzugang vorhanden ist. 65 | -------------------------------------------------------------------------------- /gradlew.bat: -------------------------------------------------------------------------------- 1 | @rem 2 | @rem Copyright 2015 the original author or authors. 3 | @rem 4 | @rem Licensed under the Apache License, Version 2.0 (the "License"); 5 | @rem you may not use this file except in compliance with the License. 6 | @rem You may obtain a copy of the License at 7 | @rem 8 | @rem https://www.apache.org/licenses/LICENSE-2.0 9 | @rem 10 | @rem Unless required by applicable law or agreed to in writing, software 11 | @rem distributed under the License is distributed on an "AS IS" BASIS, 12 | @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | @rem See the License for the specific language governing permissions and 14 | @rem limitations under the License. 15 | @rem 16 | 17 | @if "%DEBUG%" == "" @echo off 18 | @rem ########################################################################## 19 | @rem 20 | @rem Gradle startup script for Windows 21 | @rem 22 | @rem ########################################################################## 23 | 24 | @rem Set local scope for the variables with windows NT shell 25 | if "%OS%"=="Windows_NT" setlocal 26 | 27 | set DIRNAME=%~dp0 28 | if "%DIRNAME%" == "" set DIRNAME=. 29 | set APP_BASE_NAME=%~n0 30 | set APP_HOME=%DIRNAME% 31 | 32 | @rem Resolve any "." and ".." in APP_HOME to make it shorter. 33 | for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi 34 | 35 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. 36 | set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" 37 | 38 | @rem Find java.exe 39 | if defined JAVA_HOME goto findJavaFromJavaHome 40 | 41 | set JAVA_EXE=java.exe 42 | %JAVA_EXE% -version >NUL 2>&1 43 | if "%ERRORLEVEL%" == "0" goto execute 44 | 45 | echo. 46 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 47 | echo. 48 | echo Please set the JAVA_HOME variable in your environment to match the 49 | echo location of your Java installation. 50 | 51 | goto fail 52 | 53 | :findJavaFromJavaHome 54 | set JAVA_HOME=%JAVA_HOME:"=% 55 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe 56 | 57 | if exist "%JAVA_EXE%" goto execute 58 | 59 | echo. 60 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 61 | echo. 62 | echo Please set the JAVA_HOME variable in your environment to match the 63 | echo location of your Java installation. 64 | 65 | goto fail 66 | 67 | :execute 68 | @rem Setup the command line 69 | 70 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar 71 | 72 | 73 | @rem Execute Gradle 74 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* 75 | 76 | :end 77 | @rem End local scope for the variables with windows NT shell 78 | if "%ERRORLEVEL%"=="0" goto mainEnd 79 | 80 | :fail 81 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of 82 | rem the _cmd.exe /c_ return code! 83 | if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 84 | exit /b 1 85 | 86 | :mainEnd 87 | if "%OS%"=="Windows_NT" endlocal 88 | 89 | :omega 90 | -------------------------------------------------------------------------------- /src/asciidoc/01_intro.adoc: -------------------------------------------------------------------------------- 1 | 2 | 3 | :numbered!: 4 | 5 | == Über Qualität 6 | Die Qualität eines Produktes oder Systems ist ganz allgemein als 7 | _Menge von Eigenschaften oder Merkmalen_ definiert. 8 | 9 | 10 | 11 | In der Praxis haben sich einige Kategorien (Oberbegriffe) für häufig auftretende _Qualitätsanforderungen_ 12 | (synonym: Qualitätsziele) etabliert, im Wesentlichen durch die Begriffsmodelle von DIN/ISO 9126 bzw. 25010 geprägt. 13 | 14 | .ISO 25010 Quality Model 15 | image::ISO-25010-EN-Tree.png[] 16 | 17 | === Die Kategorien 18 | 19 | * <> 20 | * <> 21 | * <> 22 | * <> 23 | * <> 24 | * <> 25 | 26 | 27 | === Einordnung kann mehrdeutig sein 28 | 29 | Manche Qualitätsziele oder -anforderungen gehören zu mehreren 30 | "Oberbegriffen" oder Kategorien - die Zuordnung der Beispiele zu 31 | Kategorien oder Kapiteln fiel uns deswegen manchmal schwer. 32 | 33 | Falls Sie Ihre spezifischen Qualitätsanforderungen in der Gliederung 34 | nicht finden, so schauen Sie bitte im Anhang: <> - dort finden 35 | Sie eine umfangreiche Tabelle der Q-Merkmale mit ihren Synonymen und 36 | Oberbegriffen. 37 | 38 | === Formulierung von Szenarien 39 | Ein (Qualitäts-)Szenario beschreibt die _Reaktion_ (1) eines _Systems_ (3) 40 | beim Eintreffen eines _Ereignisses oder Stimulus_ (2). 41 | 42 | ==== (1) Reaktion eines System 43 | Die _Reaktion_ kann sich auf eine Software, Hardware oder einen Datenbestand, oder 44 | auch auf beteiligte Personen, Rollen oder Organisationen beziehen. 45 | 46 | Die Reaktion des Systems und damit das resultierende Verhalten sollte in Szenarien immer _meß- oder entscheidbar_ formuliert werden. 47 | 48 | ==== (2) Ereignis oder Stimulus 49 | Unterscheidung zwischen Nutzungsereignis und Änderungsereignis. 50 | 51 | ===== Nutzungsereignis 52 | Ein Benutzer löst während der Arbeit mit dem System eine Funktion aus, etwa: 53 | 54 | * wählt einen Menüpunkt / eine Funktion aus 55 | * klickt einen Button einer grafischen Oberfläche 56 | * startet eine Verarbeitung 57 | 58 | ===== Änderungsereignis 59 | Ein Stakeholder ändert etwas im System, etwa: 60 | 61 | * modifiziert Sourcecode oder Konfiguration des Systems 62 | * ändert an der Hardware des Systems 63 | * verändert das Deployment des Systems 64 | 65 | Ein Stakeholder ändert etwas an beteiligten Prozessen oder Organisationen. 66 | 67 | ==== (3) System 68 | Der Begriff _System_ ist hier sehr breit gefasst: Dazu gehören Software, 69 | Softwarekomponenten, beteiligte Hardware, Netze, Middleware, Datenbanken, 70 | aber auch sämtliche beteiligten Personen, Rollen oder Organisationen. 71 | 72 | 73 | 74 | === Quellen 75 | 76 | 77 | Die Ideen zu den hier aufgeführten Szenarien und Qualitätsanforderungen 78 | stammen aus unterschiedlichen Quellen und Projekten. Ich habe alle 79 | überarbeitet und weitgehend anonymisiert. Die Erklärungen von 80 | Qualitätsmerkmalen stammen teilweise aus DIN/ISO 9126 bzw. dem https://en.wikipedia.org/wiki/FURPS[FURPS-Modell+]. 81 | 82 | include::bibliography.adoc[] 83 | 84 | 85 | :numbered!: 86 | === Mitwirkende 87 | 88 | * Christoph Iserlohn (INNOQ), neue Szenarien 89 | * Oliver Tigges (INNOQ), neue Szenarien 90 | * Alex Heusingfeld (Vorwerk), Infrastruktur, AsciiDoc 91 | * Roland Krummenacher & div. N.N.: Reviews, Korrekturen 92 | 93 | Ideen und Anregungen zu einigen Szenarien auch von Firebrand-Softwarearchitectures. 94 | 95 | 96 | === Lizenz 97 | 98 | include::lizenz.adoc[] 99 | -------------------------------------------------------------------------------- /src/asciidoc/04_effizienz_herangehensweise_zeitverhalten.adoc: -------------------------------------------------------------------------------- 1 | 2 | 3 | == Herangehensweise Zeitverhalten 4 | 5 | Zeitverhalten (Zeitverhalten) hat viele Facetten, von Webseiten, Mobile Apps, der Durchlauf von Batches oder von eingebetteten Systemen. 6 | 7 | === Webseiten 8 | 9 | Was die Performance von Webseiten angeht, gibt es sehr viele Untersuchungen, welche Performance denn nun "gut" bzw. "schlecht" ist. Untersuchungen von Google sagen, dass 0-2,5 Sekunden Ladezeit bis eine Webseite den "Largest Contentful Paint" anzeigt, gut ist, bei 2,5 bis 4 Sekunden Verbesserung braucht und alles langsamer als 4 Sekunden schlecht ist. Google schaut hier auf das 75ste Perzentil. 10 | Bevor wir uns mit diesen Zahlen kritisch auseinandersetzen, müssen wir nun erstmal Begriffe klären: 11 | 12 | Der *Largest Contentful Paint - LCP -* (web.dev/lcp/) ist grob gesagt, das Gefühl des Nutzers, dass eine Webseite grundsätzlich geladen und nutzbar ist, weil der größte Block von Text und/oder Bild angezeigt wird. Eine detaillierte Erklärung mit Bilderfolge gibt es auf der LCP Webseite. Dort wird auch gezeigt, wie man LCP z.B. mit einem Chrome-Browser messen kann. Gängige Performance-Monitoring Tools wie z.B. Dynatrace oder Instana können das auch. 13 | 14 | Wenn man nun z.B. sagen würde, dass eine Produktdetailseite innerhalb von 2,5 Sekunden den LCP im 75sten Perzentil anzeigen soll, dann bedeutet das, dass von 100 Aufrufen der Produktdetailseite 75 Aufrufe innerhalb von 0 und 2,5 Sekunden liegen müssen und es OK ist, wenn 25 Aufrufe langsamer sind. Warum ist es in diesem Falle OK, wenn so viele Aufrufe langsamer sind? Wir als Entwickler haben nicht immer die Kontrolle über die Umgebung des Nutzers. Fährt dieser gerade durch einen Tunnel, dann ist der LCP sicher sehr langsam, dafür können wir nichts. 15 | 16 | Müssen jetzt alle Webseiten einer Anwendung im 75sten Perzentil schneller als 2,5 Sekunden sein? Nein, es kommt darauf an. Es gibt einen Ankereffekt bei der Nutzung von Webseiten, d.h. wir sind daran gewöhnt, dass gewisse Aktionen wie z.B. Zahlvorgänge länger dauern und seltener durchgeführt werden als andere, z.B. Produktdetailseiten. Daher kann ein Zahlvorgang ruhig auch mal 5 Sekunden dauern. Seiten, die oft aufgerufen werden wie z.B. Suche oder Produktdetails müssen aber zwingend schnell sein, also unter 2,5 Sekunden liegen. Wie ist das bei der Landingpage? Hier fällt auf, dass selbst Amazon.com mehr als 3,5 Sekunden braucht um den LCP aufzubauen. Das liegt daran, dass es auch immer einen Trade-Off gibt: will ich nur schnell sein oder auch attraktiv sein, z.B. viele schöne Bilder und personalisierte Empfehlungen anbieten? Wenn ja, dann darf eine oft aufgerufene Seite auch langsamer als 2,5 Sekunden sein. 17 | 18 | Wir müssen uns diese Anforderungen auch nicht für alle Seiten überlegen. Die wichtigsten Use Cases reichen erst einmal aus. 19 | 20 | Wir müssen also vorher überlegen: 21 | 22 | * Welche Use Cases müssen wir betrachten? 23 | * Welche Zeiten braucht der Nutzer um zufrieden zu sein? Müssen es 2,5 Sekunden sein, weil es oft aufgerufen wird bzw. weil Nutzer es wegen dem Ankereffekt erwarten? Oder sind auch 4 Sekunden akzeptabel? 24 | 25 | Um die Anforderungen einfach zu halten, sollten wir nicht mehr als 3 unterschiedliche Anforderungen definieren, d.h. dass wir uns z.B. auf "schnell" (= 2,5 Sekunden), mittel (= 4 Sekunden) und langsam (= 5,5 Sekunden) festlegen und nicht noch feingranularer werden. 26 | 27 | In Produktion kann man dann mit einer APM (Application Performance Monitoring) überwachen, ob diese Werte dann auch einigermaßen eingehalten werden. "Einigermaßen" weil niemand bei einer Verletzung von 100 Millisekunden direkt handeln wird, aber gesunder Menschenverstand hilft mögliche Abweichung entsprechend zu bewerten. 28 | 29 | Du hast kein Monitoring? Dann leg Dir eins zu. Das reicht von einfachen synthetischen Clients, die deine Webseite z.B. alle 5 Minuten aufrufen und den LCP messen bis hin zu Observability-Lösungen, die "alles" (Monitoring, Tracing, Logging, Alerting) anbieten. 30 | 31 | Beispiel-Szenario: 32 | Ein Nutzer aus Europa erhält nach dem Klick auf "Suchen" den LCP der Suchresultatseite innerhalb von 2,5 Sekunden im 75sten Perzentil angezeigt. -------------------------------------------------------------------------------- /src/asciidoc/uebersetzung_q_merkmale.adoc: -------------------------------------------------------------------------------- 1 | 2 | [[Uebersetzung-Q-Merkmale]] 3 | ## Übersetzung der Qualitätskategorien aus der ISO/IEC 25010 4 | 5 | Qualitäten eines Softwareproduktes nach ISO/IEC 25010 6 | 7 | 8 | [cols="2,2,3a", options="header"] 9 | |======= 10 | | ISO 25010 11 | | Übersetzung 12 | | Anmerkungen 13 | 14 | | System/Software product quality 15 | | Qualitäten eines Systems/Softwareproduktes 16 | | 17 | 18 | | *Functional suitability* 19 | | Funktionalität [embarc] Funktionale Tauglichkeit [usec] _Funktionale Eignung_ [istqb] 20 | | 21 | 22 | | Appropriateness 23 | | (funktionale) Angemessenheit 24 | | 25 | 26 | | Accuracy [a42] / functional correctness [enzy] 27 | | (funktionale) Korrektheit 28 | | 29 | 30 | | functional completeness [enzy] 31 | | (funktionale) Vollständigkeit 32 | | [embarc] [usec] 33 | 34 | | *Reliability* 35 | | Zuverlässigkeit 36 | | 37 | 38 | | 39 | | Reife [usec] 40 | | 41 | 42 | | Availability 43 | | Verfügbarkeit 44 | | 45 | 46 | | Fault tolerance 47 | | Fehlertoleranz 48 | | 49 | 50 | | Recoverability 51 | | Wiederherstellbarkeit 52 | | 53 | 54 | | *Performance efficiency* 55 | | Effizienz (Performanz [usec]) 56 | | 57 | 58 | | Time-behaviour 59 | | Zeitverhalten 60 | | 61 | 62 | | Resource-utilisation 63 | | Ressourcenverbrauch [embarc] _Ressourcenverwendung_ [usec] 64 | | 65 | 66 | | 67 | | Kapazität 68 | | [embarc] [usec] 69 | 70 | | *Operability (Useability)* 71 | | Benutzbarkeit [embarc] Gebrauchstauglichkeit [usec] 72 | | 73 | 74 | | Appropriateness-recogniseability 75 | | Angemessenheitserkennung [usec] 76 | | 77 | 78 | | Learnability 79 | | Erlernbarkeit 80 | | 81 | 82 | | Ease-of-use 83 | | Bedienbarkeit 84 | | 85 | 86 | | Helpfulness 87 | | Nützlichkeit 88 | | 89 | 90 | | Attractiveness 91 | | Ästetik der Benutzungsschnittstelle [usec] 92 | | 93 | 94 | | Technical-accessibility 95 | | Barrierefreiheit 96 | | 97 | 98 | | 99 | | Schutz vor Fehlern des Benutzers [embarc] Fehlersicherheit [usec] 100 | | [embarc] 101 | 102 | | *Security* 103 | | Sicherheit 104 | | 105 | 106 | | Confidentiality 107 | | Vertraulichkeit 108 | | 109 | 110 | | Integrity 111 | | Integrität 112 | | 113 | 114 | | Non-repudiation 115 | | Nachweisbarkeit [embarc] Verbindlichkeit [usec] Nicht-Abstreitbarkeit [usec] 116 | | 117 | 118 | | Accountability 119 | | Ordnungsmäßigkeit [embarc] Zurechenbarkeit [usec] 120 | | 121 | 122 | | Authenticity 123 | | Authentizität 124 | | 125 | 126 | | *Compatibility* 127 | | Kompatibilität 128 | | 129 | 130 | | Replace-ability 131 | | Austauschbarkeit 132 | | 133 | 134 | | Coexistence 135 | | Koexistenz 136 | | 137 | 138 | | Interoperability 139 | | Interoperabilität 140 | | 141 | 142 | | *Maintainability* 143 | | Wartbarkeit 144 | | 145 | 146 | | Modularity 147 | | Modularität 148 | | 149 | 150 | | Reuseability 151 | | Wiederverwendbarkeit 152 | | 153 | 154 | | Analyzability 155 | | Analysierbarkeit 156 | | 157 | 158 | | Changeability 159 | | Änderbarkeit 160 | | 161 | 162 | | Modification stability 163 | | Änderungsstabilität 164 | | 165 | 166 | | Testability 167 | | Testbarkeit 168 | | 169 | 170 | | *Transferability* / *Portability*[embarc] 171 | | Portabilität [embarc] Übertragbarkeit [usec] 172 | | 173 | 174 | | Portability 175 | | Portabilität 176 | | 177 | 178 | | Adaptability 179 | | Anpassbarkeit 180 | | 181 | 182 | | Installability 183 | | Installierbarkeit 184 | | 185 | 186 | | Replaceability 187 | | Ersetzbarkeit 188 | | 189 | 190 | Quelle: 191 | 192 | [a42] arc42/quality-requirements (insb. ISO-25010-EN-Tree.png) 193 | [embarc] https://www.embarc.de/software-qualitaet-iso-25010/ 194 | [usec] USecureD: E 1.4 USecureD-Qualitätsmodell (https://www.usecured.de/UseWP/wp-content/uploads/2015/04/E-1.4-USecureD-Qualitätsmodell-V.2.pdf) 195 | [enzy] https://www.enzyklopaedie-der-wirtschaftsinformatik.de/wi-enzyklopaedie/lexikon/is-management/Systementwicklung/Management-der-Systementwicklung/Software-Qualitatsmanagement/Qualitatsmerkmale-von-Software/index.html 196 | [nocomp] https://nocomplexity.com/overview-of-iso-25010/ 197 | 198 | [istqb] GTB Standardglossar der Testbegriffe Deutsch V3.2 -------------------------------------------------------------------------------- /src/asciidoc/05_zuverlaessigkeit_herangehensweise_verfuegbarkeit.adoc: -------------------------------------------------------------------------------- 1 | 2 | 3 | == Herangehensweise Verfügbarkeit bei Webanwendungen 4 | 5 | Verfügbarkeit ist als Anforderung notorisch schwer zu definieren. Eine gute Verfügbarkeit bedeutet, dass die Nutzer des Systems glücklich sind. Aber was soll das sein? 5 min Ausfall pro Jahr sind für die meisten Systeme absolut großartig, aber auch extrem schwer zu erreichen und damit auch extrem teuer. Ein System, welches 250 Tage im Jahr nicht verfügbar ist, macht z.B. nicht notwendigerweise deren Nutzer unglücklich. Stellt euch ein internes Verwaltungssystem für Lebensversicherungen vor. Es reicht, wenn das System Montag bis Freitag zu den normalen Arbeitszeiten, 7:00 bis 19:00, verfügbar ist und am Wochenende oder nachts nicht verfügbar. Bei einem Webshop, der rund um die Uhr auf allen Kontinenten Waren anbietet, sieht das schon ganz anders aus. Vor allem am Black Friday. Es kommt also auf das System an. 6 | 7 | Wir müssen also mit unseren Stakeholdern sprechen: 8 | 9 | * Welche Use Cases sind uns besonders wichtig? Für die wichtigsten Use Cases gelten die folgenden Fragen. 10 | * Zu welchen Zeiten soll das System laufen? Wann wird es am Tag oder in der Nacht genutzt? 11 | * Soll es jeden Tag laufen oder nur Mo-Fr? Vielleicht sogar nur zu gewissen Zeitpunkten. 12 | * Gibt es Zeiträume, wo Verfügbarkeit besonders wichtig ist? Bei Autoversicherungen ist es der November, bei Webshops für Karnevalsartikel der Januar und Februar und bei der Ampelsteuerung das ganze Jahr. 13 | * Wie teuer sind die Konsequenzen eines Ausfall? Nicht gemachter Umsatz? 10.000 Menschen können während des Ausfalls nicht arbeiten? 14 | * Zu den Zeitpunkten, wo das System laufen soll: wie viel Ausfall (in Minuten/Stunden/Tagen pro Jahr/Quartal/Monat) ist tolerabel? Kein System funktioniert zu 100%, nicht mal ein Herzschrittmacher. 15 | * Dann versuchen wir mit unseren Stakeholdern tolerable Ausfallzeiten zu definieren ("educated guess"), von denen wir glauben, dass die Nutzer diese auch tolerieren würden 16 | * Wir brauchen Feedbacksysteme um herauszufinden, ob die Nutzer auch wirklich noch glücklich mit der Verfügbarkeit sind 17 | 18 | Nehmen wir als Beispiel einen Webshop, der innerhalb Deutschlands irgendwelche Dinge verkauft. Die wichtigsten Use Cases sind die (1) Suche, (2)die Produktdetailseite anzeigen, (3) Artikel in den Warenkorb legen und (4) der Bezahlvorgang. Das System soll 7 Tage die Woche von 7:00 bis 0:00 Uhr hochverfügbar sein. Ausfälle außerhalb dieser Zeiten sind akzeptabel. Was "hochverfügbar" bedeutet, werden wir noch definieren. Es gibt keinerlei besondere Zeiträume, währenddessen das System besonders verfügbar sein sollte. Ein Ausfall führt nicht notwendigerweise zu Umsatzeinbußen, die Kunden kommen einfach später nochmal. Fällt das System aber entweder sehr lange und/oder sehr oft aus, gibt es die Gefahr, dass Nutzer zu einem anderen Anbieter wechseln. 19 | 20 | Ein guter Startpunkt für sehr viele (Web-)Anwendungen, so auch unsere Beispielanwendung, sind 99,9% bis 99,95% Verfügbarkeit pro Use Case zu den Zeiten 7:00 bis 0:00 Uhr. Was bedeuten diese "Neuner"? 99,9% bedeuten knapp 9 Stunden Ausfall über das Jahr gesehen, 99,95% sind ca. 4,5 Stunden Ausfall pro Jahr. Mit diesen Zahlen kann sich normalerweise jedes "Business" anfreunden. Wir sollten versuchen, die Verfügbarkeitsanforderungen unserer Use Cases so einheitlich wie möglich zu definieren. Vielleicht ist es dem Kunden wichtiger, dass die Suche und Produktdetailseite funktioniert, als das der Bezahlvorgang geht. Ich will erstmal suchen und finden. Zu viele unterschiedliche Anforderungen sind allerdings verwirrend, daher 21 | 22 | Eine ausführliche Tabelle gibt es bei Wikipedia: https://en.wikipedia.org/wiki/High_availability. Kritische Infrastruktur bei Google erreicht z.B. 9,995% Verfügbarkeit, 24x7, also nicht mal 30 Minuten Ausfall pro Jahr. Das bedeutet u.a., dass auch ein Fehler um 3 Uhr morgens innerhalb von Sekunden gefunden, innerhalb von Minuten gefixt und deployt werden kann. Da niemand so schnell aufwachen kann, müssen Menschen in allen Zeitzonen diese Infrastrukturen betreiben. 23 | 24 | Wie finden wir nun heraus, ob unsere Anforderung gut war? Wir müssen die Nutzer fragen! Entweder haben wir direkte Möglichkeiten, z.B. im B2B Bereich. Im Consumerbereich müssen wir auch mit dem Marketing oder Sales zusammenarbeiten. Diese Abteilungen haben normalerweise gute Einblicke in Social Media, App Store Reviews oder Net Promoter Scores. Keine Nachrichten sind hier gute Nachrichten. Beschwert sich niemand, dann ist alles gut. Lob zur Verfügbarkeit kann man nicht erwarten. Gibt es allerdings Beschwerden, dann muss nachgebessert werden. 25 | 26 | Zudem müssen wir messen, wie verfügbar unsere Use Cases sind. Hier macht es keinen Sinn, die Verfügbarkeit der gesamten Anwendung anzuschauen. Viele Web-Anwendungen haben einfache, aber sehr oft auftretende Anfragen, z.B. um einen Teaser anzuzeigen. Diese einfachen Anfragen verwässern unsere Sicht auf die wichtigen Use Cases. Daher müssen wir unsere wichtigen Use Cases monitoren. -------------------------------------------------------------------------------- /doc/iso-25010-definitions.txt: -------------------------------------------------------------------------------- 1 | 2 | 3 | Functional suitability 4 | degree to which a product or system provides functions that meet stated and implied needs when used underspecified conditions. 5 | 6 | Functional completeness : "degree to which the set of functions covers all the specified tasks and user objectives" 7 | Functional correctness : "degree to which a product or system provides the correct results with the needed degree of precision" 8 | Functional appropriateness : "degree to which the functions facilitate the accomplishment of specified tasks and objectives" 9 | 10 | Performance efficiency 11 | performance relative to the amount of resources used under stated conditions 12 | 13 | Time behaviour : "degree to which the response and processing times and throughput rates of a product or system, when performing its functions, meet requirements" 14 | Resource utilization : "degree to which the amounts and types of resources used by a product or system, when performing its functions, meet requirements" 15 | Capacity : "degree to which the maximum limits of a product or system parameter meet requirements" 16 | 17 | Compatibility 18 | degree to which a product, system or component can exchange information with other products, systems or components, and/or perform its required functions, while sharing the same hardware or software environment 19 | 20 | Co-existence : "degree to which a product can perform its required functions efficiently while sharing a common environment and resources with other products, without detrimental impact on any other product" 21 | Interoperability : "degree to which two or more systems, products or components can exchange information and use the information that has been exchanged" 22 | 23 | Usability 24 | degree to which a product or system can be used by specified users to achieve specified goals with effectiveness, efficiency and satisfaction in a specified context of use 25 | 26 | Appropriateness recognizability : "degree to which users can recognize whether a product or system is appropriate for their needs" 27 | Learnability : "degree to which a product or system can be used by specified users to achieve specified goals of learning to use the product or system with effectiveness, efficiency, freedom from risk and satisfaction in a specified context of use" 28 | Operability : "degree to which a product or system has attributes that make it easy to operate and control" 29 | User error protection : "degree to which a system protects users against making errors" 30 | User interface aesthetics : "degree to which a user interface enables pleasing and satisfying interaction for the user" 31 | Accessibility : "degree to which a product or system can be used by people with the widest range of characteristics and capabilities to achieve a specified goal in a specified context of use" 32 | 33 | Reliability 34 | degree to which a system, product or component performs specified functions under specified conditions for a specified period of time 35 | 36 | Maturity : "degree to which a system, product or component meets needs for reliability under normal operation" 37 | Availability : "degree to which a system, product or component is operational and accessible when required for use" 38 | Fault tolerance : "degree to which a system, product or component operates as intended despite the presence of hardware or software faults" 39 | Recoverability : "degree to which, in the event of an interruption or a failure, a product or system can recover the data directly affected and re-establish the desired state of the system" 40 | 41 | Security 42 | degree to which a product or system protects information and data so that persons or other products or systems have the degree of data access appropriate to their types and levels of authorization 43 | 44 | Confidentiality : "degree to which a product or system ensures that data are accessible only to those authorized to have access" 45 | Integrity : "degree to which a system, product or component prevents unauthorized access to, or modification of, computer programs or data" 46 | Non-repudiation : "degree to which actions or events can be proven to have taken place, so that the events or actions cannot be repudiated later" 47 | Accountability : "degree to which the actions of an entity can be traced uniquely to the entity" 48 | Confidentiality : "degree to which a product or system ensures that data are accessible only to those authorized to have access" 49 | Authenticity : "degree to which the identity of a subject or resource can be proved to be the one claimed" 50 | 51 | Maintainability 52 | degree of effectiveness and efficiency with which a product or system can be modified by the intended maintainers 53 | 54 | Modularity : "degree to which a system or computer program is composed of discrete components such that a change to one component has minimal impact on other components" 55 | Reusability : "degree to which an asset can be used in more than one system, or in building other assets" 56 | Analysability : "degree of effectiveness and efficiency with which it is possible to assess the impact on a product or system of an intended change to one or more of its parts, or to diagnose a product for deficiencies or causes of failures, or to identify parts to be modified" 57 | Modifiability : "degree to which a product or system can be effectively and efficiently modified without introducing defects or degrading existing product quality" 58 | Testability : "degree of effectiveness and efficiency with which test criteria can be established for a system, product or component and tests can be performed to determine whether those criteria have been met" 59 | 60 | 61 | Portability 62 | degree of effectiveness and efficiency with which a system, product or component can be transferred from one hardware, software or other operational or usage environment to another 63 | 64 | Adaptability : "degree to which a product or system can effectively and efficiently be adapted for different or evolving hardware, software or other operational or usage environments" 65 | Installability : "degree of effectiveness and efficiency with which a product or system can be successfully installed and/or uninstalled in a specified environment" 66 | Replaceability : "degree to which a product can replace another specified software product for the same purpose in the same environment" 67 | -------------------------------------------------------------------------------- /src/asciidoc/07_sonstige_anforderungen.adoc: -------------------------------------------------------------------------------- 1 | == Sonstige Qualitätsanforderungen 2 | 3 | Da hätten wir noch eine nahezu beliebige Menge weiterer Qualitätsanforderungen, beispielsweise Funktionalität. Oder diverse Synonyme bereits vorgestellter Q-Merkmale :-) 4 | 5 | Einige Definitionen: 6 | 7 | === Funktionalität: 8 | 9 | Vorhandensein von Funktionen mit festgelegten Eigenschaften; diese Funktionen erfüllen die definierten Anforderungen. Zu Funktionalität gehören nach DIN/ISO 9126 noch folgende Teilmerkmale: 10 | 11 | *Richtigkeit*:: Liefern der richtigen oder vereinbarten Ergebnisse oder Wirkungen, z.B. die benötigte Genauigkeit von berechneten Werten. 12 | *Angemessenheit*:: Eignung der Funktionen für spezifizierte Aufgaben, z.B. aufgaben-orientierte Zusammensetzung von Funktionen aus Teilfunktionen. 13 | *Interoperabilität*:: Fähigkeit, mit vorgegebenen Systemen zusammenzuwirken. Hierunter fällt auch die Einbettung in die Betriebsinfrastruktur. 14 | *Ordnungsmäßigkeit*:: Erfüllung von anwendungsspezifischen Normen, Vereinbarungen, gesetzlichen Bestimmungen und ähnlichen Vorschriften. 15 | 16 | 17 | === Sonstige Szenarien 18 | 19 | ==== Szenario: Verfügbarkeit für unterschiedliche Datenbanksysteme 20 | Das System (Werkzeug) dient zur Performancemessung für Datenbanksysteme. 21 | Es muss für unterschiedliche Datenbanksysteme zur Verfügung stehen. 22 | 23 | [horizontal] 24 | Geschäftsziel:: 25 | Portabilität, Effizienz, Betreibbarkeit. 26 | Vielseitiges Werkzeug, soll für unterschiedliche Datenbanksysteme zur Verfügung stehen 27 | 28 | Auslöser:: 29 | Das Werkzeug wird (per Dialog, Kommandozeile oder programmatisch) mit einem Datenbanksystem verbunden ("connected"): Oracle, DB2, Sybase, MySQL, PostgreSQL 30 | 31 | Reaktion:: 32 | Das Werkzeug stellt die Verbindung zum jeweiligen DBMS erfolgreich her - im Werkzeug ist die DB-Struktur sichtbar. 33 | 34 | Zielwert:: 35 | Der "connect" zur Datenbank erfolgt innerhalb von 30 Sekunden. 36 | 37 | ==== Szenario: Kernfunktion portabel auf iOS und Android 38 | Die Kernfunktionen der Mac-OS Software können unter iOS und Android wiederverwendet werden. 39 | 40 | [horizontal] 41 | Qualitätsziele:: 42 | Wiederverwendbarkeit, Austauschbarkeit 43 | 44 | Geschäftsziel:: 45 | Schnelle Time-to-Market, reduzierte Entwicklungskosten, Marktvergrößerung 46 | 47 | Auslöser:: 48 | Code ist für Mac-OS entwickelt 49 | 50 | Reaktion:: 51 | Der Code ist weitmöglich (soweit die Technologie das zulässt) sowohl unter iOS und Android wieder verwendbar. 52 | 53 | Zielwert:: 54 | Das Entwicklungsteam soll die Kernfunktionen wiederverwenden, ohne sie komplett neu implementieren beziehungsweise entwerfen zu müssen. 55 | 56 | Ausnahme hiervon sind direkte Aufrufe der jeweiligen Betriebssystemfunktionen. 57 | 58 | 59 | ==== Szenario: 60% Testabdeckung für Unit-Tests. 60 | 61 | [horizontal] 62 | Qualitätsziele:: Testbarkeit, Änderbarkeit 63 | 64 | Geschäftsziel:: 65 | Einfache Erweiter- und Änderbarkeit durch hohe Testabdeckung, schnelle Rückmeldung über mögliche Nebenwirkungen bei Codeänderungen. 66 | 67 | Auslöser:: 68 | Entwickler entwickelt oder ändert eine Funktion / Methode / Klasse. 69 | 70 | Reaktion:: 71 | Die betroffene Funktion / Methode / Klasse wird durch Unit-Tests überprüft. 72 | 73 | Zielwert:: 74 | Über 60% Pfadabdeckung wird durch die Unit-Tests erreicht. 75 | 76 | 77 | ==== Szenario: Einfaches Hinzufügen neuer Tests. 78 | Tester sollen mit geringem Aufwand neue Tests zu bestehenden Testsuites hinzufügen können. 79 | 80 | [horizontal] 81 | Qualitätsziele:: Testbarkeit, Änderbarkeit 82 | 83 | Geschäftsziel:: 84 | Fähigkeit, neue Tests einfach in bestehende Test-Suites zu integrieren. 85 | 86 | Auslöser:: 87 | Tester möchte neuen Test zu einer bestehenden Testsuite hinzufügen 88 | 89 | Reaktion:: 90 | Der Test wird zugefügt ohne den Code des Systems selbst (d.h. Den Produktivcode) zu modifizieren. 91 | 92 | Zielwert:: 93 | Es ist kein Re-Compile oder Neukonfiguration des Systems (genauer: des Produktivcodes) nötig. 94 | 95 | Anmerkung:: Testcode oder Testkonfigurationen dürfen jedoch verändert werden. 96 | 97 | 98 | 99 | ==== Szenario: Ähnliche Resultate bei stochastischen Testreihen 100 | Werden zwei stochastische Testreihen ausgeführt, sind die Resultate zu 90% ähnlich. 101 | 102 | [horizontal] 103 | Qualitätsziele:: Testbarkeit, Konsistenz, Nachvollziehbarkeit. 104 | Konsistente Testergebnisse auch bei stochastischen Tests oder Testreihen. 105 | 106 | Auslöser:: 107 | Testszenario oder Testreihe mit Anteil an zufällig bestimmten Testdaten wird ausgeführt 108 | 109 | Reaktion:: 110 | Ähnliche Testergebnisse. 111 | 112 | Zielwert:: 113 | Die Ergebnisse zweier Testreihen sind bei 90% aller Einzeltests ähnlich. 114 | 115 | ==== Szenario: Testausführung mit einzelnem Befehl 116 | Ein Tester möchte mehrere Testszenarien mit einem einzelnen Befehl durchführen können. 117 | 118 | 119 | [horizontal] 120 | Geschäftsziel:: 121 | Effizienz, Testbarkeit 122 | 123 | Auslöser:: 124 | Testadministrator oder Tester möchte mehrere Tests oder Testszenarien durchführen 125 | 126 | Reaktion:: 127 | Aggregation oder Hintereinander-Ausführung mehrerer Tests. 128 | 129 | Zielwert:: 130 | Ausführung mehrerer Tests benötigt nur einen einzigen Befehl des Testers oder Testadministrators. 131 | 132 | 133 | ==== Szenario: X-Daten für externe Systeme zugänglich 134 | Die X-Daten des Y-Systems sollen für ein externes Werkzeug zur Anforderungsanalyse und -management (etwa: Requisite-Pro, Enterprise-Architect oä) zugänglich sein. 135 | 136 | [horizontal] 137 | Qualitätsziel:: Interoperabilität 138 | 139 | Geschäftsziel(e):: 140 | Datenkompatibilität mit marktüblichen Werkzeugen zur Anforderungsanalyse zählt als Vorteil gegenüber Mitbewerbern. 141 | 142 | Auslöser:: 143 | Ein Endbenutzer möchte die X-Daten des Y-Systems in eines der unterstützten Anforderungstools überführen. 144 | 145 | Kontext:: 146 | 20 Benutzer haben X-Daten in Form einzelner Projekte im System erfasst. 147 | Jedes dieser Projekte enthält mindestens ein, höchstens 100 unterschiedliche Requirements. 148 | 149 | Reaktion:: 150 | Das Y-System exportiert die betreffenden X-Daten in das Anforderungstool (Requisite-Pro oder Enterprise-Architect). 151 | 152 | Zielwert:: 153 | * Beim Export der Daten treten keine Fehler auf. 154 | * Von den im Y-System enthaltenen Requirements werden mindestens 98% korrekt exportiert. 155 | * Sämtliche nicht exportierten Requirements werden den betroffenen Benutzern als Fehler gemeldet. 156 | 157 | 158 | -------------------------------------------------------------------------------- /gradlew: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env sh 2 | 3 | # 4 | # Copyright 2015 the original author or authors. 5 | # 6 | # Licensed under the Apache License, Version 2.0 (the "License"); 7 | # you may not use this file except in compliance with the License. 8 | # You may obtain a copy of the License at 9 | # 10 | # https://www.apache.org/licenses/LICENSE-2.0 11 | # 12 | # Unless required by applicable law or agreed to in writing, software 13 | # distributed under the License is distributed on an "AS IS" BASIS, 14 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 | # See the License for the specific language governing permissions and 16 | # limitations under the License. 17 | # 18 | 19 | ############################################################################## 20 | ## 21 | ## Gradle start up script for UN*X 22 | ## 23 | ############################################################################## 24 | 25 | # Attempt to set APP_HOME 26 | # Resolve links: $0 may be a link 27 | PRG="$0" 28 | # Need this for relative symlinks. 29 | while [ -h "$PRG" ] ; do 30 | ls=`ls -ld "$PRG"` 31 | link=`expr "$ls" : '.*-> \(.*\)$'` 32 | if expr "$link" : '/.*' > /dev/null; then 33 | PRG="$link" 34 | else 35 | PRG=`dirname "$PRG"`"/$link" 36 | fi 37 | done 38 | SAVED="`pwd`" 39 | cd "`dirname \"$PRG\"`/" >/dev/null 40 | APP_HOME="`pwd -P`" 41 | cd "$SAVED" >/dev/null 42 | 43 | APP_NAME="Gradle" 44 | APP_BASE_NAME=`basename "$0"` 45 | 46 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. 47 | DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' 48 | 49 | # Use the maximum available, or set MAX_FD != -1 to use that value. 50 | MAX_FD="maximum" 51 | 52 | warn () { 53 | echo "$*" 54 | } 55 | 56 | die () { 57 | echo 58 | echo "$*" 59 | echo 60 | exit 1 61 | } 62 | 63 | # OS specific support (must be 'true' or 'false'). 64 | cygwin=false 65 | msys=false 66 | darwin=false 67 | nonstop=false 68 | case "`uname`" in 69 | CYGWIN* ) 70 | cygwin=true 71 | ;; 72 | Darwin* ) 73 | darwin=true 74 | ;; 75 | MINGW* ) 76 | msys=true 77 | ;; 78 | NONSTOP* ) 79 | nonstop=true 80 | ;; 81 | esac 82 | 83 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar 84 | 85 | 86 | # Determine the Java command to use to start the JVM. 87 | if [ -n "$JAVA_HOME" ] ; then 88 | if [ -x "$JAVA_HOME/jre/sh/java" ] ; then 89 | # IBM's JDK on AIX uses strange locations for the executables 90 | JAVACMD="$JAVA_HOME/jre/sh/java" 91 | else 92 | JAVACMD="$JAVA_HOME/bin/java" 93 | fi 94 | if [ ! -x "$JAVACMD" ] ; then 95 | die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME 96 | 97 | Please set the JAVA_HOME variable in your environment to match the 98 | location of your Java installation." 99 | fi 100 | else 101 | JAVACMD="java" 102 | which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 103 | 104 | Please set the JAVA_HOME variable in your environment to match the 105 | location of your Java installation." 106 | fi 107 | 108 | # Increase the maximum file descriptors if we can. 109 | if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then 110 | MAX_FD_LIMIT=`ulimit -H -n` 111 | if [ $? -eq 0 ] ; then 112 | if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then 113 | MAX_FD="$MAX_FD_LIMIT" 114 | fi 115 | ulimit -n $MAX_FD 116 | if [ $? -ne 0 ] ; then 117 | warn "Could not set maximum file descriptor limit: $MAX_FD" 118 | fi 119 | else 120 | warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" 121 | fi 122 | fi 123 | 124 | # For Darwin, add options to specify how the application appears in the dock 125 | if $darwin; then 126 | GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" 127 | fi 128 | 129 | # For Cygwin or MSYS, switch paths to Windows format before running java 130 | if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then 131 | APP_HOME=`cygpath --path --mixed "$APP_HOME"` 132 | CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` 133 | 134 | JAVACMD=`cygpath --unix "$JAVACMD"` 135 | 136 | # We build the pattern for arguments to be converted via cygpath 137 | ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` 138 | SEP="" 139 | for dir in $ROOTDIRSRAW ; do 140 | ROOTDIRS="$ROOTDIRS$SEP$dir" 141 | SEP="|" 142 | done 143 | OURCYGPATTERN="(^($ROOTDIRS))" 144 | # Add a user-defined pattern to the cygpath arguments 145 | if [ "$GRADLE_CYGPATTERN" != "" ] ; then 146 | OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" 147 | fi 148 | # Now convert the arguments - kludge to limit ourselves to /bin/sh 149 | i=0 150 | for arg in "$@" ; do 151 | CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` 152 | CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option 153 | 154 | if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition 155 | eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` 156 | else 157 | eval `echo args$i`="\"$arg\"" 158 | fi 159 | i=`expr $i + 1` 160 | done 161 | case $i in 162 | 0) set -- ;; 163 | 1) set -- "$args0" ;; 164 | 2) set -- "$args0" "$args1" ;; 165 | 3) set -- "$args0" "$args1" "$args2" ;; 166 | 4) set -- "$args0" "$args1" "$args2" "$args3" ;; 167 | 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; 168 | 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; 169 | 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; 170 | 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; 171 | 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; 172 | esac 173 | fi 174 | 175 | # Escape application args 176 | save () { 177 | for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done 178 | echo " " 179 | } 180 | APP_ARGS=`save "$@"` 181 | 182 | # Collect all arguments for the java command, following the shell quoting and substitution rules 183 | eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" 184 | 185 | exec "$JAVACMD" "$@" 186 | -------------------------------------------------------------------------------- /src/asciidoc/04_effizienz.adoc: -------------------------------------------------------------------------------- 1 | 2 | 3 | == Effizienz (_performance efficiency_) 4 | 5 | === Was bedeutet Effizienz? 6 | Nach DIN/ISO 9126: Verhältnis zwischen dem Leistungsniveau der Software und dem Umfang der eingesetzten Betriebsmittel unter festgelegten Bedingungen. 7 | 8 | In der Praxis oftmals vereinfacht als _Performance_, Verarbeitungsgeschwindigkeit, Antwortzeit, Skalierbarkeit, Durchsatz, Speicherbedarf oder Mengengerüst bezeichnet. 9 | 10 | Nach DIN/ISO 9126 gehören zu Effizienz folgende Teilmerkmale: 11 | 12 | * _Zeitverhalten_: Antwort- und Verarbeitungszeiten sowie Durchsatz bei der Funktionsausführung. 13 | * _Verbrauchsverhalten_: Anzahl, Menge und Dauer der benötigten Betriebsmittel für die Erfüllung der Funktionen. 14 | 15 | Anmerkung: Die Effizienz vorhandener Software können Sie "am lebenden Objekt" objektiv messen. Insofern ist die Prüfung, ob Effizienzanforderungen an Software erreicht werden, verhältnismäßig einfach möglich. 16 | 17 | 18 | === Szenarien für Effizienz 19 | 20 | 21 | ==== Szenario: Schnelle Erzeugung von Testdaten 22 | Schnelle Erzeugung großer Mengen an Testdaten für das XY-System. 23 | 24 | [horizontal] 25 | Geschäftsziel(e):: 26 | Effektives Testen, Test mit großen Datenmengen. 27 | 28 | Auslöser:: 29 | Ein Tester benötigt für den Test des XY-Systems Testdaten. 30 | 31 | Reaktion:: 32 | Der Testdaten-Generator erzeugt 1 Gigabyte an passenden, fachlich korrekten Testdaten. 33 | 34 | Zielwert:: 35 | Laufzeit weniger als eine Stunde. 36 | 37 | ==== Szenario: Diagnose hat kaum Auswirkungen auf Ausführungszeit 38 | Das Diagnose-Subsystem beeinflusst die Ausführungszeit von Funktionen und Transaktionen des Systems nur in geringem Umfang . 39 | 40 | [horizontal] 41 | 42 | Geschäftsziel(e):: 43 | Genaues Reporting über Laufzeiten und genaue Fehlerdiagnose ohne Beeinträchtigung von Laufzeiten. 44 | 45 | Auslöser:: 46 | Benutzer, Tester oder Administrator ruft eine Diagnosefunktion auf. 47 | 48 | Reaktion:: 49 | Das System arbeitet ohne Einschränkung weiter. 50 | 51 | Zielwert:: 52 | Alle Funktionen und Transaktionen des Systems laufen funktional korrekt. Laufzeiten sind gegenüber abgeschaltetem Diagnose-Subsystem höchstens 5% höher. 53 | 54 | 55 | ==== Szenario: Generierung von Reports in weniger als 4h 56 | Generierung aller für den Monatsabschluss erforderlichen Reports und Listen innerhalb von 4h Laufzeit. 57 | 58 | [horizontal] 59 | Geschäftsziel(e):: 60 | Performanter und pünktlicher Monatsabschluss 61 | 62 | Auslöser:: 63 | Die Controlling- oder Finanz-Abteilung startet nach Buchungsschluss den Monatsabschluss. 64 | 65 | Reaktion:: 66 | Das System generiert alle notwendigen Reports und Listen. 67 | 68 | Zielwert:: 69 | Die Generierung endet spätestens nach 4h Laufzeit, erste (einfache) Reports stehen dem Controlling nach 30 Min Laufzeit zur Verfügung. 70 | 71 | ==== Szenario: Integrationstests in weniger als 15 Minuten 72 | Sämtliche Integrationstests des Subsystems XY können innerhalb von 15 Minuten automatisiert ausgeführt werden. 73 | 74 | [horizontal] 75 | Geschäftsziel(e):: 76 | Risikoarme Änderungen und Erweiterungen. 77 | 78 | Auslöser:: 79 | Entwickler führt eine Änderung am Quellcode im Subsystem XY durch und startet anschließend die automatisierte Testsuite (der Integrations- und Unittests) dieses Subsystems. 80 | 81 | Reaktion:: 82 | Das Testframework führt sämtliche Testfälle aus und berichtet die Testergebnisse an den Benutzer. 83 | 84 | Zielwert:: 85 | Sämtliche Testfälle sind in weniger als 15 Minuten komplett ausgeführt. 86 | 87 | Bemerkung:: 88 | Last-, Performance- oder Stresstests können unabhängig von den Integrationstests auch länger laufen. Diese sind nicht Bestandteil dieses Szenarios. 89 | 90 | 91 | ==== Szenario: Daten innerhalb von 3 Sekunden 92 | In 90% aller Fälle erhalten Benutzer die XY-Daten innerhalb von 3 Sekunden. 93 | 94 | [horizontal] 95 | 96 | Geschäftsziel(e):: 97 | Paralleles Arbeiten mehrerer Benutzer ist mit akzeptabler Laufzeit möglich 98 | 99 | Auslöser:: 100 | 10 echt parallel arbeitende Benutzer fordern vom System die XY-Daten an. 101 | 102 | Reaktion:: 103 | Das System zeigt bei allen anfordernden Benutzern die korrekten Daten an. 104 | 105 | Zielwert:: 106 | Bei mindestens 9 von 10 dieser Benutzer dauert diese Anfrage 3 Sekunden oder weniger (in 90% der Anfragen nach den XY-Daten antwortet das System in 3 Sekunden oder schneller). 107 | 108 | ==== Szenario: Hohe Performanz bei 200 gleichzeitigen Benutzern 109 | Bei 200 oder mehr gleichzeitig angemeldeten Benutzern verhält 110 | sich das System immer noch performant. 111 | 112 | [horizontal] 113 | 114 | Geschäftsziel(e):: 115 | Fähigkeit des Systems, seine Funktionsfähigkeit, insbesondere an der GUI, auch bei mehreren parallelen Benutzern zu erhalten. 116 | 117 | Auslöser:: 118 | * 200 oder mehr Benutzer sind am System angemeldet. 119 | * 20 oder mehr Benutzer arbeiten gleichzeitig im XY-Dialog aus oder starten eine YZ-Berechnung. 120 | 121 | Reaktion:: 122 | Das System arbeitet normal und bedient sämtliche Benutzer. 123 | 124 | Zielwert:: 125 | Die Reaktionen des Systems im XY-Dialog erfolgen innerhalb von 2 Sekunden. 126 | Das System führt die YZ-Berechnung in weniger als 5 Sekunden durch. 127 | Bemerkung: Skalierbarkeit 128 | 129 | 130 | ==== Szenario: Umfangreiche Reports in weniger als 1 Sekunde 131 | Das XY-System soll auch umfangreiche benutzerdefinierte Reports in weniger als 1 Sekunde speichern. 132 | 133 | [horizontal] 134 | Geschäftsziel(e):: 135 | Reaktive Benutzeroberfläche steigert Bedienkomfort. 136 | 137 | Auslöser: 138 | Benutzer hat einen spezifischen Report konfiguriert und speichert diesen über die "speichern" Funktion ab. 139 | 140 | Reaktion und Zielwert: 141 | Das System speichert die gesamte Reportdefinition (im xml-Format) in weniger als 1 Sekunde. 142 | 143 | 144 | ==== Szenario: Konfigurationsoberfläche erscheint in weniger als 2 Sekunden 145 | An Benutzerprofil angepasste grafische Konfigurationsoberfläche erscheint in weniger als 2 Sekunden. 146 | 147 | [horizontal] 148 | Geschäftsziel(e):: 149 | Reaktive Benutzeroberfläche steigert Bedienkomfort. 150 | 151 | Auslöser:: 152 | Benutzer startet die Konfigurationsoberfläche für Reports. 153 | 154 | Reaktion und Zielwert:: 155 | Beim Start der Report-Konfigurationsoberfläche erscheint eine gemäß des Benutzerprofils aufbereitete grafische Oberfläche in weniger als 2 Sekunden. 156 | 157 | 158 | ==== Szenario: Nutzung von höchstens 1GB RAM 159 | Die Anwendung soll als Sockel nur 1 GB RAM benötigen und pro gleichzeitig eingeloggten User nicht mehr als weitere 5 MB 160 | 161 | [horizontal] 162 | Geschäftsziel(e):: 163 | Die Anwendung soll zur Verfügung gestellte Systemressourcen effizient nutzen und Wachstum der Mitarbeiter ermöglichen. 164 | 165 | Auslöser:: 166 | Ein Benutzer meldet sich am System an. 167 | 168 | Reaktion und Zielwert:: 169 | Die Anwendung soll als Sockel nur 1 GB RAM benötigen und pro gleichzeitig eingeloggten User nicht mehr als weitere 5 MB. Nach dem Logout müssen die 5 MB wieder zur freien Verfügung stehen. 170 | 171 | 172 | -------------------------------------------------------------------------------- /src/asciidoc/05_zuverlaessigkeit.adoc: -------------------------------------------------------------------------------- 1 | 2 | == Zuverlässigkeit 3 | 4 | === Was bedeutet Zuverlässigkeit? 5 | Fähigkeit der Software, ihr Leistungsniveau unter festgelegten Bedingungen über einen festgelegten Zeitraum zu bewahren. 6 | 7 | Zu Zuverlässigkeit gehören nach DIN/ISO 9126 folgende Teilmerkmale: 8 | 9 | *Reife:*:: 10 | Geringe Versagenshäufigkeit durch Fehlzustände. 11 | 12 | *Fehlertoleranz:*:: 13 | Fähigkeit, ein spezifiziertes Leistungsniveau bei Software-Fehlern oder Nicht-Einhaltung ihrer spezifizierten Schnittstelle zu bewahren. 14 | 15 | *Wiederherstellbarkeit:*:: 16 | Fähigkeit, bei einem Versagen das Leistungsniveau wiederherzustellen und die direkt betroffenen Daten wiederzugewinnen. 17 | 18 | 19 | 20 | 21 | === Szenarien für Zuverlässigkeit 22 | 23 | ==== Szenario: Detaillierte Auskunft über Fehler 24 | Wenn der Datenimport fehlschlägt, gibt das System detaillierte Auskunft über den/die aufgetretenen Fehler. 25 | 26 | [horizontal] 27 | Geschäftsziel(e):: 28 | Fähigkeit, Fehler im Datenimport schnell zu identifizieren, lokalisieren und zu beheben. 29 | 30 | Auslöser:: 31 | Datenimport schlägt fehl. 32 | 33 | Reaktion:: 34 | System sammelt die für Fehlerdiagnose und -behebung relevanten Informationen (Art des Fehlers, betroffene Datensätze, Zeit, letzte erfolgreiche ausgeführte Aktion etc.) 35 | 36 | Zielwert:: 37 | Relevante Informationen werden in weniger als 30 Sekunden nach Auftreten des Fehlers ins Logfile geschrieben und per smtp-Mail an <[x@y.com](mailto:x@y.com)> geschickt. 38 | 39 | 40 | ==== Szenario: Messgenauigkeit für Zeitmessungen 41 | Das Diagnose-Subsystem soll die gleiche Messgenauigkeit für Zeitmessungen besitzen, wie entsprechende externe Werkzeuge. 42 | 43 | [horizontal] 44 | Geschäftsziel(e):: 45 | Externe Messwerkzeuge für die Ausführungszeiten von Transaktionen liefern identische Ergebnisse zum internen Diagnose-Subsystem. 46 | 47 | Auslöser:: 48 | Ein Benutzer stößt im System eine beliebige Transaktion an. Die interne Diagnose ist dabei auf "ein" konfiguriert. 49 | 50 | Reaktion:: 51 | Das interne Diagnose-Subsystem speichert die Anfangs- und Endzeit der Transaktion. 52 | 53 | Zielwert:: 54 | Die vom internen Diagnose-Subsystem gemessenen Zeiten stimmen im Bereich von 5% mit Werten überein, die externe Werkzeuge für dieselbe Transaktion ermittelt haben. 55 | 56 | 57 | ==== Szenario: Ausfallsicherung für Container 58 | Das System besitzt eine Ausfallsicherung für den Servlet-Container. 59 | 60 | [horizontal] 61 | Geschäftsziel(e):: 62 | Problemlose Behandlung genereller Fehler- und Ausfallsituationen 63 | 64 | Auslöser:: 65 | Der Servlet-Container stürzt aufgrund eines Softwareproblems ab- 66 | Hardware und Betriebssystem sind weiterhin verfügbar. 67 | 68 | Reaktion und Zielwert:: 69 | Das Monitoringsystem entdeckt den Ausfall innerhalb von 1 Sekunde, stellt innerhalb von 15 Sekunden einen Ersatz-Container bereit und ist nach spätestens 120 Sekunden wieder voll funktionsfähig. 70 | 71 | Bemerkungen:: 72 | Für ein konkretes System wäre hierbei zusätzlich zu spezifizieren, ob und in welchem Umfang die gerade aktiven Sessions des ausgefallenen Containers gesichert und auf das Ersatzsystem übertragen werden müssen. 73 | 74 | 75 | ==== Szenario: Keine Abstürze bei Speicherknappheit 76 | Das System verarbeitet während der pdf-Generierung und Dateikonvertierung (im Speicher) Daten im Bereich bis zu mehreren Gigabyte. Sollte es zu Speicherknappheit oder -überlauf kommen, darf das System nicht abstürzen, sondern muss aussagekräftige Log-Meldungen schreiben, die Generierung kontrolliert beenden und die Benutzer darüber benachrichtigen. 77 | 78 | [horizontal] 79 | Geschäftsziel(e):: 80 | Zuverlässigkeit des Systems auch bei umfangreichen und voluminösen Generierungs- und Konvertierungsaufgaben. 81 | 82 | Auslöser:: 83 | Das System generiert oder konvertiert Daten, eventuell verteilt auf mehrere Threads, Prozesse oder Knoten. Es tritt an mindestens einem dieser Threads, Prozesse oder Knoten ein Speicherüberlauf auf. 84 | 85 | Reaktion:: 86 | Das System beendet die entsprechenden Prozesse kontrolliert und speichert den Zwischenstand der Generierung/Konvertierung zur späteren Verwendung ab. Es erzeugt eine passende Logmeldung und informiert den jeweiligen Benutzer über die Situation. 87 | 88 | Zielwert:: 89 | Speicherüberlauf wird innerhalb von 15 Sekunden erkannt, alle beteiligten Prozesse innerhalb weiterer 15 Sekunden kontrolliert beendet. 90 | 91 | Bemerkung:: auch Benutzbarkeit 92 | 93 | ==== Szenario: Funktionale Korrektheit auch bei Unterspannung 94 | Das System verhält sich auch bei Unterspannungen der Hardware-Sensoren (bis zu 15% unterhalb der Nennspannung) in allen Belangen funktional korrekt. 95 | 96 | [horizontal] 97 | Geschäftsziel(e):: 98 | Zuverlässigkeit 99 | 100 | Auslöser:: 101 | Die Spannung der Hardware-Sensoren (z.B. Sensor zur Messung der Papier-Transportgeschwindigkeit, der Durchflussgeschwindigkeit o.ä.) sinkt höchstens 15% unterhalb der vorgeschriebenen Nennspannung. 102 | 103 | Reaktion:: 104 | Alle Systemfunktionen arbeiten korrekt weiter. 105 | 106 | Bemerkung:: 107 | Einige Sensor-Typen verhalten sich bei Unterspannung unkontrollierbar, manche arbeiten langsamer, andere ungenau, andere gar nicht mehr. Die Systemfunktionen müssen daher die Spannung der Sensoren überwachen und auf Spannungsprobleme entsprechend reagieren. 108 | 109 | 110 | ==== Szenario: Kein Datenverlust bei Spannungsverlust oder Unterspannung. 111 | 112 | [horizontal] 113 | Geschäftsziel(e):: 114 | Robustheit gegenüber Schwankungen oder Ausfällen der elektrischen Versorgung. Das System verliert bei Spannungsverlust oder Unterspannung (der gesamten Netzversorgung) keine Daten. 115 | 116 | Auslöser:: 117 | Die Versorgungsspannung fällt aus oder schwankt um bis zu 25%. 118 | 119 | Reaktion:: 120 | Das System ist lange genug durch redundante Stromversorgung gesichert, um im Falle des Verlustes der regulären Stromversorgung noch sämtliche im Speicher befindlichen Daten konsistent auf langfristigen Speichermedien sichern zu können. 121 | 122 | Zielwert:: 123 | Spannungsverlust oder Unterspannung wird innerhalb von 200msec erkannt. 124 | 125 | 126 | ==== Szenario: Das System bietet eine Ausfallsicherung des Servlet-Containers. 127 | 128 | Geschäftsziel(e):: 129 | Das System soll Ausfälle der allgemeinen Infrastruktur (insbesondere Servlet-Container) problemlos und ohne Absturz behandeln. 130 | 131 | Auslöser:: 132 | Der (für viele Systemfunktionen notwendige) Servlet-Container fällt aus. 133 | 134 | Reaktion:: 135 | Das System erkennt den Ausfall und transferiert alle noch zur Verfügung stehenden Daten/Sessions auf einen Ersatz-Servlet-Container. 136 | 137 | Zielwert:: 138 | * Entdecke den Fehler im Servlet-Container innerhalb von 1 Sekunde. 139 | * Fährt den Hot/Cold-Standby Servlet-Container innerhalb von 30 Sekunden hoch. 140 | * Nach 180 Sekunden hat das System die gesamte Funktionalität von vor dem Ausfall wieder hergestellt. 141 | 142 | 143 | ==== Szenario: Stabilität auch bei Dauerbenutzung 144 | Auch im Dauerbetrieb verhält sich das System gegenüber Online-Benutzern angemessen stabil und robust. 145 | 146 | [horizontal] 147 | Geschäftsziel(e):: 148 | Stabilität, Benutzerkomfort 149 | 150 | Auslöser:: 151 | Endbenutzer verwenden das System für mindestens 8 Stunden ohne Neustart, Abmeldung oder sonstige Unterbrechung. 152 | Dabei sind ständig mindestens 20 parallele Benutzer am System angemeldet - höchstens 1000 parallele Benutzer. 153 | 154 | Reaktion:: 155 | Das System funktioniert für alle angemeldeten Benutzer korrekt. 156 | Für den oder die die lange angemeldeten Benutzer gilt dies ebenfalls. 157 | 158 | Zielwert:: 159 | In der gesamten Zeit tritt bei den Benutzern kein Absturz auf. 160 | Anmerkung: Es muss für die Benutzer zumindest so aussehen, als verhalte sich das System stabil. Serverseitige Probleme muss das System gegenüber den Benutzern kaschieren oder durch Standby-Systeme oder Failover kompensieren können. 161 | 162 | 163 | -------------------------------------------------------------------------------- /src/asciidoc/03_benutzbarkeit.adoc: -------------------------------------------------------------------------------- 1 | [[benutzbarkeit]] 2 | == Gebrauchstauglichkeit 3 | // Benutzbarkeit 4 | 5 | === Was bedeutet Gebrauchstauglichkeit ? 6 | // Benutzbarkeit? 7 | 8 | Aufwand, der zur Benutzung erforderlich ist, und individuelle Beurteilung der Benutzung durch eine festgelegte oder vorausgesetzte Benutzergruppe. Hierunter fällt auch der Bereich _Softwareergonomie_. 9 | 10 | Zu Gebrauchtstauglichkeit gehören nach DIN/ISO 25010 folgende Teilmerkmale: 11 | 12 | *Verständlichkeit:*:: Aufwand für den Benutzer, das Konzept und die Anwendung zu verstehen. 13 | *Erlernbarkeit:*:: Aufwand für den Benutzer, die Anwendung zu erlernen (z.B. Bedienung, Ein-, Ausgabe) 14 | *Bedienbarkeit:*:: Aufwand für den Benutzer, die Anwendung zu bedienen. 15 | *Nützlichkeit:*:: . 16 | *Ästetik der Benutzerschnittstelle:*:: . 17 | 18 | === Szenarien für Benutzbarkeit 19 | 20 | 21 | ==== Szenario: Einfache Benutzbarkeit von Testwerkzeug 22 | 23 | Das interaktive Testwerkzeug muss einfach benutzbar sein. 24 | Tester, welche die Benutzer-Akzeptanztests (BA) durchführen, müssen die Bedienung des Testwerkzeuges schnell erlernen können. 25 | 26 | [horizontal] 27 | Qualitätsziel:: Erlernbarkeit 28 | 29 | Geschäftsziel(e):: 30 | Produktive und schnelle Akzeptanztests, schnelle Durchläufe 31 | 32 | Auslöser:: 33 | Ein neue BA-Tester soll mit dem Testwerkzeug ein Release einer Software testen. 34 | 35 | Reaktion:: 36 | Der Tester erlernt das Testwerkzeug und kann danach das Testwerkzeug vollständig bedienen. 37 | 38 | Zielwert:: 39 | Ein Benutzer-Akzeptanztester benötigt für das Erlernen des Testwerkzeugs weniger als zwei Stunden Einarbeitung. 40 | 41 | 42 | ==== Szenario: Konsistente Tastaturkürzel 43 | 44 | Endanwender / Endbenutzer können identische Tastaturkürzel ("keyboard shortcuts") in allen, unabhängig voneinander entwickelten, Modulen des Systems verwenden. 45 | 46 | [horizontal] 47 | Qualitätsziel:: Erlernbarkeit 48 | 49 | Geschäftsziel(e):: 50 | Konsistente Benutzerführung ("User experience") im gesamten Produkt 51 | 52 | Auslöser:: 53 | Benutzer möchte Tastatur zur Navigation innerhalb des Systems verwenden 54 | 55 | Reaktion:: 56 | Benutzer kann die gleichen Funktionen wie bei der Benutzung der Maus ausführen. 57 | 58 | Zielwert:: 59 | Die Tastaturkürzel sind einheitlich vergeben. Bei Verwendung der Tastatur können sämtliche Funktionen schneller oder mindestens genauso schnell wie bei Nutzung der Maus verwendet werden. 60 | 61 | 62 | ==== Szenario: Schnelle Erfassbarkeit von Informationen 63 | Benutzer soll auch Informationen, die nicht im Zusammenhang mit der aktuellen Bildschirmmaske stehen, schnell erfassen können. 64 | 65 | [horizontal] 66 | Qualitätsziele:: Benutzbarkeit, Effizienz 67 | 68 | Geschäftsziel(e):: 69 | Einfache Benutzbarkeit, einfache Navigierbarkeit innerhalb des Systems 70 | 71 | Auslöser:: 72 | Der Benutzer arbeitet mit dem System. Während der Bearbeitung einer Bildschirmmaske möchte er zu einem gänzlich anderen Thema Informationen erfassen oder bearbeiten. 73 | 74 | Reaktion:: 75 | Der Benutzer kann einfach zu dem gewünschten Thema navigieren und nach dessen Bearbeitung einfach zum aktuellen Thema zurückkehren. 76 | 77 | Zielwert:: 78 | Navigation zum gewünschten Thema erfolgt in weniger als 10 Sekunden, die Rückkehr zum aktuellen Thema erfolgt mit nur einem Knopfdruck / Mausklick. 79 | 80 | 81 | ==== Szenario: Hinweis auf Fehleingaben 82 | Benutzer werden grundsätzlich auf inkonsistente oder fehlerhafte Eingaben hingewiesen. 83 | 84 | [horizontal] 85 | Qualitätsziel:: Bedienbarkeit, Fehlertoleranz 86 | 87 | Geschäftsziel(e):: 88 | Konsistenz bei Benutzereingaben 89 | 90 | Auslöser:: 91 | Benutzer gibt Daten ein. 92 | 93 | Reaktion:: 94 | Das System nimmt korrekte Eingabedaten an, weist inkonsistente oder fehlerhafte Eingabedaten zurück. 95 | 96 | Zielwert:: 97 | Im Falle inkonsistenter oder fehlerhafter Eingabedaten gibt das System eine passende Meldung, die den Fehler oder die Inkonsistenz eindeutig und einfach aufzeigt. 98 | 99 | 100 | ==== Szenario: Benutzerfreundliches Verhalten bei Backend-Prozess 101 | 102 | Falls ein Benutzer die pdf-Generierung des XY-Reports unterbricht, hält das System diese Generierung an und übergibt die Kontrolle innerhalb von 15 Sekunden wieder an die Benutzeroberfläche. 103 | 104 | [horizontal] 105 | Qualitätsziel:: Bedienbarkeit 106 | 107 | Geschäftsziel(e):: 108 | Verbessere die Benutzbarkeit der pdf-Generierung 109 | 110 | Auslöser:: 111 | Benutzer möchte die pdf-Generierung des XY-Reports unterbrechen (etwa aufgrund vorheriger Fehleingaben oder sonstiger Gründe) und klickt den "Abbrechen"-Button 112 | 113 | Reaktion:: 114 | Das System unterbricht die Generierung, speichert den bisherigen Generierungszustand (für eventuelle Fortsetzungen) und übergibt die Kontrolle an die Benutzeroberfläche. 115 | 116 | Zielwert:: 117 | Benutzer erhält Kontrolle über das UI innerhalb von 15 Sekunden (d.h. In spätestens 15 Sekunden haben alle beteiligten Generierungsprozesse den Abbrechen-Befehl erfolgreich quittiert). 118 | 119 | Bemerkung:: Die Generierung dieses Reports läuft in mehreren parallelen Threads (oder Prozessen), eventuell sogar auf mehreren unterschiedlichen Prozessoren oder (virtuellen) Maschinen. Die Unterbrechung muss synchron und konsistent über alle diese Ausführungsinstanzen erfolgen. 120 | 121 | 122 | ==== Szenario: Aussagekräftige Fehlermeldungen ohne Absturz 123 | 124 | Falls eine Fehlersituation auftritt, wird dies dem Benutzer in aussagekräftigen Meldungen angezeigt. Das System stürzt bei Ausnahmesituationen (Speicherüberlauf, Hardwarefehler) nicht ab, sondern fährt höchstens kontrolliert herunter. 125 | 126 | [horizontal] 127 | Qualitätsziele:: Fehlertoleranz, Bedienbarkeit 128 | 129 | Geschäftsziel(e):: 130 | Verbessere die Benutzbarkeit (und gefühlte Zuverlässigkeit). Ermögliche Benutzern, zu Fehlern führende Kombinationen von Eingabedaten zu korrigieren, ohne dass das System abstürzt. 131 | 132 | Auslöser:: 133 | Ein Fehler / Ausnahmesituation in der Infrastruktur tritt auf (Speicherüberlauf, Out-of-Memory, Hardwarefehler). 134 | 135 | Reaktion:: 136 | Das System erkennt den Fehler, meldet (soweit möglich) an den Benutzer und fährt kontrolliert herunter. 137 | 138 | Zielwert:: 139 | Fehlererkennung erfolgt innerhalb von 15 Sekunden, Meldung an Benutzer (sofern noch möglich) innerhalb von 1 Sekunde, herunterfahren innerhalb von 15 Sekunden. 140 | 141 | 142 | ==== Szenario: Status lang laufender Prozesse erkennbar 143 | 144 | Das System zeigt den Fortschritt der lange laufenden XY-Konvertierungsprozesse in der grafischen Oberfläche dem Benutzer an. 145 | 146 | [horizontal] 147 | Qualitätsziele:: Bedienbarkeit 148 | 149 | Geschäftsziel(e):: 150 | Fortschrittsüberwachung, Benutzerfreundlichkeit 151 | 152 | Auslöser:: 153 | Benutzer möchte über Fortschritt von lang laufenden Berechnungen/Prozessen informiert werden. 154 | 155 | Reaktion:: 156 | Das System zeigt die Anzahl der bisher verarbeiteten Datensätze, das verarbeitete Datenvolumen in Megabyte sowie den geschätzten verbleibenden Restaufwand an der GUI an. 157 | 158 | Zielwert:: 159 | Die Aktualisierung dieser Informationen erfolgt mindestens alle 60 Sekunden - höchstens alle 5 Sekunden. 160 | 161 | Anmerkung:: Diese XY-Konvertierung dauert 1-18 Stunden. 162 | 163 | 164 | ==== Szenario: Einhaltung der betriebssystem spezifischen User Experience Guidelines 165 | 166 | Das System soll den Auflagen und Vorschlägen der Microsoft Windows User Experience Guidelines für Windows-8 entsprechen. 167 | 168 | [horizontal] 169 | Qualitätsziel:: Ästetik der Benutzungsschnittstelle, Erlernbarkeit 170 | 171 | Geschäftsziel(e):: 172 | Einheitliches, dem Windows-8 Look-and-Feel entsprechendes Aussehen und Verhalten. 173 | 174 | Auslöser:: 175 | Die Benutzeroberfläche und interaktiven Komponenten des Systems sollen neu gestaltet und implementiert werden. 176 | 177 | Zielwert:: 178 | Ein fachkundiger Auditor testiert die Übereinstimmung mit o.g. Guidelines ohne Einschränkung. 179 | 180 | ==== Szenario: Benutzerinteraktionen an grafischer Oberfläche 181 | 182 | Sämtliche Benutzerinteraktion und -meldungen im System sind als GUI implementiert. 183 | 184 | [horizontal] 185 | Qualitätsziel:: Nützlichkeit 186 | 187 | Geschäftsziel(e):: 188 | Erhöhe die Akzeptanz und Produktivität der Arbeit mit dem System. 189 | 190 | Auslöser:: 191 | Alle Anforderungen an das System. 192 | 193 | Zielwert:: 194 | Das System erfordert keine Benutzerinteraktion außerhalb der grafischen Oberfläche. 195 | 196 | -------------------------------------------------------------------------------- /license.txt: -------------------------------------------------------------------------------- 1 | Apache License, Version 2.0 2 | Apache License 3 | Version 2.0, January 2004 4 | http://www.apache.org/licenses/ 5 | 6 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 7 | 8 | 1. Definitions. 9 | 10 | "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. 11 | 12 | "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. 13 | 14 | "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. 15 | 16 | "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. 17 | 18 | "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. 19 | 20 | "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. 21 | 22 | "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). 23 | 24 | "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. 25 | 26 | "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." 27 | 28 | "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 29 | 30 | 2. Grant of Copyright License. 31 | 32 | Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 33 | 34 | 3. Grant of Patent License. 35 | 36 | Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 37 | 38 | 4. Redistribution. 39 | 40 | You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: 41 | 42 | You must give any other recipients of the Work or Derivative Works a copy of this License; and 43 | You must cause any modified files to carry prominent notices stating that You changed the files; and 44 | You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and 45 | If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. 46 | You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 47 | 48 | 5. Submission of Contributions. 49 | 50 | Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 51 | 52 | 6. Trademarks. 53 | 54 | This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 55 | 56 | 7. Disclaimer of Warranty. 57 | 58 | Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 59 | 60 | 8. Limitation of Liability. 61 | 62 | In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 63 | 64 | 9. Accepting Warranty or Additional Liability. 65 | 66 | While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. 67 | 68 | END OF TERMS AND CONDITIONS 69 | 70 | APPENDIX: How to apply the Apache License to your work 71 | 72 | To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. 73 | 74 | Copyright [yyyy] [name of copyright owner] 75 | 76 | Licensed under the Apache License, Version 2.0 (the "License"); 77 | you may not use this file except in compliance with the License. 78 | You may obtain a copy of the License at 79 | 80 | http://www.apache.org/licenses/LICENSE-2.0 81 | 82 | Unless required by applicable law or agreed to in writing, software 83 | distributed under the License is distributed on an "AS IS" BASIS, 84 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 85 | See the License for the specific language governing permissions and 86 | limitations under the License. -------------------------------------------------------------------------------- /doc/quality-requirements-icon.graffle: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | ApplicationVersion 6 | 7 | com.omnigroup.OmniGraffle7 8 | 179.17.0.293761 9 | 10 | CreationDate 11 | 2014-07-20 14:59:03 +0000 12 | Creator 13 | Dr. Gernot Starke 14 | FileType 15 | flat 16 | GraphDocumentVersion 17 | 14 18 | GuidesLocked 19 | NO 20 | GuidesVisible 21 | YES 22 | ImageCounter 23 | 4 24 | LinksVisible 25 | NO 26 | MagnetsVisible 27 | NO 28 | MasterSheets 29 | 30 | ModificationDate 31 | 2017-10-14 13:09:28 +0000 32 | Modifier 33 | Dr. Gernot Starke 34 | MovementHandleVisible 35 | NO 36 | NotesVisible 37 | NO 38 | OriginVisible 39 | NO 40 | PageBreaks 41 | NO 42 | PrintInfo 43 | 44 | NSBottomMargin 45 | 46 | float 47 | 41 48 | 49 | NSHorizonalPagination 50 | 51 | coded 52 | BAtzdHJlYW10eXBlZIHoA4QBQISEhAhOU051bWJlcgCEhAdOU1ZhbHVlAISECE5TT2JqZWN0AIWEASqEhAFxlwCG 53 | 54 | NSLeftMargin 55 | 56 | float 57 | 18 58 | 59 | NSPaperSize 60 | 61 | size 62 | {595, 842} 63 | 64 | NSPrintReverseOrientation 65 | 66 | coded 67 | BAtzdHJlYW10eXBlZIHoA4QBQISEhAhOU051bWJlcgCEhAdOU1ZhbHVlAISECE5TT2JqZWN0AIWEASqEhAFxlwCG 68 | 69 | NSRightMargin 70 | 71 | float 72 | 18 73 | 74 | NSTopMargin 75 | 76 | float 77 | 18 78 | 79 | 80 | ReadOnly 81 | NO 82 | Sheets 83 | 84 | 85 | ActiveLayerIndex 86 | 0 87 | AutoAdjust 88 | 6 89 | AutosizingMargin 90 | 72 91 | BackgroundGraphic 92 | 93 | Bounds 94 | {{0, 0}, {298.1875, 219.9375}} 95 | Class 96 | GraffleShapes.CanvasBackgroundGraphic 97 | ID 98 | 2 99 | Style 100 | 101 | shadow 102 | 103 | Draws 104 | NO 105 | 106 | stroke 107 | 108 | Draws 109 | NO 110 | 111 | 112 | 113 | BaseZoom 114 | 0 115 | CanvasDimensionsOrigin 116 | {0, 0} 117 | CanvasOrigin 118 | {0, 0} 119 | CanvasSize 120 | {298.1875, 219.9375} 121 | CanvasSizingMode 122 | 1 123 | ColumnAlign 124 | 1 125 | ColumnSpacing 126 | 36 127 | DisplayScale 128 | 1 in = 1 in 129 | GraphicsList 130 | 131 | 132 | Bounds 133 | {{185.625, 33.1875}, {39.5625, 40}} 134 | Class 135 | ShapedGraphic 136 | FitText 137 | Vertical 138 | Flow 139 | Resize 140 | FontInfo 141 | 142 | Color 143 | 144 | b 145 | 0 146 | g 147 | 0 148 | r 149 | 1 150 | 151 | Font 152 | Frutiger-Cn 153 | Size 154 | 27 155 | 156 | ID 157 | 37 158 | Style 159 | 160 | fill 161 | 162 | Draws 163 | NO 164 | 165 | shadow 166 | 167 | Draws 168 | NO 169 | 170 | stroke 171 | 172 | Draws 173 | NO 174 | 175 | 176 | Text 177 | 178 | Pad 179 | 1 180 | Text 181 | {\rtf1\ansi\ansicpg1252\cocoartf1504\cocoasubrtf830 182 | {\fonttbl\f0\fnil\fcharset0 Frutiger-Cn;} 183 | {\colortbl;\red255\green255\blue255;\red255\green0\blue0;} 184 | {\*\expandedcolortbl;;\csgenericrgb\c100000\c0\c0;} 185 | \deftab720 186 | \pard\pardeftab720\qc\partightenfactor0 187 | 188 | \f0\fs54 \cf2 \expnd0\expndtw0\kerning0 189 | 42} 190 | VerticalPad 191 | 2 192 | 193 | 194 | 195 | Bounds 196 | {{102.9375, 3.9375}, {91, 144}} 197 | Class 198 | ShapedGraphic 199 | FitText 200 | YES 201 | Flow 202 | Resize 203 | FontInfo 204 | 205 | Color 206 | 207 | b 208 | 0.798753 209 | g 210 | 0.465158 211 | r 212 | 0.26247 213 | space 214 | srgb 215 | 216 | Font 217 | Frutiger-Bold 218 | Size 219 | 103 220 | 221 | ID 222 | 36 223 | Style 224 | 225 | fill 226 | 227 | Draws 228 | NO 229 | 230 | shadow 231 | 232 | Draws 233 | NO 234 | 235 | stroke 236 | 237 | Draws 238 | NO 239 | 240 | 241 | Text 242 | 243 | Text 244 | {\rtf1\ansi\ansicpg1252\cocoartf1504\cocoasubrtf830 245 | {\fonttbl\f0\fnil\fcharset0 Frutiger-Bold;} 246 | {\colortbl;\red255\green255\blue255;\red53\green96\blue192;} 247 | {\*\expandedcolortbl;;\cssrgb\c26247\c46516\c79875;} 248 | \deftab720 249 | \pard\pardeftab720\qc\partightenfactor0 250 | 251 | \f0\b\fs206 \cf2 Q} 252 | 253 | Wrap 254 | NO 255 | 256 | 257 | Bounds 258 | {{185.625, 36.5625}, {39.5625, 39.5625}} 259 | Class 260 | ShapedGraphic 261 | ID 262 | 38 263 | Shape 264 | Circle 265 | Style 266 | 267 | shadow 268 | 269 | Draws 270 | NO 271 | 272 | stroke 273 | 274 | Color 275 | 276 | b 277 | 0.0 278 | g 279 | 0.1491314172744751 280 | r 281 | 1 282 | space 283 | srgb 284 | 285 | Width 286 | 2 287 | 288 | 289 | Text 290 | 291 | VerticalPad 292 | 0.0 293 | 294 | 295 | 296 | GridInfo 297 | 298 | HPages 299 | 1 300 | KeepToScale 301 | 302 | Layers 303 | 304 | 305 | Artboards 306 | 307 | Lock 308 | 309 | Name 310 | Ebene 1 311 | Print 312 | 313 | View 314 | 315 | 316 | 317 | LayoutInfo 318 | 319 | Animate 320 | NO 321 | LineLength 322 | 0.4643835723400116 323 | circoMinDist 324 | 18 325 | circoSeparation 326 | 0.0 327 | layoutEngine 328 | dot 329 | neatoLineLength 330 | 0.20000000298023224 331 | neatoSeparation 332 | 0.0 333 | twopiSeparation 334 | 0.0 335 | 336 | Orientation 337 | 2 338 | OutlineStyle 339 | Basic 340 | PrintOnePage 341 | 342 | RowAlign 343 | 1 344 | RowSpacing 345 | 36 346 | SheetTitle 347 | Arbeitsfläche 1 348 | UniqueID 349 | 1 350 | VPages 351 | 1 352 | VisibleVoidKey 353 | 1 354 | 355 | 356 | SmartAlignmentGuidesActive 357 | YES 358 | SmartDistanceGuidesActive 359 | YES 360 | UseEntirePage 361 | 362 | WindowInfo 363 | 364 | CurrentSheet 365 | 0 366 | Frame 367 | {{4, 51}, {1276, 729}} 368 | ShowInfo 369 | 370 | Sidebar 371 | 372 | SidebarWidth 373 | 200 374 | Sidebar_Tab 375 | 0 376 | VisibleRegion 377 | {{-196.66666666666666, -127.33333333333333}, {1032, 825.33333333333337}} 378 | ZoomValues 379 | 380 | 381 | Arbeitsfläche 1 382 | 0.75 383 | 1 384 | 385 | 386 | 387 | compressOnDiskKey 388 | 389 | copyLinkedImagesKey 390 | 391 | createSinglePDFKey 392 | 393 | exportAreaKey 394 | 2 395 | exportQualityKey 396 | 100 397 | exportSizesKey 398 | 399 | 1 400 | png 401 | 402 | fileFormatKey 403 | 0 404 | htmlImageTypeKey 405 | 0 406 | includeBackgroundGraphicKey 407 | 408 | includeNonPrintingLayersKey 409 | 410 | lastExportTypeKey 411 | 0 412 | marginWidthKey 413 | 0.0 414 | previewTypeKey 415 | 0 416 | readOnlyKey 417 | 418 | resolutionForBMPKey 419 | 1 420 | resolutionForGIFKey 421 | 1 422 | resolutionForHTMLKey 423 | 1 424 | resolutionForJPGKey 425 | 1 426 | resolutionForPNGKey 427 | 1 428 | resolutionForTIFFKey 429 | 1 430 | resolutionUnitsKey 431 | 0 432 | saveAsFlatFileOptionKey 433 | 0 434 | useArtboardsKey 435 | 436 | useMarginKey 437 | 438 | useNotesKey 439 | 440 | 441 | 442 | -------------------------------------------------------------------------------- /src/logo/qr42_logo.graffle/data.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | ApplicationVersion 6 | 7 | com.omnigroup.OmniGrafflePro 8 | 139.18.0.187838 9 | 10 | CreationDate 11 | 2011-01-30 11:13:05 +0000 12 | Creator 13 | Dr. Gernot Starke 14 | GraphDocumentVersion 15 | 8 16 | GuidesLocked 17 | NO 18 | GuidesVisible 19 | YES 20 | ImageCounter 21 | 6 22 | ImageLinkBack 23 | 24 | 25 | 26 | ImageList 27 | 28 | image5.png 29 | 30 | LinksVisible 31 | NO 32 | MagnetsVisible 33 | NO 34 | MasterSheets 35 | 36 | ModificationDate 37 | 2013-09-20 16:21:23 +0000 38 | Modifier 39 | Dr. Gernot Starke 40 | NotesVisible 41 | NO 42 | OriginVisible 43 | NO 44 | PageBreaks 45 | YES 46 | PrintInfo 47 | 48 | NSBottomMargin 49 | 50 | float 51 | 41 52 | 53 | NSHorizonalPagination 54 | 55 | coded 56 | BAtzdHJlYW10eXBlZIHoA4QBQISEhAhOU051bWJlcgCEhAdOU1ZhbHVlAISECE5TT2JqZWN0AIWEASqEhAFxlwCG 57 | 58 | NSLeftMargin 59 | 60 | float 61 | 18 62 | 63 | NSPaperSize 64 | 65 | size 66 | {595, 842} 67 | 68 | NSPrintReverseOrientation 69 | 70 | int 71 | 0 72 | 73 | NSRightMargin 74 | 75 | float 76 | 18 77 | 78 | NSTopMargin 79 | 80 | float 81 | 18 82 | 83 | 84 | ReadOnly 85 | NO 86 | Sheets 87 | 88 | 89 | ActiveLayerIndex 90 | 0 91 | AutoAdjust 92 | 93 | BackgroundGraphic 94 | 95 | Bounds 96 | {{0, 0}, {559, 783}} 97 | Class 98 | SolidGraphic 99 | ID 100 | 2 101 | Style 102 | 103 | shadow 104 | 105 | Draws 106 | NO 107 | 108 | stroke 109 | 110 | Draws 111 | NO 112 | 113 | 114 | 115 | BaseZoom 116 | 0 117 | CanvasOrigin 118 | {0, 0} 119 | ColumnAlign 120 | 1 121 | ColumnSpacing 122 | 36 123 | DisplayScale 124 | 1 0/72 in = 1.0000 in 125 | GraphicsList 126 | 127 | 128 | Bounds 129 | {{152, 358.5}, {282, 23}} 130 | Class 131 | ShapedGraphic 132 | FitText 133 | YES 134 | Flow 135 | Resize 136 | FontInfo 137 | 138 | Color 139 | 140 | b 141 | 0.298039 142 | g 143 | 0.298039 144 | r 145 | 0.298039 146 | 147 | Font 148 | Verdana 149 | Size 150 | 18 151 | 152 | ID 153 | 30 154 | Shape 155 | Rectangle 156 | Style 157 | 158 | fill 159 | 160 | Draws 161 | NO 162 | 163 | shadow 164 | 165 | Draws 166 | NO 167 | 168 | stroke 169 | 170 | Draws 171 | NO 172 | 173 | 174 | Text 175 | 176 | Pad 177 | 0 178 | Text 179 | {\rtf1\ansi\ansicpg1252\cocoartf1187\cocoasubrtf390 180 | \cocoascreenfonts1{\fonttbl\f0\fnil\fcharset0 Verdana;} 181 | {\colortbl;\red255\green255\blue255;\red76\green76\blue76;} 182 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\pardirnatural\qc 183 | 184 | \f0\fs36 \cf2 Software Quality Requirements} 185 | VerticalPad 186 | 0 187 | 188 | Wrap 189 | NO 190 | 191 | 192 | Bounds 193 | {{195, 252}, {134, 110}} 194 | Class 195 | ShapedGraphic 196 | FitText 197 | YES 198 | Flow 199 | Resize 200 | FontInfo 201 | 202 | Color 203 | 204 | b 205 | 0.2 206 | g 207 | 0.2 208 | r 209 | 0.2 210 | 211 | Font 212 | Verdana 213 | Size 214 | 90 215 | 216 | ID 217 | 18 218 | Shape 219 | Rectangle 220 | Style 221 | 222 | fill 223 | 224 | Draws 225 | NO 226 | 227 | shadow 228 | 229 | Draws 230 | NO 231 | 232 | stroke 233 | 234 | Draws 235 | NO 236 | 237 | 238 | Text 239 | 240 | Pad 241 | 0 242 | Text 243 | {\rtf1\ansi\ansicpg1252\cocoartf1187\cocoasubrtf390 244 | \cocoascreenfonts1{\fonttbl\f0\fnil\fcharset0 Verdana;} 245 | {\colortbl;\red255\green255\blue255;\red51\green51\blue51;} 246 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\pardirnatural\qc 247 | 248 | \f0\fs180 \cf2 QR} 249 | VerticalPad 250 | 0 251 | 252 | Wrap 253 | NO 254 | 255 | 256 | Bounds 257 | {{169.5, 300.5}, {146.5, 76.5}} 258 | Class 259 | ShapedGraphic 260 | ID 261 | 29 262 | Shape 263 | Rectangle 264 | Style 265 | 266 | shadow 267 | 268 | Draws 269 | NO 270 | 271 | stroke 272 | 273 | Draws 274 | NO 275 | 276 | 277 | 278 | 279 | Bounds 280 | {{100.15185546875, 213}, {343.82101440429688, 172}} 281 | Class 282 | ShapedGraphic 283 | ID 284 | 28 285 | ImageID 286 | 5 287 | Shape 288 | Rectangle 289 | Style 290 | 291 | fill 292 | 293 | Draws 294 | NO 295 | 296 | shadow 297 | 298 | Draws 299 | NO 300 | 301 | stroke 302 | 303 | Draws 304 | NO 305 | 306 | 307 | 308 | 309 | GridInfo 310 | 311 | HPages 312 | 1 313 | KeepToScale 314 | 315 | Layers 316 | 317 | 318 | Lock 319 | NO 320 | Name 321 | Ebene 1 322 | Print 323 | YES 324 | View 325 | YES 326 | 327 | 328 | LayoutInfo 329 | 330 | Animate 331 | NO 332 | circoMinDist 333 | 18 334 | circoSeparation 335 | 0.0 336 | layoutEngine 337 | dot 338 | neatoSeparation 339 | 0.0 340 | twopiSeparation 341 | 0.0 342 | 343 | Orientation 344 | 2 345 | PrintOnePage 346 | 347 | RowAlign 348 | 1 349 | RowSpacing 350 | 36 351 | SheetTitle 352 | logo-final 353 | UniqueID 354 | 3 355 | VPages 356 | 1 357 | 358 | 359 | ActiveLayerIndex 360 | 0 361 | AutoAdjust 362 | 363 | BackgroundGraphic 364 | 365 | Bounds 366 | {{0, 0}, {559, 783}} 367 | Class 368 | SolidGraphic 369 | ID 370 | 2 371 | Style 372 | 373 | shadow 374 | 375 | Draws 376 | NO 377 | 378 | stroke 379 | 380 | Draws 381 | NO 382 | 383 | 384 | 385 | BaseZoom 386 | 0 387 | CanvasOrigin 388 | {0, 0} 389 | ColumnAlign 390 | 1 391 | ColumnSpacing 392 | 36 393 | DisplayScale 394 | 1 0/72 in = 1.0000 in 395 | GraphicsList 396 | 397 | 398 | Bounds 399 | {{193, 263}, {134, 110}} 400 | Class 401 | ShapedGraphic 402 | FitText 403 | YES 404 | Flow 405 | Resize 406 | FontInfo 407 | 408 | Color 409 | 410 | b 411 | 0.2 412 | g 413 | 0.2 414 | r 415 | 0.2 416 | 417 | Font 418 | Verdana 419 | Size 420 | 90 421 | 422 | ID 423 | 18 424 | Shape 425 | Rectangle 426 | Style 427 | 428 | fill 429 | 430 | Draws 431 | NO 432 | 433 | shadow 434 | 435 | Draws 436 | NO 437 | 438 | stroke 439 | 440 | Draws 441 | NO 442 | 443 | 444 | Text 445 | 446 | Pad 447 | 0 448 | Text 449 | {\rtf1\ansi\ansicpg1252\cocoartf1187\cocoasubrtf390 450 | \cocoascreenfonts1{\fonttbl\f0\fnil\fcharset0 Verdana;} 451 | {\colortbl;\red255\green255\blue255;\red51\green51\blue51;} 452 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\pardirnatural\qc 453 | 454 | \f0\fs180 \cf2 QR} 455 | VerticalPad 456 | 0 457 | 458 | Wrap 459 | NO 460 | 461 | 462 | Bounds 463 | {{169.5, 300.5}, {146.5, 76.5}} 464 | Class 465 | ShapedGraphic 466 | ID 467 | 29 468 | Shape 469 | Rectangle 470 | Style 471 | 472 | shadow 473 | 474 | Draws 475 | NO 476 | 477 | stroke 478 | 479 | Draws 480 | NO 481 | 482 | 483 | 484 | 485 | Bounds 486 | {{100.15185546875, 213}, {343.82101440429688, 172}} 487 | Class 488 | ShapedGraphic 489 | ID 490 | 28 491 | ImageID 492 | 5 493 | Shape 494 | Rectangle 495 | Style 496 | 497 | fill 498 | 499 | Draws 500 | NO 501 | 502 | shadow 503 | 504 | Draws 505 | NO 506 | 507 | stroke 508 | 509 | Draws 510 | NO 511 | 512 | 513 | 514 | 515 | GridInfo 516 | 517 | HPages 518 | 1 519 | KeepToScale 520 | 521 | Layers 522 | 523 | 524 | Lock 525 | NO 526 | Name 527 | Ebene 1 528 | Print 529 | YES 530 | View 531 | YES 532 | 533 | 534 | LayoutInfo 535 | 536 | Animate 537 | NO 538 | circoMinDist 539 | 18 540 | circoSeparation 541 | 0.0 542 | layoutEngine 543 | dot 544 | neatoSeparation 545 | 0.0 546 | twopiSeparation 547 | 0.0 548 | 549 | Orientation 550 | 2 551 | PrintOnePage 552 | 553 | RowAlign 554 | 1 555 | RowSpacing 556 | 36 557 | SheetTitle 558 | logo-final 2 559 | UniqueID 560 | 5 561 | VPages 562 | 1 563 | 564 | 565 | SmartAlignmentGuidesActive 566 | YES 567 | SmartDistanceGuidesActive 568 | YES 569 | UseEntirePage 570 | 571 | WindowInfo 572 | 573 | CurrentSheet 574 | 0 575 | ExpandedCanvases 576 | 577 | Frame 578 | {{39, 196}, {1497, 1222}} 579 | ListView 580 | 581 | OutlineWidth 582 | 142 583 | RightSidebar 584 | 585 | ShowRuler 586 | 587 | Sidebar 588 | 589 | SidebarWidth 590 | 120 591 | VisibleRegion 592 | {{-402, -150}, {1362, 1083}} 593 | Zoom 594 | 1 595 | ZoomValues 596 | 597 | 598 | logo-final 599 | 1 600 | 1 601 | 602 | 603 | logo-final 2 604 | 1 605 | 1 606 | 607 | 608 | 609 | 610 | 611 | -------------------------------------------------------------------------------- /src/asciidoc/02_aenderbarkeit.adoc: -------------------------------------------------------------------------------- 1 | :numbered: 2 | 3 | == Wartbarkeit 4 | 5 | === Was bedeutet Wartbarkeit? 6 | 7 | // ISTQB 8 | // Maintainability: The degree to which a component or system can be modified by the intended maintainer. 9 | // Wartbarkeit/Änderbarkeit: Der Grad, zu dem eine Komponente oder ein System von den dafür vorgesehenen Personen gewartet werden kann. [Nach ISO 25010] 10 | 11 | Wartbarkeit:: Aufwand, der zur Durchführung vorgegebener Änderungen notwendig ist. 12 | Änderungen sind dabei Korrekturen, Verbesserungen oder Anpassungen an 13 | Änderungen der Umgebung, der Anforderungen & der funktionalen 14 | Spezifikationen. 15 | 16 | Zur Änderbarkeit gehören gemäß DIN/ISO 25010 folgende Teilmerkmale: 17 | 18 | *Modularität:*:: Aufwand für die Herstellung und Aufrechterhaltung einer guten funktionalen und technischen Aufteilung der Anwendung in Bausteine 19 | 20 | *Wiederverwendbarkeit:*:: Aufwand für die Verwendung von Bausteinen in einem anderen, als ihrem ursprünglichen Kontext 21 | 22 | *Analysierbarkeit:*:: Aufwand, um Mängel oder Ursachen von Versagen zu 23 | diagnostizieren oder um änderungsbedürftige Teile zu bestimmen. 24 | 25 | *Modifizierbarkeit:*:: Aufwand zur Ausführung von Verbesserungen, zur 26 | Fehlerbeseitigung oder Anpassung an Umgebungsänderungen 27 | 28 | *Änderungsstabilität:*:: Wahrscheinlichkeit des Auftretens unerwarteter Wirkungen 29 | von Änderungen. 30 | 31 | *Testbarkeit:*:: Aufwand, der zur Prüfung der geänderten Software 32 | notwendig ist 33 | 34 | Umgangssprachlich heißt Änderbarkeit oftmals Flexibilität, Anpassbarkeit, Wartbarkeit 35 | oder Erweiterbarkeit. 36 | 37 | 38 | 39 | === Szenarien für Wartbarkeit 40 | 41 | 42 | ==== Szenario: Aktualisierung Betriebssystem auf Endgeräten 43 | Auf den (mehr als 1000) im Feld verteilten Endgeräten müssen 44 | Updates des Betriebssystems (insbesondere Security-Patches) in weniger 45 | als 4 Wochen vollständig verteilt werden können. 46 | 47 | [horizontal] 48 | Geschäftsziele:: Betriebsbereitschaft 49 | 50 | Auslöser:: Betriebssystemupdates stehen bereit 51 | 52 | Reaktion:: Auf allen Endgeräten sind die Updates installiert. 53 | 54 | Zielwert:: 4 Wochen 55 | 56 | ==== Szenario: Neuer Konnektor 57 | 58 | Wenn die Datenimport-Komponente Daten aus einer zusätzlichen 59 | Datenquelle einlesen soll, so muss der dafür notwendige Konnektor 60 | innerhalb von drei Personenmonaten entwickelt, integriert und in Betrieb 61 | genommen werden können. 62 | 63 | [horizontal] 64 | Geschäftsziele:: Flexibilität, Reaktionsfähigkeit, Entgegenkommen 65 | 66 | Auslöser:: Datenimport aus einer zusätzlichen Datenquelle wird notwendig 67 | 68 | Reaktion:: Der neue Konnektor ist programmiert und in Betrieb. 69 | 70 | Zielwert:: 3 Personenmonate 71 | 72 | 73 | ==== Szenario: Jährliche Aktualisierung 74 | 75 | Das Datenausgabeformat des jährlichen Buchungsreports wird jedes Jahr am 31. Dezember angepasst, 76 | um den gesetzlichen und steuerlichen Änderungen zu genügen. Das System muss das neue Format erzeugen können. 77 | 78 | [horizontal] 79 | Geschäftsziele:: Betriebsbereitschaft 80 | 81 | Auslöser:: Bereitstellung der neuen Spezifikation des Datenausgabeformates für Buchungsreports 82 | 83 | Reaktion:: Die Buchungs- und Reportingkomponenten sind geändert und lieferen 84 | den Buchungsreport entsprechend der neuen Spezifikation. 85 | 86 | Zielwert:: Die Änderung muss in weniger als 80 Personenstunden umgesetzt 87 | werden können. 88 | 89 | 90 | ==== Szenario: Plugins entwickeln 91 | 92 | Ein unabhängiger Entwickler kann PlugIns für das System 93 | erstellen. 94 | 95 | [horizontal] 96 | Geschäftsziele:: Ermögliche der "Community", die Basisfunktionalität 97 | des Systems zu erweitern 98 | 99 | Auslöser:: Unabhängiger Entwickler (eine "third party") möchte eigene 100 | Erweiterung ("PlugIn") für das System erstellen 101 | 102 | Reaktion:: Unabhängige Entwickler sind in der Lage, auf Basis 103 | vordefinierter Erweiterungspunkte das System zu erweitern. Dafür sind 104 | neben dem System ausschließlich Open Source Komponenten notwendig. 105 | 106 | Zielwert:: Einfache PlugIns sollen innerhalb von 8 Personenstunden 107 | umsetzbar sein. 108 | 109 | 110 | ==== Szenario: Wechsel des Algorithmus 111 | 112 | Wechsel des Algorithmus zur Routenberechnung. 113 | 114 | [horizontal] 115 | Geschäftsziele:: Setze Änderungen oder Verbesserungen in der 116 | Routenoptimierung möglichst schnell und einfach um 117 | 118 | Auslöser:: Entwickler möchte einen alternativen Algorithmus zur 119 | Berechnung passender Routen entwickeln und in das Gesamtsystem 120 | integrieren. 121 | 122 | Reaktion:: Der Algorithmus zur Routenberechnung ist ausgetauscht. 123 | Es gibt keinerlei Seiteneffekte auf andere Bausteine des 124 | Systems. 125 | 126 | Zielwert:: Es ist lediglich ein einziger Softwarebaustein (Modul, Komponente, 127 | Package) betroffen, der eigentliche Austausch des bestehenden gegen einen alternativen 128 | Algorithmus geschieht innerhalb von 4h (inklusive eventuelle Anpassungen 129 | der Build-Umgebung). 130 | 131 | 132 | ==== Szenario: Neues Feld in Stammdaten 133 | 134 | Ein Entwickler möchte ein neues Feld in die XY-Stammdaten aufnehmen. 135 | 136 | [horizontal] 137 | Geschäftsziele:: Fähigkeit zur Änderung/Anpassung des Domänenmodells 138 | (fachliche Datenstruktur) inklusive Oberfläche und Datenbank. 139 | 140 | Auslöser:: Die Fach-, Business- oder Marketingabteilung 141 | benötigt in den XY-Stammdaten ein neues Attribut vom Typ "String" (maximale 142 | Länge 80 Zeichen) 143 | 144 | Reaktion:: Ein Entwickler identifiziert die zugehörigen Programmteile, 145 | nimmt die notwendigen Erweiterungen vor, testet die Erweiterungen in 146 | Integrations- und Systemtestumgebung. 147 | 148 | Zielwert:: Alle notwendigen Änderungen und zugehörigen Tests sind 149 | innerhalb von 40h (Aufwand) abgeschlossen. 150 | 151 | 152 | ==== Szenario: Unterstütze ANSI SQL-92 kompatible Datenbanksysteme. 153 | 154 | Biete das System Kunden mit verschiedenen DB-Systeme an. 155 | 156 | [horizontal] 157 | Geschäftsziel(e):: Flexibilität, biete das System Kunden mit 158 | unterschiedlichen Datenbanksystemen an. 159 | 160 | Auslöser:: Ein Kunde möchte das System mit einer (bisher nicht unterstützten) (ANSI-SQL-92 kompatiblen) Datenbank verwenden. 161 | 162 | Reaktion:: Entwickler und Tester nehmen das System mit der Datenbank in 163 | Betrieb und führen sämtliche Systemtests durch, insbesondere die SQL-92 164 | Kompatibilitätstests. 165 | 166 | Zielwert:: Sofern die Datenbank die Kompatibilitätstests erfolgreich 167 | durchläuft, sind auch alle übrigen Systemtests erfolgreich. 168 | In diesen Falle beträgt: 169 | 170 | * der Arbeitsaufwand für Systemaufbau, Inbetriebnahme und Testdurchführung maximal 20h 171 | * die Gesamtdauer maximal eine Kalenderwoche. 172 | 173 | 174 | ==== Szenario: Verständlichkeit von generiertem Code 175 | 176 | Generierter Code für Testfälle ist leicht verständlich und 177 | manuell modifizierbar. 178 | 179 | [horizontal] 180 | Qualitätsziele:: Verständlichkeit, Testbarkeit, Modifizierbarkeit 181 | 182 | Geschäftsziel(e):: Tester können den automatisch generierten Code für 183 | Testfälle leicht verstehen und eigenen Bedürfnissen anpassen. 184 | 185 | Auslöser:: Ein Tester beschreibt einen Testfall in einer 186 | (semi-formalen) Sprache. 187 | 188 | Reaktion:: Testcode (in C, Java oder C#) für bestimmte Teile des Systems 189 | wird durch den Code-Generator für Testfälle automatisch auf Basis dieser 190 | Testfallbeschreibung erzeugt. 191 | 192 | Zielwert:: Ein Tester kann den generierten (C- oder Java) Quellcode für 193 | einen Testfall im Mittel in weniger als 30 Minuten verstehen und 194 | einfache Änderungen daran vornehmen. 195 | 196 | Anmerkung:: Im hier genannten Szenario ändern Tester generierten Code. Je 197 | nach Art des Codegenerators könnte dieser geänderte Code bei 198 | Neugenerierung überschrieben werden. Entsprechende Anforderungen müssten 199 | in anderen Szenarien gestellt werden. 200 | 201 | 202 | ==== Szenario: Schnelle Lokalisierung von Fehlern 203 | 204 | Entwickler kann die Ursache fehlgeschlagener Testfälle in 205 | kurzer Zeit lokalisieren. 206 | 207 | [horizontal] 208 | Geschäftsziele:: Kurze Fehlerbehebungszeiten, gute Änderbarkeit, 209 | geringes Risiko bei Änderungen 210 | 211 | Auslöser:: Entwickler, Tester oder das Build-System führen 212 | automatische Testfälle (Unit- oder Integrationstests) aus. 213 | Dabei schlägt ein Test fehl. 214 | 215 | Reaktion:: Aus den Fehler- und/oder 216 | Log-Nachrichten kann ein Entwickler die Ursache/den Auslöser des Fehlers 217 | in kurzer Zeit lokalisieren. 218 | 219 | Zielwert:: Entwickler findet die Ursache durchschnittlich in weniger als 220 | 10 Minuten. 221 | 222 | ==== Szenario: Neue Funktion 223 | 224 | Der Auftraggeber fordert eine neue Funktion im System. 225 | Entwickler identifizieren innerhalb kurzer Zeit die für diese Erweiterung passende Stelle innerhalb des Quellcodes. 226 | 227 | [horizontal] 228 | Geschäftsziel(e):: Schnelle Aufwandsbewertung von Kundenwünschen 229 | 230 | Auslöser:: Änderungsanforderung 231 | 232 | Reaktion:: Entwickler suchen innerhalb des Quellcodes die geeignete 233 | Stelle für die gewünschte Erweiterung. 234 | Darauf aufbauend kann er den Aufwand und die Risiken der gewünschten 235 | Erweiterung besser bewerten/abschätzen. 236 | 237 | Zielwert:: Entwickler finden die geeignete Stelle in weniger als zwei 238 | Stunden. 239 | 240 | ==== Szenario: Kurze Implementierungszeit für neue Funktion 241 | 242 | Eine neue Funktion mittlerer Komplexität soll in kurzer Zeit 243 | implementiert werden können. 244 | 245 | [horizontal] 246 | Geschäftsziele:: Eine neue Funktion mittlerer Komplexität soll in 247 | kurzer Zeit implementiert werden können. 248 | 249 | Auslöser:: Änderungsanforderung 250 | 251 | Reaktion:: Entwickler identifiziert die anzupassenden Bausteine, implementieren in diesen die geforderte Funktion sowie automatisierter Testfälle (Unit-Tests) 252 | 253 | Zielwert:: Der Aufwand für die Fertigstellung der neuen Funktion beträgt weniger 254 | als 5 PT. 255 | 256 | 257 | ==== Szenario: Erweiterte Logmeldungen 258 | 259 | Das bisherige Format der Logmeldungen genügt für den Betreiber 260 | nicht mehr. Sämtliche Logmeldungen müssen um zusätzliche Informationen 261 | ergänzt werden. 262 | 263 | [horizontal] 264 | Geschäftsziel(e):: Flexible Anpassung an geänderte/erweiterte 265 | Anforderungen beim Logging. 266 | 267 | Auslöser:: Betreiber benötigt zusätzliche Informationen in 268 | Logmeldungen (beispielsweise IP-Adresse des ausführenden Webservers, 269 | Session-ID oÄ). 270 | 271 | Reaktion:: Entwickler müssen die betroffenen Stellen im 272 | Quellcode identifizieren, anpassen, testen und in Betrieb nehmen. 273 | 274 | Zielwert:: Die Umsetzung erfolgt innerhalb von weniger als 40h. 275 | 276 | Anmerkung:: Für dieses 277 | Szenario ist das Verhältnis aus Zielwert und Umfang des betroffenen 278 | Quellcodes (LoC) relevant. 279 | 280 | 281 | ==== Szenario: Report in kurzer Zeit implementieren 282 | 283 | Ein Entwickler möchte einen Report über alle Buchungen eines 284 | Tages implementieren 285 | 286 | [horizontal] 287 | Geschäftsziel(e):: Eine neue Funktion (geringer Komplexität) soll in 288 | kurzer Zeit umsetz- und testbar sein 289 | 290 | Auslöser:: Auftraggeber benötigt die Ergebnisse des 291 | Buchungsreports 292 | 293 | Reaktion:: 294 | * Entwickler implementiert diese Funktion innerhalb von 3 Arbeitstagen. 295 | * Tester testet diese Funktion gegen die Spezifikation innerhalb von 2 Arbeitstagen. 296 | 297 | Zielwert:: Der neue Report wird mit einem maximalen Aufwand von 16h und nach einer maximalen Dauer von 5 Arbeitstagen zur Verfügung. 298 | 299 | 300 | ==== Szenario: Schnittstelle um Authentifizierung erweitern 301 | 302 | Entwickler erweitert die externe XY-Schnittstelle um 303 | Authentifizierung. 304 | 305 | [horizontal] 306 | Geschäftsziel(e):: Die XY-Schnittstelle benötigt ab sofort eine sichere 307 | Authentifizierung. 308 | 309 | Auslöser:: Regularien oder Kundenanforderungen erfordern eine 310 | sichere Authentifizierung über OAuth 2.0 der XY-Schnittstelle 311 | 312 | Reaktion:: Der Entwickler erweitern die Schnittstelle um OAuth 2.0 basierter Authentifizierung. 313 | 314 | Zielwert:: Absicherung der XY-Schnittstelle benötigt einen Entwicklungsaufwand von max 5 PT. 315 | 316 | 317 | ==== Szenario: Kommerzielle durch Open-Source Datenbank ersetzen 318 | 319 | Das verwendete, kommerzielle Datenbankmanagementsystem muss 320 | durch ein lizenzkostenfreies, Open-Source-Produkt ersetzt werden können. 321 | 322 | [horizontal] 323 | Geschäftsziele:: Bei Bedarf und in bestimmten Einsatzszenarien des 324 | Systems müssen Lizenzkosten reduziert werden. 325 | 326 | Auslöser:: Betreiber/Kunde des Systems möchte die Lizenzkosten 327 | des verwendeten Datenbanksystems reduzieren. 328 | 329 | Reaktion:: Entwickler ersetzen die standardmäßig verwendete kommerzielle 330 | Datenbank durch ein quelloffenes, lizenzkostenfreies DBMS ersetzen. 331 | Es wird sichergestellt, dass alle funktionalen Anforderungen erfüllt werden. 332 | Dies wird durch die Ausführung der automatisierten Integrations-, System- und Abnahmetests nachgewiesen. 333 | 334 | Zielwert:: 335 | 336 | * Die zusätzlichen Unterstützung des alternativen Datenbankmanagementsystems 337 | ist mit weniger als 40 PT Aufwand durchführbar. 338 | * Die Laufzeiten der wichtigsten 15 Anwendungsfälle verschlechtert sich 339 | gegenüber der kommerziellen Datenbank um höchstens 15%. 340 | * Die Laufzeiten aller übrigen Anwendungsfälle verschlechtert sich 341 | gegenüber der kommerziellen Dankbank um höchstens 25%. 342 | 343 | 344 | ==== Szenario: Geschäftsprozess erweitern 345 | 346 | Der Geschäftsprozess XY kann zur Laufzeit um zusätzlicher 347 | Verarbeitungsschritte ergänzt werden 348 | 349 | [horizontal] 350 | Geschäftsziele:: Dynamische Erweiterung des Geschäftsprozesses XY trägt 351 | zur Zufriedenheit der Anwender bei. 352 | 353 | Auslöser:: Zur Anpassung an Marktbedürfnisse erweitert ein 354 | Entwickler oder Architekt den Geschäftsprozess XY um einen zusätzlichen 355 | Schritt, während die aktiven Prozessinstanzen von XY vom System 356 | bearbeitet werden. 357 | 358 | Kontext:: Mehr als 20 Benutzer haben unvollständige Projekte (Daten) auf 359 | Basis des aktuellen XY-Prozesses gespeichert. 360 | 361 | Reaktion:: Das System aktualisiert selbständig und ohne 362 | Datenverlust die vorhandenen Daten der unvollständigen Projekte 363 | (automatische Migration der benutzerspezifischen Daten auf die neue 364 | Version von XY). 365 | 366 | Zielwert:: 367 | Die Änderung des XY-Prozesses dauert nicht länger als 80 Personenstunden 368 | (Aufwand). 369 | 370 | 371 | ==== Szenario: Änderung am Geschäftsprozess 372 | 373 | Der einzelne Verarbeitungsschritt AB innerhalb des 374 | Anwendungsfalls XY wird von der Regulierungsbehörde für ungültig erklärt 375 | und im System entfernt. Die vom System bearbeiteten Daten sind nicht 376 | betroffen. 377 | 378 | [horizontal] 379 | Geschäftsziel(e):: Die Änderung am Anwendungsfall XY kann mit geringen 380 | Kosten und ohne negative Auswirkungen durchgeführt werden. 381 | 382 | Auslöser:: Der Gesetzgeber, vertreten durch die 383 | Regulierungsbehörde, untersagt die Verwendung des Verarbeitungsschrittes 384 | AB. 385 | 386 | Reaktion:: Ein Entwickler oder Architekt entfernt im System den 387 | Verarbeitungsschritt AB (durch Löschen der entsprechenden Aufrufe oder 388 | durch Neukonfiguration der Prozessabläufe). 389 | + 390 | Diese Änderung hat keine Auswirkung auf die im System vorhandenen Daten 391 | der Anwender/Kunden bezüglich des XY-Anwendungsfalles. Eine 392 | (automatische) Migration einiger Daten ist zulässig, darf allerdings die 393 | 24 Zeitstunden-Grenze nicht überschreiten. 394 | 395 | Zielwert:: Die Änderung erfordert höchstens 24 Zeitstunden mit höchstens 396 | 48 Personenstunden Aufwand. Nach dieser Zeit ist das System wieder 397 | völlig funktionsfähig. 398 | 399 | 400 | ==== Szenario: Erweiterung um automatisierte Testsuite 401 | 402 | Erweitere das X-Subsystem um eine vollständig automatisierte 403 | Testsuite. 404 | 405 | [horizontal] 406 | Geschäftsziel(e):: Verbessere die Änderbarkeit und Testbarkeit des 407 | Systems. 408 | 409 | Auslöser:: Kunde kündigt umfangreiche Änderungswünsche am 410 | X-Subsystem an. Die bessere Änderbarkeit und Testbarkeit reduzieren das 411 | Risiko dieser Änderungen. 412 | 413 | Reaktion:: Entwickler implementieren Unit- und Integrationstests für 414 | sämtliche Klassen sowie Schnittstellen des Subsystems X. 415 | 416 | Zielwert:: Gesamtaufwand der Änderungen liegt unter 200 Personentagen. 417 | 418 | 419 | ==== Szenario: Neuer Typ von Client 420 | 421 | Erweitere das XY-System um einen mobilen Client (Android, 422 | iOS), ohne die Performance der übrigen GUI-Teile zu beeinträchtigen. 423 | 424 | [horizontal] 425 | Geschäftsziele:: Einführung neuer Zugangswege verbreitert die 426 | mögliche Kundenbasis und steigert die Attraktivität des Systems. 427 | 428 | Auslöser:: Kunden und Verbraucher erwarten (wie 429 | selbstverständlich) native mobile Clients als Bestandteil des 430 | Produktportfolios. 431 | 432 | Reaktion:: Entwicklungsteam entwirft und implementiert mobile Clients 433 | für das XY-System sowie die dazu benötigte (Daten-)Schnittstelle. 434 | 435 | Zielwert:: 436 | - Die bisherigen (Browser- und Rich-)Clients werden in ihrer Funktion und 437 | Performance in keiner Weise beeinträchtigt. 438 | - Bei 100 parallelen Browser-Benutzern und 100 gleichzeitig angemeldeten mobilen Clients 439 | dürfen maximal 3% der Datenzugriffe maximal 20% mehr Zeit beanspruchen 440 | als vor der Einführung der mobilen Clients. 441 | 442 | Anmerkung:: Dieses Szenario beschreibt mehrere Qualitätsmerkmale: 443 | Attraktivität, Effizienz/Performance, Verfügbarkeit, Robustheit und 444 | Änderbarkeit. 445 | 446 | 447 | ==== Szenario: Unabhängige Erweiterung eines Subsystems 448 | 449 | Erweiterungen oder Änderungen eines Subsystems sollen 450 | unabhängig von allen anderen Subsystemen möglich sein. 451 | 452 | [horizontal] 453 | Geschäftsziel(e):: Leichte Änderbarkeit, schnelle Reaktion auf Fehler. 454 | 455 | Auslöser:: Entwicklungsteam ändern innerhalb eines 456 | Subsystems - die Außenschnittstellen dieses Subsystems bleiben dabei 457 | identisch! 458 | 459 | Zielwert:: Kein anderes Subsystem muss geändert werden. Für sämtliche 460 | anderen Subsysteme gilt: 461 | 462 | * Der Quellcode bleibt identisch 463 | * Compile-, Build- und Testprozesse bleiben identisch 464 | * Deployment-, Installation und Konfiguration bleiben identisch 465 | 466 | Anmerkung:: Diese Anforderung bedeutet, dass sämtliche Subsysteme nur 467 | über ihre öffentlichen ("offiziellen") Schnittstellen kommunizieren - 468 | und kein Subsystem Interna eines anderen verwendet oder ausnutzt. 469 | Herausfordernd insbesondere bei Kopplung über Daten oder 470 | Datenstrukturen. 471 | -------------------------------------------------------------------------------- /src/asciidoc/tabelle_der_q_merkmale.adoc: -------------------------------------------------------------------------------- 1 | 2 | [[Q-Merkmale]] 3 | ## Q-Merkmale 4 | 5 | Draußen im Dschungel der Realität warten Dutzende verschiedener Qualitätsanforderungen oder 6 | Qualitätsziele auf ihre Erfüllung. Hier der Versuch, diese etwas präziser zu definieren und 7 | zu kategorisieren. 8 | 9 | 10 | 11 | 12 | [cols="1,3a,1", options="header"] 13 | |======= 14 | | Q-Merkmal 15 | a| Bedeutung 16 | | Oberbegriffe 17 | 18 | 19 | | Absturzsicherheit 20 | | 21 | | Zuverlässigkeit 22 | 23 | | Administrierbarkeit 24 | | Benötigter Aufwand zur Administration (Verwaltung) einer Software 25 | | Betreibbarkeit 26 | 27 | | Ästhetik (der Benutzungsschnittstelle) 28 | | Grad, zu dem eine Benutzungsschnittstelle eine für 29 | Nutzer angenehme und zufriedenstellende Interaktion ermöglicht 30 | | Gebrauchstauglichkeit 31 | 32 | | Analysierbarkeit 33 | | * Aufwand, um Mängel oder Ursachen von Versagen zu diagnostizieren oder um änderungsbedürftige Teile zu bestimmen 34 | * Grad der Effektivität und Effizienz, mit der es möglich ist, den Einfluss von 35 | beabsichtigten Änderungen eines Produkts oder Systems auf seine 36 | Bestandteile zu bewerten, ein Produkt auf Mängel oder Ausfallgründe zu 37 | prüfen oder zu ändernde Teile zu identifizieren. 38 | * (engl.: degree to which the software product can be diagnosed for 39 | deficiencies or causes of failures in the software, or for the parts to be 40 | modified to be identified.) 41 | 42 | | Änderbarkeit 43 | 44 | | *Änderbarkeit* 45 | | Aufwand, der zur Durchführung vorgegebener Änderungen notwendig ist. Änderungen sind Korrekturen, Verbesserungen oder Anpassungen der Umgebung, Infrastruktur, Betriebsmittel, der Anforderungen, der internen Struktur, der Implementierung oder technischer Konzepte. 46 | | 47 | 48 | | Angemessenheit 49 | | Liefern der richtigen oder vereinbarten Ergebnisse oder Wirkungen, z.B. die benötigte Genauigkeit berechneter Ergebnisse. 50 | | Funktionalität 51 | 52 | | Angemessenheitserkennung (engl: Appropriateness recognisability) 53 | | Grad, zu dem Nutzer erkennen können, ob ein Produkt oder System 54 | für ihre Bedürfnisse angemessen ist (funktionale Angemessenheit). 55 | | Gebrauchstauglichkeit 56 | 57 | | Anpassbarkeit 58 | | * Fähigkeit der Software zur Anpassung an verschiedene Umgebungen oder Nutzungsszenarien. 59 | * Grad der Effektivität und Effizienz, mit der ein System von 60 | einer Hardware-, Software- oder Nutzungsumgebung in eine andere 61 | transferiert werden kann. 62 | | Übertragbarkeit 63 | 64 | | Antwortzeit 65 | | Zeit, bis die Software ein gewünschtes Ergebnis erzielt oder errechnet. 66 | | Effizienz 67 | 68 | | Auditierbarkeit 69 | | 70 | | Prüfbarkeit 71 | 72 | 73 | | Ausfallsicherheit 74 | | Fähigkeit des Systems, auch bei Ausfall einiger Bestandteile (Hardware oder Software) ein definiertes Leistungsniveau erhalten zu können. 75 | Im Zuge von verteilten Systemen auch: Toleranz gegenüber partiellen Ausfällen einzelner Netzsegmente. 76 | | Zuverlässigkeit, Partitionstoleranz 77 | 78 | 79 | | Ausschaltzeit | | Effizienz 80 | 81 | | Austauschbarkeit 82 | | 83 | * Möglichkeit (und der dafür nötiger Aufwand), diese Software anstelle einer spezifizierten anderen in der Umgebung jener Software zu verwenden. 84 | * Grad, zu dem ein Produkt ein anderes bestimmtes Softwareprodukt mit 85 | demselben Zweck in derselben Umgebung ersetzen kann. 86 | | Übertragbarkeit 87 | 88 | 89 | | Authentizität 90 | | Grad, zu dem nachgewiesen werden kann, dass die Identität einer Person oder 91 | Ressource der angegebenen Identität entspricht. 92 | | Sicherheit 93 | 94 | 95 | 96 | | Autonomie 97 | | Fähigkeit eines Systems, sein Leistungsniveau unabhängig von anderen Systemen zu erbringen. 98 | | **Betreibbarkeit** 99 | 100 | | Barrierefreiheit 101 | | Grad, zu dem ein Produkt oder System von Personen mit verschiedensten 102 | Eigenschaften und Fähigkeiten genutzt werden kann, um ein 103 | bestimmtes Ziel in einem bestimmten Nutzungskontext zu erreichen. 104 | | Gebrauchstauglichkeit 105 | 106 | | Bedienbarkeit 107 | | Aufwand für den Benutzer, die Anwendung zu bedienen. 108 | | Benutzbarkeit 109 | 110 | 111 | | *Benutzbarkeit* 112 | | Aufwand, der zur Benutzung erforderlich ist, und individuelle Beurteilung der Benutzung durch eine festgelegte oder vorausgesetzte Benutzergruppe. 113 | | 114 | 115 | | Benutzerfreundlichkeit 116 | | Siehe Benutzbarkeit 117 | | Benutzbarkeit 118 | 119 | 120 | | Berechenbarkeit 121 | | 122 | | Zuverlässigkeit 123 | 124 | 125 | | Betreibbarkeit 126 | | 127 | * Fähigkeit zur Erfüllung vorgegebener Aufgaben im Rahmen allgemeiner Anforderungen an Wirtschaftlichkeit, Verfügbarkeit, Sicherheit etc. 128 | * Möglichkeit das System mit wirtschaftlich und organisatorisch angemessenem Aufwand in seiner Ablaufumgebung zu betreiben 129 | | Administrierbarkeit 130 | 131 | 132 | | Datensicherheit 133 | | 134 | | Sicherheit 135 | 136 | 137 | | Durchsatz 138 | | 139 | | Effizienz 140 | 141 | 142 | | **Effizienz** 143 | | Verhältnis zwischen dem Leistungsniveau der Software und dem Umfang der eingesetzten Betriebsmittel unter festgelegten Bedingungen 144 | | Performance 145 | 146 | 147 | | Einfachheit 148 | | 149 | - Einfache Bedienbarkeit 150 | - Einfache Änderbarkeit 151 | | Bedienbarkeit, Änderbarkeit, 152 | 153 | 154 | | Einheitlichkeit 155 | | 156 | | Verständlichkeit, Bedienbarkeit, Änderbarkeit 157 | 158 | | Erlernbarkeit 159 | | 160 | * Aufwand für den Benutzer, die Anwendung des Systems zu erlernen 161 | (z.B. Bedienung, Ein-, Ausgabe) 162 | | Bedienbarkeit. 163 | 164 | | Erwartungskonformität 165 | | Grad, zu dem ein Produkt oder System die Nutzerbedürfnisse in einem 166 | bestimmten Nutzungskontext erfüllt. 167 | | Gebrauchstauglichkeit 168 | 169 | | Erweiterbarkeit 170 | | 171 | | Änderbarkeit 172 | 173 | | Fehlersicherheit 174 | | Grad, zu dem ein System seine Nutzer vor Fehler bewahrt. 175 | | Bedienbarkeit 176 | 177 | | Fehlertoleranz 178 | | 179 | * Grad, zu dem ein Produkt, System oder eine Systemkomponente trotz 180 | vorliegender Hardware- oder Softwarefehlern wie beabsichtigt arbeitet. 181 | * Fähigkeit, ein spezifiziertes Leistungsniveau bei Softwarefehlern oder 182 | Nichteinhaltung spezifizierter Schnittstellen zu bewahren 183 | | Zuverlässigkeit 184 | 185 | 186 | | Flexibilität 187 | | Anpassungsfähigkeit an wechselnde Umstände. Möglichkeit zur einfachen Einarbeitung von Änderungen, Erweiterungen oder Behebung von Fehlern. 188 | | Änderbarkeit 189 | 190 | 191 | | **Funktionalität** 192 | | Vorhandensein von Funktionen mit festgelegten Eigenschaften;diese Funktionen erfüllen die definierten Anforderungen 193 | | 194 | 195 | | Funktionale Angemessenheit 196 | | Grad, zu dem die Funktionen die Erreichung bestimmter 197 | Aufgaben erleichtern (Aufgabenangemessenheit). 198 | | Funktionalität 199 | 200 | | Funktionale Korrektheit 201 | | Grad, zu dem ein Produkt oder System die korrekten Ergebnisse mit der 202 | erforderlichen Präzision liefert. 203 | | Funktionalität 204 | 205 | | *Funktionale Tauglichkeit* 206 | | Grad, in dem ein Produkt oder System Funktionen bereitstellt, die vorgegebene oder implizite Anforderungen erfüllen, sofern das Produkt unter 207 | spezifizierten Bedingungen genutzt wird. 208 | (EN: degree to which a product or system provides functions that meet stated and implied needs when used under specified conditions) 209 | | in ISO-9126 210 | 211 | | Funktionale Vollständigkeit 212 | | Grad, zu dem die Menge der Funktionen alle spezifizierten Aufgaben und Nutzerziele abdeckt. 213 | | Funktionalität 214 | 215 | | *Gebrauchstauglichkeit* (engl: operability, auch: useabilty) 216 | | Grad, zu dem ein Produkt oder System von bestimmten Nutzern genutzt werden 217 | kann, um deren Ziele in einem bestimmten Nutzungskontext effektiv, 218 | effizient und zufriedenstellend zu erreichen. 219 | | 220 | 221 | | Gefahrlosigkeit 222 | | 223 | | Zuverlässigkeit 224 | 225 | 226 | | Genauigkeit 227 | | 228 | | Zuverlässigkeit, Funktionalität 229 | 230 | 231 | | Geschwindigkeit 232 | | 233 | | Effizienz 234 | 235 | 236 | | Glaubwürdigkeit 237 | | Maß der Bereitschaft von Benutzern eines Systems, dessen Ergebnisse als gültig zu akzeptieren. 238 | | Zuverlässigkeit, Robustheit 239 | 240 | 241 | | Größe 242 | | Umfang der Software, etwa in Lines-of-Code oder in Byte 243 | | Effizienz 244 | 245 | 246 | | Gültigkeit 247 | | i.d.R. bezogen auf Daten 248 | | Zuverlässigkeit, Funktionalität 249 | 250 | 251 | | Installierbarkeit 252 | | * Aufwand, der zum Installieren der Software in einer festgelegten Umgebung notwendig ist 253 | * Grad der Effektivität und Effizienz, mit der ein System in einer bestimmten 254 | Umgebung erfolgreich installiert und/oder deinstalliert werden kann. 255 | | **Übertragbarkeit**, Betreibbarkeit 256 | 257 | 258 | 259 | | Integrität 260 | | * Verhinderung unautorisierter Modifikation von Information (ITSEC) 261 | * Korrektheit (Unversehrtheit) von Daten und der korrekten Funktionsweise 262 | von Systemen (BSI) 263 | * Grad, zu dem ein System oder eine Systemkomponente 264 | die Genauigkeit und Vollständigkeit von Daten und Abläufen sicherstellt. 265 | 266 | Arten der Integrität: korrekter Inhalt, unmodifizierter Zustand, Erkennung 267 | von Modifikationen, temporale Korrektheit 268 | | Sicherheit 269 | 270 | 271 | | Interoperabilität 272 | | Fähigkeit, mit vorgegebenen Systemen zusammenzuwirken. 273 | Hierunter fällt auch die Einbettung in die Betriebsumgebung oder technische Infrastruktur. 274 | | Kompatibilität 275 | 276 | | Kapazität 277 | | Grad, zu dem die Höchstgrenzen eines Produkt- oder Systemparameters die 278 | Anforderungen erfüllen. 279 | | Effizienz 280 | 281 | | Koexistenz 282 | | Grad, zu dem ein Produkt die erforderlichen Funktionen effizient ausführen 283 | kann, während es sich eine gemeinsame Umgebung und gemeinsame 284 | Ressourcen mit anderen Produkten teilt, ohne dabei schädlichen 285 | Einfluss auf ein anderes Produkt zu haben. 286 | | Kompatibilität 287 | 288 | | *Kompatibilität* 289 | | Grad, zu dem ein Produkt, System oder eine Komponente Informationen mit 290 | anderen Produkten, Systemen oder Komponenten austauschen kann und/oder 291 | seine erforderlichen Funktionen ausführen kann, während es dieselbe 292 | Hardware- oder Softwareumgebung teilt 293 | | 294 | 295 | | Konfigurierbarkeit 296 | | 297 | | Betreibbarkeit, Änderbarkeit 298 | 299 | 300 | | Konformität 301 | | Grad, zu dem die Software Normen oder Vereinbarungen erfüllt. Differenziert nach Merkmalen (etwa bezüglich Normen zur Sicherheit oder Zuverlässigkeit) 302 | | 303 | 304 | 305 | | Konsistenz 306 | | Synonym: Integrität. 307 | * Bezüglich Daten: 308 | + Maß, in dem Daten sowie deren Beziehungen deren Gültigkeitsregeln genügen. 309 | + Clienten einer Datenbank erhalten bei identischen Anfragen identische Ergebnisse. 310 | * Bezüglich Verhalten: Maß, in dem sich ein System schlüssig und nachvollziehbar verhält. 311 | 312 | Weitere Verfeinerung: Monotonic-Read-Consistency, Montonic-Write-Consistency, Read-Your-Writes-Consistency, 313 | Write-Follows-Read-Consistency. Siehe Erläuterungen zum CAP-Theorem. http://www.infoq.com/articles/cap-twelve-years-later-how-the-rules-have-changed 314 | | Integrität 315 | 316 | | Korrektheit 317 | | Eigenschaft eines Systems, seiner Spezifikation zu genügen. 318 | | Funktionalität, Zuverlässigkeit 319 | 320 | 321 | | Latenz 322 | | Synonym: Verzögerungszeit. Zeit vom Ende eines Ereignisses bis zum Beginn der Reaktion auf dieses Ereignis. 323 | | Effizienz 324 | 325 | 326 | | Laufzeiteffizienz 327 | | Sparsamkeit eines Systems (meist: eines Algorithmus) bezüglich der Ressource "Rechenzeit" 328 | | Effizienz 329 | 330 | 331 | | Leistungsfähigkeit 332 | | Fähigkeit eines Systems, spezifizierte Dienste oder Leistungen zu erbringen. 333 | | Effizienz 334 | 335 | 336 | | Lokalisierbarkeit 337 | | Anpassungsfähigkeit an landes- oder sprachspezifische Anforderungen. 338 | | Bedienbarkeit, Änderbarkeit, Flexibilität 339 | 340 | 341 | | Modifizierbarkeit 342 | | 343 | * Aufwand zur Ausführung von Verbesserungen, zur Fehlerbeseitigung oder 344 | Anpassung an Umgebungsänderungen. 345 | * Grad, zu dem ein Produkt oder System effektiv und effizient 346 | geändert werden kann, ohne Mängel zu verursachen oder die bestehende 347 | Produktqualität zu verringern. 348 | | Änderbarkeit 349 | 350 | 351 | | Modularität 352 | | 353 | * Zerlegung eines Systems in Einzelbausteine mit definierten Schnittstellen. 354 | * Grad, zu dem ein System oder Computerprogramm aus einzelnen Komponenten besteht, 355 | so dass eine Änderung einer Komponente nur minimalen Einfluss auf andere Komponenten hat. 356 | | Wartbarkeit, Änderbarkeit 357 | 358 | 359 | 360 | | Nachvollziehbarkeit 361 | | 362 | | 363 | 364 | | Nachweisbarkeit 365 | | Grad, zu dem es möglich ist, nachzuweisen, dass Aktionen oder 366 | Ereignisse tatsächlich stattgefunden haben, so dass Ereignisse und 367 | Aktionen später nicht in Frage gestellt werden können. 368 | | Sicherheit, Nichtabstreitbarkeit 369 | 370 | | Nichtabstreitbarkeit 371 | | ->Nachweisbarkeit 372 | | Sicherheit 373 | 374 | 375 | | Nichtangreifbarkeit 376 | | 377 | | Sicherheit 378 | 379 | 380 | | Normgerechtigkeit 381 | | Siehe Konformität. 382 | | Konformität 383 | 384 | 385 | | Ordnungsmäßigkeit 386 | | Erfüllung von anwendungsspezifischen Normen, Vereinbarungen, gesetzlichen Bestimmungen und ähnlichen Vorschriften 387 | | Funktionalität 388 | 389 | 390 | | Partitionstoleranz 391 | | Das System arbeitet auch bei Ausfall einzelner Knoten, Netzsegmente oder sonstiger Systembestandteile weiter. Begriff wird insbesondere im Zusammenhang mit dem http://en.wikipedia.org/wiki/CAP_theorem[CAP-Theorem] und verteilten Datenbanken (http://nosql-database.org/[NoSQL-DB]) verwendet. 392 | | **Zuverlässigkeit**, Ausfallsicherheit 393 | 394 | 395 | | Performanz 396 | | Siehe <>. 397 | | Effizienz 398 | 399 | 400 | | Personalisierbarkeit 401 | | 402 | | Änderbarkeit, Betreibbarkeit 403 | 404 | 405 | | Portabilität 406 | | Grad der Plattformunabhängigkeit 407 | | Übertragbarkeit 408 | 409 | 410 | | Prüfbarkeit 411 | | Aufwand, der zur Prüfung der Software notwendig ist, insbesondere nach Änderungen 412 | | Zuverlässigkeit 413 | 414 | 415 | | Reaktionszeit 416 | | 417 | | Effizienz 418 | 419 | 420 | | Reife 421 | | Grad, zu dem ein Produkt, System oder eine Systemkomponente 422 | Zuverlässigkeitsbedürfnisse bei normaler Benutzung erfüllt. 423 | | Zuverlässigkeit 424 | 425 | | Ressourcenverbrauch 426 | | Grad, zu dem die Menge und Typen von Ressourcen (keine menschlichen Ressourcen), 427 | die von einem Produkt oder System bei der Ausführung seiner Funktionen 428 | genutzt werden, die Anforderungen erfüllen. Beispiele: Speicher, CPU, Threads 429 | | Performanz, Effizienz 430 | 431 | | Richtigkeit 432 | | Eignung der Funktionen für spezifizierte Aufgaben. 433 | | Korrektheit 434 | 435 | 436 | | Robustheit 437 | | 438 | | Zuverlässigkeit 439 | 440 | 441 | | *Sicherheit* 442 | | * Fähigkeit, unberechtigten Zugriff, sowohl versehentlich als auch 443 | vorsätzlich, auf Programme und Daten zu verhindern. 444 | * Grad, zu dem ein Produkt oder System Daten und Informationen schützt, 445 | so dass Personen oder andere Systeme nur den Grad an Datenzugriff erhalten, 446 | der für sie angemessen ist. 447 | | 448 | 449 | 450 | | Skalierbarkeit 451 | | Fähigkeit eines Systems, unter Nutzung zusätzlicher Ressourcen seine Kapazitäten zur Leistungserbringung zu steigern. 452 | | Effizienz 453 | 454 | 455 | | Stabilität 456 | | Wahrscheinlichkeit des Auftretens unerwarteter Wirkungen, entweder aufgrund von Benutzung oder Änderungen 457 | | Zuverlässigkeit, Robustheit 458 | 459 | 460 | | Startup-Zeit 461 | | Zeit, die das System zum Start, d.h. bis zum Herstellen der (vollständigen oder teilweisen) Betriebsbereitschaft benötigt. 462 | | Effizienz 463 | 464 | 465 | | Strapazierfähigkeit 466 | | 467 | | Zuverlässigkeit 468 | 469 | 470 | | Testbarkeit 471 | | Grad der Effektivität und Effizienz, mit der Testkriterien für ein Produkt, 472 | System oder eine Komponente festgelegt und Tests durchgeführt werden 473 | können, um festzustellen, ob diese Testkriterien erfüllt werden. 474 | (engl.: degree to which the software product enables modified software to be validated.) 475 | | Zuverlässigkeit 476 | 477 | 478 | 479 | | Überprüfbarkeit 480 | | 481 | | Zuverlässigkeit 482 | 483 | 484 | | *Übertragbarkeit* 485 | | Wie leicht lässt sich die Software in eine andere 486 | (Hardware-, Software- oder organisatorische) Umgebung übertragen? 487 | | 488 | 489 | 490 | | Überwachbarkeit 491 | | Fähigkeit, (Betriebs-)Ablauf, Störungsfreiheit, Auslastung, Ressourcennutzung oder sonstige Eigenschaften zur Laufzeit ohne funktionale Beeinträchtigung zu beobachten. 492 | | Betreibbarkeit 493 | 494 | 495 | | Unterstützbarkeit 496 | | 497 | | Betreibbarkeit 498 | 499 | | Verantwortlichkeit (engl: accountability) 500 | | Grad, zu dem Aktionen einer Entität zu genau dieser 501 | Entität zurückverfolgt werden können. 502 | | Sicherheit 503 | 504 | | Verbrauchsverhalten 505 | | Anzahl und Dauer der benötigten Betriebsmittel für die Erfüllung der Funktionen 506 | | Effizienz 507 | 508 | 509 | | Verfügbarkeit 510 | | 511 | | Zuverlässigkeit, Robustheit 512 | 513 | 514 | 515 | | Verständlichkeit 516 | | 1.) Externe ~: Aufwand für den Benutzer, das Konzept und die Anwendung zu verstehen 517 | 2.) Interne ~: Aufwand, die interne Struktur, deren Konzepte und Implementierung zu verstehen 518 | 519 | 520 | | 1.) Benutzbarkeit 521 | 2.) Wartbarkeit, 522 | 523 | 524 | 525 | | Verteilbarkeit 526 | | 527 | | Betreibbarkeit 528 | 529 | 530 | 531 | | Vertraulichkeit 532 | | Grad, zu dem ein Produkt oder System sicherstellt, 533 | dass Daten nur für diejenigen Nutzer, Produkte und Systeme zugänglich 534 | sind, die die entsprechende Autorisierung haben. 535 | | Sicherheit 536 | 537 | 538 | | Vorhersagbarkeit 539 | | 540 | | Zuverlässigkeit 541 | 542 | 543 | 544 | | *Wartbarkeit* 545 | | 546 | * Welchen Aufwand erfordert es, vorgegebene Änderungen an der Software durchzuführen? 547 | * Grad der Effektivität und Effizienz, mit der ein System geändert werden kann 548 | (umfasst Korrekturen, Verbesserungen und Anpassungen) 549 | * Mit welcher Energie und welchem Erfolg können Änderungen an einem System 550 | durchgeführt werden. 551 | | Änderbarkeit 552 | 553 | 554 | | Wiederherstellbarkeit 555 | | 556 | * Grad, zu dem ein Produkt oder System im Falle einer Störung oder eines 557 | Ausfalls Daten, die von der Störung oder dem Ausfall direkt betroffen 558 | waren, und den gewünschten Systemzustand wiederherstellen kann 559 | * Fähigkeit, bei einem Versagen das Leistungsniveau wiederherzustellen und 560 | die direkt betroffenen Daten wiederzugewinnen. 561 | | Zuverlässigkeit 562 | 563 | 564 | | Wiederverwendbarkeit 565 | | 566 | * Eigenschaft eines Systems oder Bausteins, auch ausserhalb des ursprünglich geplanten Einsatzzwecks oder -ortes verwendet zu werden. 567 | * Grad, zu dem Systemteile oder Daten (engl: assets) für mehr als ein 568 | System oder zur Entwicklung weiterer Systeme genutzt werden können. 569 | | Wartbarkeit (auch: Flexibilität) 570 | 571 | 572 | | Zeitverhalten 573 | | Grad, zu dem die Antwort- und Bearbeitungszeiten sowie die 574 | Durchsatzraten eines Produkts oder Systems bei der Ausführung 575 | seiner Funktionen die Anforderungen erfüllen. 576 | | Effizienz, Performance 577 | 578 | 579 | 580 | | Zugriffsschutz 581 | | Maßnahmen gegen unerwünschten Zugriff auf Ressourcen oder Systemteile 582 | | Sicherheit 583 | 584 | 585 | | *Zuverlässigkeit* 586 | | Fähigkeit der Software, ihr Leistungsniveau unter festgelegten Bedingungen über einen festgelegten Zeitraum zu bewahren 587 | | Robustheit 588 | 589 | 590 | |======== 591 | -------------------------------------------------------------------------------- /doc/iso-25010-de.xml.drawio: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /doc/ISO-25010-EN.graffle: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | ActiveLayerIndex 6 | 0 7 | ApplicationVersion 8 | 9 | com.omnigroup.OmniGraffle6 10 | 163.7.0.243167 11 | 12 | AutoAdjust 13 | 14 | BackgroundGraphic 15 | 16 | Bounds 17 | {{0, 0}, {950, 632}} 18 | Class 19 | SolidGraphic 20 | ID 21 | 2 22 | Style 23 | 24 | stroke 25 | 26 | Draws 27 | NO 28 | 29 | 30 | 31 | BaseZoom 32 | 0 33 | CanvasOrigin 34 | {0, 0} 35 | CanvasSize 36 | {950, 632} 37 | ColumnAlign 38 | 1 39 | ColumnSpacing 40 | 36 41 | CreationDate 42 | 2014-07-20 14:59:03 +0000 43 | Creator 44 | Dr. Gernot Starke 45 | DisplayScale 46 | 1 in = 1 in 47 | FileType 48 | flat 49 | GraphDocumentVersion 50 | 12 51 | GraphicsList 52 | 53 | 54 | Bounds 55 | {{804.10000000000002, 391.98200109863285}, {73.799999999999997, 64.01799890136715}} 56 | Class 57 | ShapedGraphic 58 | FontInfo 59 | 60 | Font 61 | Helvetica 62 | NSKern 63 | 0.0 64 | Size 65 | 12 66 | 67 | ID 68 | 1200 69 | Style 70 | 71 | shadow 72 | 73 | Draws 74 | NO 75 | 76 | stroke 77 | 78 | Draws 79 | NO 80 | 81 | 82 | Text 83 | 84 | Align 85 | 0 86 | Text 87 | {\rtf1\ansi\ansicpg1252\cocoartf1348\cocoasubrtf170 88 | {\fonttbl\f0\fswiss\fcharset0 Helvetica;} 89 | {\colortbl;\red255\green255\blue255;} 90 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720 91 | 92 | \f0\fs24 \cf0 \expnd0\expndtw0\kerning0 93 | Portability\ 94 | Adaptability\ 95 | Installability\ 96 | Compliance} 97 | VerticalPad 98 | 0.0 99 | 100 | TextPlacement 101 | 0 102 | 103 | 104 | Bounds 105 | {{700, 391.98200109863285}, {88, 119.00399780273438}} 106 | Class 107 | ShapedGraphic 108 | FontInfo 109 | 110 | Font 111 | Helvetica 112 | NSKern 113 | 0.0 114 | Size 115 | 12 116 | 117 | ID 118 | 1198 119 | Style 120 | 121 | shadow 122 | 123 | Draws 124 | NO 125 | 126 | stroke 127 | 128 | Draws 129 | NO 130 | 131 | 132 | Text 133 | 134 | Align 135 | 0 136 | Text 137 | {\rtf1\ansi\ansicpg1252\cocoartf1348\cocoasubrtf170 138 | {\fonttbl\f0\fswiss\fcharset0 Helvetica;} 139 | {\colortbl;\red255\green255\blue255;} 140 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720 141 | 142 | \f0\fs24 \cf0 \expnd0\expndtw0\kerning0 143 | Modularity\ 144 | Reusability\ 145 | Analyzability\ 146 | Changeability\ 147 | Modification stability\ 148 | Testability\ 149 | Compliance} 150 | VerticalPad 151 | 0.0 152 | 153 | TextPlacement 154 | 0 155 | 156 | 157 | Bounds 158 | {{604.09999999999991, 391.98200109863285}, {76.900000000000091, 103.00399780273439}} 159 | Class 160 | ShapedGraphic 161 | FontInfo 162 | 163 | Font 164 | Helvetica 165 | NSKern 166 | 0.0 167 | Size 168 | 12 169 | 170 | ID 171 | 1196 172 | Style 173 | 174 | shadow 175 | 176 | Draws 177 | NO 178 | 179 | stroke 180 | 181 | Draws 182 | NO 183 | 184 | 185 | Text 186 | 187 | Align 188 | 0 189 | Text 190 | {\rtf1\ansi\ansicpg1252\cocoartf1348\cocoasubrtf170 191 | {\fonttbl\f0\fswiss\fcharset0 Helvetica;} 192 | {\colortbl;\red255\green255\blue255;} 193 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720 194 | 195 | \f0\fs24 \cf0 \expnd0\expndtw0\kerning0 196 | Replace-ability\ 197 | Coexistence\ 198 | Inter-operability\ 199 | Compliance} 200 | VerticalPad 201 | 0.0 202 | 203 | TextPlacement 204 | 0 205 | 206 | 207 | Bounds 208 | {{491.5625, 391.98400000000004}, {96.875, 98}} 209 | Class 210 | ShapedGraphic 211 | FontInfo 212 | 213 | Font 214 | Helvetica 215 | NSKern 216 | 0.0 217 | Size 218 | 12 219 | 220 | ID 221 | 1194 222 | Style 223 | 224 | shadow 225 | 226 | Draws 227 | NO 228 | 229 | stroke 230 | 231 | Draws 232 | NO 233 | 234 | 235 | Text 236 | 237 | Align 238 | 0 239 | Text 240 | {\rtf1\ansi\ansicpg1252\cocoartf1348\cocoasubrtf170 241 | {\fonttbl\f0\fswiss\fcharset0 Helvetica;} 242 | {\colortbl;\red255\green255\blue255;} 243 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720 244 | 245 | \f0\fs24 \cf0 \expnd0\expndtw0\kerning0 246 | Confidentiality\ 247 | Integrity\ 248 | Non-repudiation\ 249 | Accountability\ 250 | Authenticity\ 251 | Compliance} 252 | VerticalPad 253 | 0.0 254 | 255 | TextPlacement 256 | 0 257 | 258 | 259 | Bounds 260 | {{369.3125, 391.98200109863285}, {105.375, 133.00399780273438}} 261 | Class 262 | ShapedGraphic 263 | FontInfo 264 | 265 | Font 266 | Helvetica 267 | NSKern 268 | 0.0 269 | Size 270 | 12 271 | 272 | ID 273 | 1192 274 | Style 275 | 276 | shadow 277 | 278 | Draws 279 | NO 280 | 281 | stroke 282 | 283 | Draws 284 | NO 285 | 286 | 287 | Text 288 | 289 | Align 290 | 0 291 | Text 292 | {\rtf1\ansi\ansicpg1252\cocoartf1348\cocoasubrtf170 293 | {\fonttbl\f0\fswiss\fcharset0 Helvetica;} 294 | {\colortbl;\red255\green255\blue255;} 295 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720 296 | 297 | \f0\fs24 \cf0 \expnd0\expndtw0\kerning0 298 | Appropriateness-\ 299 | recogniseability\ 300 | Learnability\ 301 | Ease-of-use\ 302 | Helpfulness\ 303 | Attractiveness\ 304 | Technical- \ 305 | accessibility\ 306 | Compliance} 307 | VerticalPad 308 | 0.0 309 | 310 | TextPlacement 311 | 0 312 | 313 | 314 | Bounds 315 | {{272.4375, 391.98200109863285}, {80, 74.503997802734375}} 316 | Class 317 | ShapedGraphic 318 | FontInfo 319 | 320 | Font 321 | Helvetica 322 | NSKern 323 | 0.0 324 | Size 325 | 12 326 | 327 | ID 328 | 1189 329 | Style 330 | 331 | shadow 332 | 333 | Draws 334 | NO 335 | 336 | stroke 337 | 338 | Draws 339 | NO 340 | 341 | 342 | Text 343 | 344 | Align 345 | 0 346 | Text 347 | {\rtf1\ansi\ansicpg1252\cocoartf1348\cocoasubrtf170 348 | {\fonttbl\f0\fswiss\fcharset0 Helvetica;} 349 | {\colortbl;\red255\green255\blue255;} 350 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720 351 | 352 | \f0\fs24 \cf0 \expnd0\expndtw0\kerning0 353 | Time-behaviour\ 354 | Resource-utilisation\ 355 | Compliance} 356 | VerticalPad 357 | 0.0 358 | 359 | TextPlacement 360 | 0 361 | 362 | 363 | Bounds 364 | {{157.5625, 391.98200109863285}, {96.875, 98}} 365 | Class 366 | ShapedGraphic 367 | FontInfo 368 | 369 | Font 370 | Helvetica 371 | NSKern 372 | 0.0 373 | Size 374 | 12 375 | 376 | ID 377 | 1186 378 | Style 379 | 380 | shadow 381 | 382 | Draws 383 | NO 384 | 385 | stroke 386 | 387 | Draws 388 | NO 389 | 390 | 391 | Text 392 | 393 | Align 394 | 0 395 | Text 396 | {\rtf1\ansi\ansicpg1252\cocoartf1348\cocoasubrtf170 397 | {\fonttbl\f0\fswiss\fcharset0 Helvetica;} 398 | {\colortbl;\red255\green255\blue255;} 399 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720 400 | 401 | \f0\fs24 \cf0 \expnd0\expndtw0\kerning0 402 | Availability\ 403 | Fault tolerance\ 404 | Recoverability\ 405 | Compliance} 406 | VerticalPad 407 | 0.0 408 | 409 | TextPlacement 410 | 0 411 | 412 | 413 | Bounds 414 | {{35.312500000000007, 391.98200109863285}, {105.375, 70.012001037597656}} 415 | Class 416 | ShapedGraphic 417 | FontInfo 418 | 419 | Font 420 | Helvetica 421 | NSKern 422 | 0.0 423 | Size 424 | 12 425 | 426 | ID 427 | 1182 428 | Style 429 | 430 | shadow 431 | 432 | Draws 433 | NO 434 | 435 | stroke 436 | 437 | Draws 438 | NO 439 | 440 | 441 | Text 442 | 443 | Align 444 | 0 445 | Text 446 | {\rtf1\ansi\ansicpg1252\cocoartf1348\cocoasubrtf170 447 | {\fonttbl\f0\fswiss\fcharset0 Helvetica;} 448 | {\colortbl;\red255\green255\blue255;} 449 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720 450 | 451 | \f0\fs24 \cf0 \expnd0\expndtw0\kerning0 452 | Appropriateness\ 453 | Accuracy\ 454 | Compliance} 455 | VerticalPad 456 | 0.0 457 | 458 | TextPlacement 459 | 0 460 | 461 | 462 | Bounds 463 | {{805, 309.98400000000004}, {72, 45}} 464 | Class 465 | ShapedGraphic 466 | FontInfo 467 | 468 | Font 469 | Helvetica 470 | NSKern 471 | 0.0 472 | Size 473 | 12 474 | 475 | ID 476 | 1180 477 | Style 478 | 479 | shadow 480 | 481 | Draws 482 | NO 483 | 484 | 485 | Text 486 | 487 | Text 488 | {\rtf1\ansi\ansicpg1252\cocoartf1348\cocoasubrtf170 489 | {\fonttbl\f0\fswiss\fcharset0 Helvetica;} 490 | {\colortbl;\red255\green255\blue255;} 491 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc 492 | 493 | \f0\fs24 \cf0 \expnd0\expndtw0\kerning0 494 | Transfer-ability} 495 | VerticalPad 496 | 0.0 497 | 498 | 499 | 500 | Bounds 501 | {{706, 309.98400000000004}, {72, 45}} 502 | Class 503 | ShapedGraphic 504 | FontInfo 505 | 506 | Font 507 | Helvetica 508 | NSKern 509 | 0.0 510 | Size 511 | 12 512 | 513 | ID 514 | 1178 515 | Style 516 | 517 | shadow 518 | 519 | Draws 520 | NO 521 | 522 | 523 | Text 524 | 525 | Text 526 | {\rtf1\ansi\ansicpg1252\cocoartf1348\cocoasubrtf170 527 | {\fonttbl\f0\fswiss\fcharset0 Helvetica;} 528 | {\colortbl;\red255\green255\blue255;} 529 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc 530 | 531 | \f0\fs24 \cf0 \expnd0\expndtw0\kerning0 532 | Maintain-ability} 533 | VerticalPad 534 | 0.0 535 | 536 | 537 | 538 | Bounds 539 | {{603, 309.98400000000004}, {80, 45}} 540 | Class 541 | ShapedGraphic 542 | FontInfo 543 | 544 | Font 545 | Helvetica 546 | NSKern 547 | 0.0 548 | Size 549 | 12 550 | 551 | ID 552 | 1176 553 | Style 554 | 555 | shadow 556 | 557 | Draws 558 | NO 559 | 560 | 561 | Text 562 | 563 | Text 564 | {\rtf1\ansi\ansicpg1252\cocoartf1348\cocoasubrtf170 565 | {\fonttbl\f0\fswiss\fcharset0 Helvetica;} 566 | {\colortbl;\red255\green255\blue255;} 567 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc 568 | 569 | \f0\fs24 \cf0 \expnd0\expndtw0\kerning0 570 | Compatibility} 571 | VerticalPad 572 | 0.0 573 | 574 | 575 | 576 | Bounds 577 | {{503.99999999999994, 309.98400000000004}, {72, 45}} 578 | Class 579 | ShapedGraphic 580 | FontInfo 581 | 582 | Font 583 | Helvetica 584 | NSKern 585 | 0.0 586 | Size 587 | 12 588 | 589 | ID 590 | 1174 591 | Style 592 | 593 | shadow 594 | 595 | Draws 596 | NO 597 | 598 | 599 | Text 600 | 601 | Text 602 | {\rtf1\ansi\ansicpg1252\cocoartf1348\cocoasubrtf170 603 | {\fonttbl\f0\fswiss\fcharset0 Helvetica;} 604 | {\colortbl;\red255\green255\blue255;} 605 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc 606 | 607 | \f0\fs24 \cf0 \expnd0\expndtw0\kerning0 608 | Security} 609 | VerticalPad 610 | 0.0 611 | 612 | 613 | 614 | Bounds 615 | {{386, 309.98400000000004}, {72, 45}} 616 | Class 617 | ShapedGraphic 618 | FontInfo 619 | 620 | Font 621 | Helvetica 622 | NSKern 623 | 0.0 624 | Size 625 | 10 626 | 627 | ID 628 | 1172 629 | Style 630 | 631 | shadow 632 | 633 | Draws 634 | NO 635 | 636 | 637 | Text 638 | 639 | Text 640 | {\rtf1\ansi\ansicpg1252\cocoartf1348\cocoasubrtf170 641 | {\fonttbl\f0\fswiss\fcharset0 Helvetica;} 642 | {\colortbl;\red255\green255\blue255;} 643 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc 644 | 645 | \f0\fs24 \cf0 \expnd0\expndtw0\kerning0 646 | Operability\ 647 | 648 | \fs20 (Useability)} 649 | VerticalPad 650 | 0.0 651 | 652 | 653 | 654 | Bounds 655 | {{272, 309.98400000000004}, {80, 45}} 656 | Class 657 | ShapedGraphic 658 | FontInfo 659 | 660 | Font 661 | Helvetica 662 | NSKern 663 | 0.0 664 | Size 665 | 12 666 | 667 | ID 668 | 1165 669 | Style 670 | 671 | shadow 672 | 673 | Draws 674 | NO 675 | 676 | 677 | Text 678 | 679 | Text 680 | {\rtf1\ansi\ansicpg1252\cocoartf1348\cocoasubrtf170 681 | {\fonttbl\f0\fswiss\fcharset0 Helvetica;} 682 | {\colortbl;\red255\green255\blue255;} 683 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc 684 | 685 | \f0\fs24 \cf0 \expnd0\expndtw0\kerning0 686 | Performance efficiency} 687 | VerticalPad 688 | 0.0 689 | 690 | 691 | 692 | Bounds 693 | {{170, 309.98400000000004}, {72, 45}} 694 | Class 695 | ShapedGraphic 696 | FontInfo 697 | 698 | Font 699 | Helvetica 700 | NSKern 701 | 0.0 702 | Size 703 | 12 704 | 705 | ID 706 | 1163 707 | Style 708 | 709 | shadow 710 | 711 | Draws 712 | NO 713 | 714 | 715 | Text 716 | 717 | Text 718 | {\rtf1\ansi\ansicpg1252\cocoartf1348\cocoasubrtf170 719 | {\fonttbl\f0\fswiss\fcharset0 Helvetica;} 720 | {\colortbl;\red255\green255\blue255;} 721 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc 722 | 723 | \f0\fs24 \cf0 \expnd0\expndtw0\kerning0 724 | Reliability} 725 | VerticalPad 726 | 0.0 727 | 728 | 729 | 730 | Bounds 731 | {{52.000000000000007, 309.98400000000004}, {72, 45}} 732 | Class 733 | ShapedGraphic 734 | FontInfo 735 | 736 | Font 737 | Helvetica 738 | NSKern 739 | 0.0 740 | Size 741 | 12 742 | 743 | ID 744 | 1166 745 | Style 746 | 747 | shadow 748 | 749 | Draws 750 | NO 751 | 752 | 753 | Text 754 | 755 | Text 756 | {\rtf1\ansi\ansicpg1252\cocoartf1348\cocoasubrtf170 757 | {\fonttbl\f0\fswiss\fcharset0 Helvetica;} 758 | {\colortbl;\red255\green255\blue255;} 759 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc 760 | 761 | \f0\fs24 \cf0 \expnd0\expndtw0\kerning0 762 | Functional Suitability} 763 | VerticalPad 764 | 0.0 765 | 766 | 767 | 768 | Bounds 769 | {{445, 227.98400000000001}, {72, 45}} 770 | Class 771 | ShapedGraphic 772 | FontInfo 773 | 774 | Font 775 | Helvetica 776 | NSKern 777 | 0.0 778 | Size 779 | 12 780 | 781 | ID 782 | 1167 783 | Style 784 | 785 | shadow 786 | 787 | Draws 788 | NO 789 | 790 | 791 | Text 792 | 793 | Text 794 | {\rtf1\ansi\ansicpg1252\cocoartf1348\cocoasubrtf170 795 | {\fonttbl\f0\fswiss\fcharset0 Helvetica;} 796 | {\colortbl;\red255\green255\blue255;} 797 | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc 798 | 799 | \f0\fs24 \cf0 \expnd0\expndtw0\kerning0 800 | Software Product Quality} 801 | VerticalPad 802 | 0.0 803 | 804 | 805 | 806 | Class 807 | LineGraphic 808 | Head 809 | 810 | ID 811 | 1166 812 | 813 | ID 814 | 1168 815 | Points 816 | 817 | {444.51054089713915, 258.09757670848478} 818 | {124.48945910286071, 324.87042329151342} 819 | 820 | Style 821 | 822 | shadow 823 | 824 | Draws 825 | NO 826 | 827 | stroke 828 | 829 | HeadArrow 830 | 0 831 | Legacy 832 | 833 | TailArrow 834 | 0 835 | 836 | 837 | Tail 838 | 839 | ID 840 | 1167 841 | 842 | 843 | 844 | Class 845 | LineGraphic 846 | Head 847 | 848 | ID 849 | 1163 850 | 851 | ID 852 | 1169 853 | Points 854 | 855 | {444.52084774838318, 261.36141994405392} 856 | {242.47915225161509, 321.60658005545992} 857 | 858 | Style 859 | 860 | shadow 861 | 862 | Draws 863 | NO 864 | 865 | stroke 866 | 867 | HeadArrow 868 | 0 869 | Legacy 870 | 871 | TailArrow 872 | 0 873 | 874 | 875 | Tail 876 | 877 | ID 878 | 1167 879 | 880 | 881 | 882 | Class 883 | LineGraphic 884 | Head 885 | 886 | ID 887 | 1165 888 | 889 | ID 890 | 1170 891 | Points 892 | 893 | {444.55015629378386, 268.16972286222438} 894 | {352.44984370379638, 312.85744819567935} 895 | 896 | Style 897 | 898 | shadow 899 | 900 | Draws 901 | NO 902 | 903 | stroke 904 | 905 | HeadArrow 906 | 0 907 | Legacy 908 | 909 | TailArrow 910 | 0 911 | 912 | 913 | Tail 914 | 915 | ID 916 | 1167 917 | 918 | 919 | 920 | Class 921 | LineGraphic 922 | Head 923 | 924 | ID 925 | 1172 926 | 927 | ID 928 | 1171 929 | Points 930 | 931 | {464.51742058343848, 273.3898480728808} 932 | {438.47709123858033, 309.57810554560166} 933 | 934 | Style 935 | 936 | shadow 937 | 938 | Draws 939 | NO 940 | 941 | stroke 942 | 943 | HeadArrow 944 | 0 945 | Legacy 946 | 947 | TailArrow 948 | 0 949 | 950 | 951 | Tail 952 | 953 | ID 954 | 1167 955 | 956 | 957 | 958 | Class 959 | LineGraphic 960 | Head 961 | 962 | ID 963 | 1174 964 | 965 | ID 966 | 1173 967 | Points 968 | 969 | {497.48104102140553, 273.38986107410005} 970 | {523.51893990227063, 309.57813908711711} 971 | 972 | Style 973 | 974 | shadow 975 | 976 | Draws 977 | NO 978 | 979 | stroke 980 | 981 | HeadArrow 982 | 0 983 | Legacy 984 | 985 | TailArrow 986 | 0 987 | 988 | 989 | Tail 990 | 991 | ID 992 | 1167 993 | 994 | 995 | 996 | Class 997 | LineGraphic 998 | Head 999 | 1000 | ID 1001 | 1176 1002 | 1003 | ID 1004 | 1175 1005 | Points 1006 | 1007 | {517.44610546034903, 268.93227425467228} 1008 | {602.55388968870886, 312.0120964968707} 1009 | 1010 | Style 1011 | 1012 | shadow 1013 | 1014 | Draws 1015 | NO 1016 | 1017 | stroke 1018 | 1019 | HeadArrow 1020 | 0 1021 | Legacy 1022 | 1023 | TailArrow 1024 | 0 1025 | 1026 | 1027 | Tail 1028 | 1029 | ID 1030 | 1167 1031 | 1032 | 1033 | 1034 | Class 1035 | LineGraphic 1036 | Head 1037 | 1038 | ID 1039 | 1178 1040 | 1041 | ID 1042 | 1177 1043 | Points 1044 | 1045 | {517.47701179214869, 261.94421060157845} 1046 | {705.52298820784551, 321.02378939994884} 1047 | 1048 | Style 1049 | 1050 | shadow 1051 | 1052 | Draws 1053 | NO 1054 | 1055 | stroke 1056 | 1057 | HeadArrow 1058 | 0 1059 | Legacy 1060 | 1061 | TailArrow 1062 | 0 1063 | 1064 | 1065 | Tail 1066 | 1067 | ID 1068 | 1167 1069 | 1070 | 1071 | 1072 | Class 1073 | LineGraphic 1074 | Head 1075 | 1076 | ID 1077 | 1180 1078 | 1079 | ID 1080 | 1179 1081 | Points 1082 | 1083 | {517.48751315441905, 258.79504705516115} 1084 | {804.51248677729313, 324.1729765317607} 1085 | 1086 | Style 1087 | 1088 | shadow 1089 | 1090 | Draws 1091 | NO 1092 | 1093 | stroke 1094 | 1095 | HeadArrow 1096 | 0 1097 | Legacy 1098 | 1099 | TailArrow 1100 | 0 1101 | 1102 | 1103 | Tail 1104 | 1105 | ID 1106 | 1167 1107 | 1108 | 1109 | 1110 | Class 1111 | LineGraphic 1112 | Head 1113 | 1114 | ID 1115 | 1182 1116 | 1117 | ID 1118 | 1181 1119 | Points 1120 | 1121 | {87.99998899098378, 355.48400000000004} 1122 | {87.99998899098378, 391.98200109863285} 1123 | 1124 | Style 1125 | 1126 | shadow 1127 | 1128 | Draws 1129 | NO 1130 | 1131 | stroke 1132 | 1133 | HeadArrow 1134 | 0 1135 | Legacy 1136 | 1137 | TailArrow 1138 | 0 1139 | 1140 | 1141 | Tail 1142 | 1143 | ID 1144 | 1166 1145 | 1146 | 1147 | 1148 | Class 1149 | LineGraphic 1150 | Head 1151 | 1152 | ID 1153 | 1186 1154 | 1155 | ID 1156 | 1185 1157 | Points 1158 | 1159 | {205.99998864924754, 355.48400000000004} 1160 | {205.99998864924754, 391.98200109863285} 1161 | 1162 | Style 1163 | 1164 | shadow 1165 | 1166 | Draws 1167 | NO 1168 | 1169 | stroke 1170 | 1171 | HeadArrow 1172 | 0 1173 | Legacy 1174 | 1175 | TailArrow 1176 | 0 1177 | 1178 | 1179 | Tail 1180 | 1181 | ID 1182 | 1163 1183 | 1184 | 1185 | 1186 | Class 1187 | LineGraphic 1188 | Head 1189 | 1190 | ID 1191 | 1189 1192 | 1193 | ID 1194 | 1190 1195 | Points 1196 | 1197 | {312.10406527436669, 355.48399488212675} 1198 | {312.26920335592808, 391.98200109863279} 1199 | 1200 | Style 1201 | 1202 | shadow 1203 | 1204 | Draws 1205 | NO 1206 | 1207 | stroke 1208 | 1209 | HeadArrow 1210 | 0 1211 | Legacy 1212 | 1213 | TailArrow 1214 | 0 1215 | 1216 | 1217 | Tail 1218 | 1219 | ID 1220 | 1165 1221 | 1222 | 1223 | 1224 | Class 1225 | LineGraphic 1226 | Head 1227 | 1228 | ID 1229 | 1192 1230 | 1231 | ID 1232 | 1191 1233 | Points 1234 | 1235 | {421.99999032516553, 355.48400000000004} 1236 | {421.99999032516553, 391.98200109863285} 1237 | 1238 | Style 1239 | 1240 | shadow 1241 | 1242 | Draws 1243 | NO 1244 | 1245 | stroke 1246 | 1247 | HeadArrow 1248 | 0 1249 | Legacy 1250 | 1251 | TailArrow 1252 | 0 1253 | 1254 | 1255 | Tail 1256 | 1257 | ID 1258 | 1172 1259 | 1260 | 1261 | 1262 | Class 1263 | LineGraphic 1264 | Head 1265 | 1266 | ID 1267 | 1194 1268 | 1269 | ID 1270 | 1193 1271 | Points 1272 | 1273 | {539.99999107492249, 355.48400000000004} 1274 | {539.99999107492249, 391.98400000000004} 1275 | 1276 | Style 1277 | 1278 | shadow 1279 | 1280 | Draws 1281 | NO 1282 | 1283 | stroke 1284 | 1285 | HeadArrow 1286 | 0 1287 | Legacy 1288 | 1289 | TailArrow 1290 | 0 1291 | 1292 | 1293 | Tail 1294 | 1295 | ID 1296 | 1174 1297 | 1298 | 1299 | 1300 | Class 1301 | LineGraphic 1302 | Head 1303 | 1304 | ID 1305 | 1196 1306 | 1307 | ID 1308 | 1195 1309 | Points 1310 | 1311 | {642.9640309260426, 355.48399938857659} 1312 | {642.90695269309867, 391.98200109863285} 1313 | 1314 | Style 1315 | 1316 | shadow 1317 | 1318 | Draws 1319 | NO 1320 | 1321 | stroke 1322 | 1323 | HeadArrow 1324 | 0 1325 | Legacy 1326 | 1327 | TailArrow 1328 | 0 1329 | 1330 | 1331 | Tail 1332 | 1333 | ID 1334 | 1176 1335 | 1336 | 1337 | 1338 | Class 1339 | LineGraphic 1340 | Head 1341 | 1342 | ID 1343 | 1198 1344 | 1345 | ID 1346 | 1197 1347 | Points 1348 | 1349 | {742.35483500444923, 355.48394050753296} 1350 | {742.91791426493648, 391.98200109863285} 1351 | 1352 | Style 1353 | 1354 | shadow 1355 | 1356 | Draws 1357 | NO 1358 | 1359 | stroke 1360 | 1361 | HeadArrow 1362 | 0 1363 | Legacy 1364 | 1365 | TailArrow 1366 | 0 1367 | 1368 | 1369 | Tail 1370 | 1371 | ID 1372 | 1178 1373 | 1374 | 1375 | 1376 | Class 1377 | LineGraphic 1378 | Head 1379 | 1380 | ID 1381 | 1200 1382 | 1383 | ID 1384 | 1199 1385 | Points 1386 | 1387 | {840.99999335720713, 355.48400000000004} 1388 | {840.99999335720713, 391.98200109863291} 1389 | 1390 | Style 1391 | 1392 | shadow 1393 | 1394 | Draws 1395 | NO 1396 | 1397 | stroke 1398 | 1399 | HeadArrow 1400 | 0 1401 | Legacy 1402 | 1403 | TailArrow 1404 | 0 1405 | 1406 | 1407 | Tail 1408 | 1409 | ID 1410 | 1180 1411 | 1412 | 1413 | 1414 | GridInfo 1415 | 1416 | GuidesLocked 1417 | NO 1418 | GuidesVisible 1419 | YES 1420 | HPages 1421 | 2 1422 | ImageCounter 1423 | 3 1424 | KeepToScale 1425 | 1426 | Layers 1427 | 1428 | 1429 | Lock 1430 | NO 1431 | Name 1432 | Ebene 1 1433 | Print 1434 | YES 1435 | View 1436 | YES 1437 | 1438 | 1439 | LayoutInfo 1440 | 1441 | Animate 1442 | NO 1443 | LineLength 1444 | 0.4643835723400116 1445 | circoMinDist 1446 | 18 1447 | circoSeparation 1448 | 0.0 1449 | layoutEngine 1450 | dot 1451 | neatoLineLength 1452 | 0.20000000298023224 1453 | neatoSeparation 1454 | 0.0 1455 | twopiSeparation 1456 | 0.0 1457 | 1458 | LinksVisible 1459 | NO 1460 | MagnetsVisible 1461 | NO 1462 | MasterSheets 1463 | 1464 | ModificationDate 1465 | 2015-09-30 06:18:45 +0000 1466 | Modifier 1467 | Dr. Gernot Starke 1468 | NotesVisible 1469 | NO 1470 | Orientation 1471 | 2 1472 | OriginVisible 1473 | NO 1474 | OutlineStyle 1475 | Basic 1476 | PageBreaks 1477 | NO 1478 | PrintInfo 1479 | 1480 | NSBottomMargin 1481 | 1482 | float 1483 | 41 1484 | 1485 | NSHorizonalPagination 1486 | 1487 | coded 1488 | BAtzdHJlYW10eXBlZIHoA4QBQISEhAhOU051bWJlcgCEhAdOU1ZhbHVlAISECE5TT2JqZWN0AIWEASqEhAFxlwCG 1489 | 1490 | NSLeftMargin 1491 | 1492 | float 1493 | 18 1494 | 1495 | NSPaperSize 1496 | 1497 | size 1498 | {595, 842} 1499 | 1500 | NSPrintReverseOrientation 1501 | 1502 | coded 1503 | BAtzdHJlYW10eXBlZIHoA4QBQISEhAhOU051bWJlcgCEhAdOU1ZhbHVlAISECE5TT2JqZWN0AIWEASqEhAFxlwCG 1504 | 1505 | NSRightMargin 1506 | 1507 | float 1508 | 18 1509 | 1510 | NSTopMargin 1511 | 1512 | float 1513 | 18 1514 | 1515 | 1516 | PrintOnePage 1517 | 1518 | ReadOnly 1519 | NO 1520 | RowAlign 1521 | 1 1522 | RowSpacing 1523 | 36 1524 | SheetTitle 1525 | Arbeitsfläche 1 1526 | SmartAlignmentGuidesActive 1527 | YES 1528 | SmartDistanceGuidesActive 1529 | YES 1530 | UniqueID 1531 | 1 1532 | UseEntirePage 1533 | 1534 | VPages 1535 | 1 1536 | WindowInfo 1537 | 1538 | CurrentSheet 1539 | 0 1540 | Expanded_Canvases 1541 | 1542 | Frame 1543 | {{36, 121}, {1377, 729}} 1544 | ShowInfo 1545 | 1546 | Sidebar 1547 | 1548 | SidebarWidth 1549 | 200 1550 | TopSlabHeight 1551 | 250 1552 | VisibleRegion 1553 | {{6, 0}, {879, 632}} 1554 | Zoom 1555 | 1 1556 | ZoomValues 1557 | 1558 | 1559 | Arbeitsfläche 1 1560 | 1 1561 | 1 1562 | 1563 | 1564 | 1565 | 1566 | 1567 | --------------------------------------------------------------------------------