Qualitätstaktiken

Vorwort

1. Danksagungen
2. Verwendung von KI
3. Über diese Auflage

Über Qualitätstaktiken

Funktionale Eignung

1. Anforderungsanalyse
2. User Stories
3. Prototyping
4. Funktionale Tests
5. Benutzerabnahmetests
6. Definition of Done
7. Product Owner
8. Personas
9. Kontinuierliches Feedback
10. Direktfeedback
11. Domain Experten
12. Kunde vor Ort
13. Iterative Entwicklung
14. Feature-getriebene Entwicklung
15. Fachliche Modellierung
16. Domain-Driven Design
17. Bounded Contexts
18. Fachlich-getriebene Architektur
19. Geschäftsprozessmodellierung
20. Standardsoftware
21. Evolutionäre Anforderungsentwicklung
22. Fachliche Reviews
23. Code-Reviews
24. Architektur-Reviews
25. Fachliches Schuldenmanagement
26. Usability-Tests
27. Fachliche Testfälle
28. Domänenquiz
29. Fachliche Qualitätsszenarien
30. Behaviour-Driven Development (BDD)
31. Akzeptanztests
32. Domänenspezifische Sprachen
33. Fachliche Muster
34. Continuous Delivery
35. Fachliche Metriken
36. Prototypen
37. Tracer Bullets
38. Fachlicher Spike
39. Customizing
40. Entscheidungstabellen
41. Geschäftsprozessautomatisierung
42. Regelbasierte Systeme
43. Fachliche Ereignisverarbeitung
44. Datenqualitäts-Checks
45. Wertebereichsdefinition
46. Fachliches Berechtigungskonzept
47. Fachdatenversionierung
48. Microservices
49. Datensparsamkeit
50. Datenintegration
51. Datenanreicherung
52. Datenmodellierung
53. Ubiquitous Language
54. Impact Mapping
55. Story Mapping
56. Event Storming
57. Specification by Example
58. Anforderungs-Traceability-Matrix
59. Funktionale Lückenanalyse
60. Design by Contract
61. Regressionstests
62. Feature Flags

Benutzbarkeit

1. Benutzerzentriertes Design
2. Usability-Tests
3. Wireframing
4. Responsive Design
5. Mobile First Design
6. Konsistente Benutzeroberfläche
7. Styleguide
8. Konsistente Terminologie
9. Kognitive Belastungsminimierung
10. Intuitive Navigation
11. Icons
12. Visuelle Hierarchie
13. Progressive Disclosure
14. Einfache Sprache
15. Verständliche Fehlermeldungen
16. Echtzeiteingabevalidierung
17. Kontextbezogene Hilfe
18. Rückmeldungen
19. Gamification
20. Anpassbare Benutzeroberfläche
21. Benutzerdefinierte Ansichten
22. Adaptives Verhalten
23. Lokalisierung
24. Performanceoptimierung
25. Asynchrone Operationen
26. Single-Page-Application
27. Tastaturunterstützung
28. Suchfunktion
29. Integriertes Onboarding
30. Interaktive Tutorials
31. Videotutorials
32. Frequently Asked Questions (FAQ)
33. Feedback-Mechanismen
34. A/B-Testing
35. User Communitys
36. Persönlicher Support
37. Wissensdatenbank
38. Barrierefreiheitskonzept
39. Assistive Technologienunterstützung
40. Anpassbare Schriftgrößen
41. Hohe Farbkontraste
42. Untertitel und Transkripte
43. Mikrointeraktionen
44. Formulardesign und mehrstufige Assistenten
45. Eingabebeschränkungen und Standardwerte
46. Bestätigungsdialoge für destruktive Aktionen
47. Rückgängig und Wiederherstellen
48. Automatisches Speichern
49. Leere Zustände und Erstnutzungshinweise
50. Drag-and-Drop-Interaktion
51. Fokusverwaltung
52. Dunkler Modus
53. Design Tokens und Theming

Zuverlässigkeit

1. Fehlerbehandlung
2. Redundanz
3. Exceptions
4. Checklisten
5. Runbooks
6. Fehlerprotokollierung
7. Monitoring
8. Überwachung der Systemauslastung
9. Langweilige Technologien
10. Resilienz
11. Notfallwiederherstellung
12. Bereitschaftsdienst
13. Lastverteilung
14. Chaos Engineering
15. Elastische Ressourcennutzung
16. Proaktives Kapazitätsmanagement
17. Service Level Agreements
18. Service Level Objectives
19. Service Level Indicators
20. Datenreplikation
21. Failover-Mechanismen
22. Selbstüberwachung und -diagnose
23. Isolierung fehlerhafter Komponenten
24. Umgebungsparität
25. Wartung der Produktionsumgebung
26. Site Reliability Engineering (SRE)
27. Graceful Degradation
28. Circuit Breaker
29. Bulkhead
30. Selbsttest
31. Ping
32. Heartbeat
33. Transaktionen
34. Retry
35. Watchdog
36. Smoke Testing
37. Nonstop Forwarding
38. Timestamping
39. Statusüberwachung
40. Failover-Cluster
41. Redundante Datenspeicherung
42. Rollback-Mechanismen
43. Blue Green Deployment
44. Feature Toggles
45. Rolling Updates
46. Dark Launches
47. Canary Releases
48. Fehlertolerante Datenstrukturen
49. Fehlereingrenzung
50. Fehlerkorrekturcodes
51. Fehlerberichterstattung und -analyse
52. Prüfsummen
53. Redundante Prüfsummen
54. Kontinuierliche Datenüberprüfung
55. Plausibilitätsprüfungen
56. Wiederherstellungspunkte
57. Überwachung der Systemintegrität
58. Lasttests
59. Regelmäßige Backups
60. Incident-Management
61. Root Cause Analysis
62. Hochverfügbarkeitsarchitekturen
63. Fehler-Log-Analyse
64. Datenintegrität
65. Sichere Software
66. Regelmäßige Wartung und Updates
67. Kontinuierliche Integration und Bereitstellung
68. Immutable Infrastructure
69. Automatisierte Tests
70. Fehlerbudgets
71. Blameless Postmortems
72. Health-Check-Endpunkte
73. Timeout-Management
74. Rate Limiting
75. Load Shedding
76. Idempotenz-Design
77. Saga Pattern
78. Dead-Letter-Queue
79. Write-Ahead-Logging

Leistungseffizienz

1. Caching
2. Lastverteilung
3. Asynchrone Verarbeitung
4. Asynchrones Logging
5. Performance-Budgets
6. Ressourcennutzungsoptimierung
7. Komprimierung
8. API-Aufrufoptimierung
9. Effiziente Algorithmen
10. Datenbankoptimierung
11. NoSQL-Datenbanken
12. Graph-Datenbanken
13. Lasttests
14. Stresstest
15. Profiling
16. Ressourcen-Pooling
17. Parallelisierung
18. Verteilte Verarbeitung
19. Nebenläufigkeit
20. Pipelining
21. Streaming
22. Elastische Skalierung
23. Vertikale Skalierung
24. Horizontale Skalierung
25. Content Delivery Networks
26. Static Site Generation
27. Server Side Rendering
28. Edge Computing
29. Client Side Rendering
30. Batch-Verarbeitung
31. In-Memory-Verarbeitung
32. Lazy Loading
33. Deferred Static Generation
34. Lazy Evaluation
35. Adaptive Streaming
36. Progressive Loading
37. Pagination
38. Infinite Scrolling
39. Virtualisierte Listen
40. Approximative Verfahren
41. Vorhersage-basiertes Laden
42. Predictive Prefetching
43. Code-Splitting
44. Tree Shaking
45. Spezialisierte Hardware
46. Kontinuierliche Leistungsüberwachung
47. Performance-Messungen
48. Statische Codeanalyse
49. Dynamische Programmierung
50. Probabilistische Datenstrukturen
51. Vektorisierung
52. Leistungsmodellierung
53. Transparente Leistungsmetriken
54. Serverless Computing
55. Reactive Programming
56. Massentestdatenerzeugung
57. Speicherhierarchie
58. Verteiltes Caching
59. Datenpartitionierung
60. Datendeduplizierung
61. Datenaggregation
62. Materialized Views
63. Probenahme
64. Datenarchivierung
65. Datenstromverarbeitung
66. Optimistische UI-Updates
67. Kapazitätsplanung
68. Backpressure
69. CQRS
70. Read Replicas
71. Denormalisierung
72. Verbindungspooling
73. Serialisierungsoptimierung
74. Bild- und Asset-Optimierung
75. Cold Start Mitigation
76. Verteiltes Tracing

Sicherheit

1. Verschlüsselung
2. Authentifizierung
3. Zwei-Faktor-Authentifizierung
4. Autorisierung
5. Berechtigungskonzept
6. Role-Based Access Control
7. Least Privilege
8. Logging und Monitoring
9. Eingabevalidierung
10. Sichere Session-Verwaltung
11. Sichere Konfiguration
12. Sicherheits-Community
13. Sicherheitsrichtlinien für Benutzer
14. Sicherheitsrichtlinien für Entwicklung
15. Sicherheitsschulungen
16. Benutzersensibilisierung
17. Netzwerksegmentierung
18. Sichere Softwareentwicklung
19. Security by Design
20. Sicherheits-Frameworks
21. Sicherheitszertifizierung
22. Sicherheits-Audits
23. Risikoanalyse
24. Incident-Response-Maßnahmen
25. Backup und Recovery
26. Sichere Protokolle
27. Datensparsamkeit
28. Sicherheitstests
29. Threat Intelligence
30. Red Teaming
31. Sicherheitsarchitekturanalyse
32. Digitale Forensik
33. Honeypots
34. Sicherheitskennzahlen
35. Bedrohungsmodellierung
36. Missbrauchsfalldefinition
37. Sicherheitsanforderungsdefinition
38. Secure-by-Default
39. Vertrauensgrenzen
40. Datenflusskontrolle
41. Kryptografische Verfahren
42. Schlüsselmanagement
43. Secure Coding Guidelines
44. Statische Codeanalyse
45. Dynamische Codeanalyse
46. Sichere Programmierschnittstellen
47. Prepared Statements
48. Output Encoding
49. Canonicalization
50. Fuzz-Testing
51. Negativ-Tests
52. Sicherheits-Regressionstests
53. Sicherheitstests durch Externe
54. Penetrationstests
55. Systemhärtung
56. Patch-Management
57. Verteidigungslinien
58. Malware-Schutz
59. Sicherheitsüberwachung
60. Endpoint Detection and Response
61. Schwachstellenscans
62. Drittanbieterabhängigkeits-Check
63. Konfigurationschecks
64. Notfallübungen
65. Physische Sicherheit
66. Sicherheitskultur
67. Zero-Trust-Architektur
68. API-Sicherheit
69. Geheimnisverwaltung
70. Zertifikatsverwaltung
71. Digitale Signaturen
72. Föderierte Identität (OAuth/OIDC)
73. Privacy by Design
74. Web Application Firewall
75. Lieferkettensicherheit
76. Audit-Trail-Verwaltung

Wartbarkeit

1. Domain-Driven Design
2. Separation of Concerns
3. Modularisierung
4. Bubble Context
5. Modulith
6. Schichtenarchitektur
7. Mustersprache
8. Anti Corruption Layer
9. Architektur-Reviews
10. Walking Skeleton
11. Technischer Durchstich
12. Clean Code
13. SOLID-Prinzipien
14. Refactoring
15. Refactoring-Katas
16. Statische Codeanalyse
17. Code Reviews
18. Strategic Code Deletion
19. Abkündigungsstrategie
20. Ensemble-Programmierung
21. Pair Programming
22. Offene Entwicklungspraktiken
23. Codekonventionen
24. Codemetriken
25. Code Quality Gates
26. Automatisierte Tests
27. Integrationstests
28. Test-Driven Development (TDD)
29. Behavior-Driven Development (BDD)
30. Code Coverage Analyse
31. Dependency Injection
32. Dependency Injection Container
33. Dependency Management
34. Kontinuierliche Integration
35. Kurze Iterationszyklen
36. Architektur-Workshops
37. Architektur-Review-Board
38. Architektur-Governance
39. Architekturkonformitätsanalyse
40. Fitness Functions
41. Architektur-Roadmap
42. Versionskontrolle
43. Feature Toggles
44. Logging
45. Wissensmanagementsystem
46. Architekturdokumentation
47. Architecture Decision Records (ADR)
48. Living Documentation
49. Docs as Code
50. API-First Design
51. API-Dokumentation
52. Codekommentare
53. Fluent Interfaces
54. Mutation Testing
55. Property-Based Testing
56. Aspektorientierte Programmierung (AOP)
57. Codegenerierung
58. Continuous Delivery
59. Continuous Deployment
60. Microservices
61. Containerisierung
62. Infrastructure as Code
63. Loose Coupling
64. High Cohesion
65. Hexagonal Architecture
66. Event-Driven Architecture
67. Strangler Fig Pattern
68. Observability
69. Contract Testing
70. Trunk-Based Development
71. Evolutionary Database Design
72. Management Technischer Schulden

Kompatibilität

1. Standardisierte Schnittstellen
2. Protokollabstraktion
3. Datenformate
4. Versionierungsschema
5. Kompatibilitätstests
6. Cross-Version Testing
7. Kontinuierliche Integration
8. Abstraktion
9. Adapter
10. Fassaden
11. Anti Corruption Layer
12. Brücken
13. Vermittler
14. Containerisierung
15. Virtualisierung
16. Emulation
17. Standardisierte Protokolle
18. Plattformunabhängige Serialisierung
19. Datenformatkonvertierung
20. Versionsverwaltung für Kompatibilität
21. API-Versionierungsstrategie
22. Rückwärtskompatibilität
23. Abwärtskompatible APIs
24. Vorwärtskompatibilität
25. Isolierte Testumgebungen
26. Simulationsumgebungen
27. Kompatibilitätsdokumentation
28. Kompatibilitätsmatrix
29. Kompatibilitätstests durch Endanwender
30. Interoperabilitätstests
31. Consumer Driven Contracts
32. Abwärtskompatible Schemamigrationen
33. Rückwärtskompatible Datenformate
34. Browserkompatibilität
35. Kompatibilität als Fehler
36. Kompatibilitätsanforderungen
37. Kompatibilitätsstandards
38. Kompatibilitätssteuerung
39. Kompatibilitätsmessung
40. Kompatibilitätszertifizierung
41. Datenstrategie
42. Datenökosysteme
43. Semantic Versioning
44. API-Abkündigungsrichtlinie
45. Tolerant Reader
46. Canonical Data Model
47. Content Negotiation
48. Schema-Registry
49. API-Gateway
50. Service Mesh
51. Event-Driven Integration
52. Idempotente Operationen
53. Feature Detection
54. Abhängigkeits-Pinning

Übertragbarkeit

1. Containerisierung
2. Plattformunabhängige Programmiersprachen
3. Externalisierte Konfiguration
4. Portabilitäts-Checklisten
5. Cross-Platform-Frameworks
6. Standardisierte Datenformate
7. Microservices-Architektur
8. Cloud-native Entwicklung
9. Abstraktionsschichten
10. Virtualisierung
11. API-First-Entwicklung
12. Dependency Injection
13. Plattformübergreifende Build-Tools
14. Plattformunabhängige UI-Frameworks
15. Datenbankabstraktion
16. Object-Relational Mapping (ORM)
17. Plattformunabhängiges Konfigurationsmanagement
18. Portable Binärformate
19. Umgebungsvariablen für Konfiguration
20. Plattformunabhängigkeit
21. Plattformunabhängige Skriptsprachen
22. Virtuelle Entwicklungsumgebungen
23. Plattformunabhängige Datenspeicherung
24. Standardisierte Deployment-Skripte
25. Plattformunabhängige Buildpipelines
26. Abstrahierte Dateisystemzugriffe
27. Plattformunabhängige Logging-Frameworks
28. Virtuelle Netzwerke
29. Plattformunabhängige Testframeworks
30. Containerisierte Datenbanken
31. Plattformunabhängige Verschlüsselung
32. Plattformunabhängige Zeitzonenhandhabung
33. Plattformunabhängige Grafikbibliotheken
34. Plattformunabhängige Buildskripte
35. Plattformunabhängige Paketmanager
36. Progressive Web App
37. Multi-Cloud-Infrastructure-as-Code
38. Multi-Architektur-Container-Builds
39. WebAssembly-Portabilität
40. Feature Detection
41. Datenexport und Datenliberation
42. Automatisierte Migrationswerkzeuge
43. Saubere Deinstallation

Qualitätsillusionen

1. Skeleton Screens
2. Shimmer-Effekt
3. Fake-Fortschrittsbalken
4. Navigationslabyrinth
5. Scheinpersonalisierung
6. Phantom-Notifications
7. Simulierte Echtzeitdaten
8. Künstliche Verzögerungen
9. Pseudo-KI-Interaktionen
10. Phantom-Funktionalität
11. Künstliche Lernkurve
12. Schein-Lokalisierung
13. Schein-Multitasking
14. Falsche Datensparsamkeit
15. Compliance-Theater
16. Placebo Security
17. Vanity Metrics Dashboard
18. Wizard-of-Oz-Backend
19. Fake Social Proof
20. Confirmshaming
21. Artificial Scarcity Indicators

Schlussbemerkungen