Korrekte nebenläufige Anwendungen mit Koroutinen und TDD
•
0 gefällt mir•108 views
Mit Koroutinen können nebenläufige und asynchrone Anwendungen in Kotlin präzise und strukturiert geschrieben werden. Leider erhöht sich durch die Nebenläufigkeit oft auch die Komplexität und es ist schwierig, fehlerfreie und wartbare Programme zu erstellen. Als Lösung bietet sich die testgetriebene Entwicklung (TDD) an.
Empfohlen
Empfohlen
Weitere ähnliche Inhalte
Ähnlich wie Korrekte nebenläufige Anwendungen mit Koroutinen und TDD
Ähnlich wie Korrekte nebenläufige Anwendungen mit Koroutinen und TDD (20)
Mehr von Jörn Dinkla
Mehr von Jörn Dinkla (17)
Korrekte nebenläufige Anwendungen mit Koroutinen und TDD
- 1. Korrekte nebenläufige Anwendungen mit Koroutinen und TDD Jörn Dinkla 1
- 2. Jörn Dinkla ● Entwickler und Berater ● Tech-Lead ● Vorträge und Artikel jdinkla@thoughtworks.com www.dinkla.net 2 https://github.com/jdinkla/2022_kkon
- 3. Das Problem 3 https://labs.openai.com/s/TC1Z805W2DgU2wHslIKDlDN9 “Was passiert, wenn ich den Code ändere? Mir wird ganz mulmig …”
- 4. Die Lösung Koroutinen und TDD 4 https://labs.openai.com/s/HYxmSVqguyiJslXMnT4GAtVo “Sauberer und änderbarer Code der funktioniert”
- 5. Test driven development (TDD) Geniale Idee ● Spezifikation des Verhaltens ● Automatisierte Überprüfung Positive Effekte ● Schnelles Feedback ● “Embrace Change” ● Refaktorisieren ohne Stress 5
- 6. Automatisierte Tests machen glücklich 6 Wirtschaftlicher Erfolg & Entwicklerzufriedenheit https://labs.openai.com/s/bHLWUoIHoksiCflksmryBZbm
- 7. Testpyramide Tests sind unterschiedlich isoliert 7
- 8. TDD-Mantra für Unit-Tests Rot Schreibe einen Test und lasse ihn laufen (er ist rot) Grün Schreibe einfachsten Code, um ihn grün zu machen Refaktorisiere Z. B. Pattern, Clean Code, Performance, etc. 8
- 9. Beispiel für einfachen Test 9 Arrange Act Assert Starten https://kotest.io/ https://plugins.jetbrains.com/plugin/14080-kotest
- 10. Grün! 10 Der Test ist grün! “Value Object” Pattern
- 11. TDD ist also ganz einfach … ;-) Dieses Beispiel ist einfach, denn … ● Rein funktional ● Keine Seiteneffekte, keine Exceptions, kein Zustand Ist alles auf einfache Fälle reduzierbar? 11 Wichtig: Reine Funktionen sind einfach zu testen! Art #1
- 12. Und die Theorie … 12 https://labs.openai.com/s/WvacZqF8Ld7KSWRnHBg94hC8
- 13. Drei Arten des Testens 1. Ausgabe-basiert 2. Zustand-basiert 3. Kommunikations-basiert 13 “Shift up” Funktional, “Immutable”, parallelisierbar Vorsicht: Sichtbarkeit des Zustands, Thread-Safety Kollaboration mit “Mocks” Drei Arten
- 14. Ideal: Funktionale Architektur 1. Funktionaler Kern Maximiere rein funktionalen Code (“immutable”) Business-Logik, Domänen-Modell Thread-Safe, einfach zu testen 2. “Mutable Shell” Minimiere Seiteneffekte und Aktionen 14
- 16. launch: “fire and forget” Hello World mit Koroutinen 16 Hello World
- 17. Structured Concurrency mit CoroutineScope ● launch {} erstellt Job ● Hierarchische Organisation ○ Wartet auf Beendigung aller Kinder ● Hat CoroutineContext ○ werden vererbt ○ “Dispatcher” ○ Thread-Pool 17 Job Child Child … https://kotlinlang.org/docs/coroutine-context-and-dispatchers.html
- 18. Hello World mit Zeitmessung und Sync 18 Fork Join JVM
- 20. Was ist mit sleep? 20 Kein Suspension point non-blocking + blocking = blocking
- 21. Kooperatives Multitasking suspend kennzeichnet unterbrechbare und nicht-blockierende Funktionen Geben freiwillig Kontrolle an Dispatcher ab, der andere Koroutine aufrufen kann. 21 vs. präemptives Multitasking
- 22. Koroutinen sind Seiteneffekte Koroutinen geben an “wie” etwas berechnet wird, nicht “was” Gegenteil der “deklarativen Programmierung” Arrow benutzt unterbrechbare Funktionen als IO-Monade Koroutinen in die “mutable Shell”!!! 22 https://en.wikipedia.org/wiki/Declarative_programming https://arrow-kt.io/docs/effects/io/
- 23. Eine Million Koroutinen …. 23 Suspension point
- 25. Testbarkeit herstellen 25 Eigene Funktion Wie lange dauert der Test? Unit-Tests sollten schnell sein! Wie soll man Seiteneffekte testen? Wichtig: TDD erfordert modularen Code, weil man Abhängigkeiten isolieren will
- 26. Echte und virtuelle Zeit 26 Virtuelle Zeit Echtzeit kotlinx-coroutines-test
- 27. Testbar machen durch Refaktorisieren 27 Seiteneffekte zu “Effekten” machen Synchronisation zwischen Koroutinen Hello World
- 28. Channels ● Synchronisation zwischen m:n Koroutinen ● “Exactly once”, kein Publish-Subscribe möglich 28 https://play.kotlinlang.org/hands-on/Introduction%20to%20Coroutines%20and%20Channels/08_Channels
- 30. Seiteneffekte zu “Effekten” machen 30 Wichtig: Bei Seiteneffekten muss die Testbarkeit erst hergestellt werden
- 32. SWAPI - The Star Wars API { "name": "Luke Skywalker", "height": "172", "mass": "77", … "films": [ "https://swapi.dev/api/films/1/", "https://swapi.dev/api/films/2/", "https://swapi.dev/api/films/3/", "https://swapi.dev/api/films/6/" ], … } 32 https://swapi.dev/api/people/1/ Ein Aufruf für Luke und weitere Aufrufe für die Filme Paradebeispiel für Asynchronität Sequentielle Implementierung ist langsam
- 33. Domänenmodell kotlinx.serialization 33 { "name": "Luke Skywalker", "height": "172", "mass": "77", … "films": [ "https://swapi.dev/api/films/1/", "https://swapi.dev/api/films/2/", "https://swapi.dev/api/films/3/", "https://swapi.dev/api/films/6/" ], … }
- 36. Nicht den Client testen! 36 Der Unit-Test sollte nicht vom Internet abhängen!
- 37. Mocking mit mockk “to mock” - etwas vortäuschen Fokus auf “System under Test” (SUT) Vorteile: ● Isolation ● Geschwindigkeit ● Reproduzierbarkeit 37 https://mockk.io JVM
- 39. Der Mock wird zum Driver … 39 Muss aufgerufen worden sein!
- 40. Ping - Pong …. 40 Einfachste Implementierung Neuer Fehler
- 41. Ping - Pong … 41 Muss Namen aus dto verwenden Verhalten definieren
- 42. Ping - Pong …. 42 Wichtig: Mocks bringen enge Kopplung zwischen Code und Test Art #3
- 43. … und der Unit-Test 43 Der “Happy Path” Art #3
- 44. Implementierung 44 Koroutinen? Fork Join Geringer Aufwand Durch Kapselung nach Außen nicht sichtbar! Wie testen?
- 45. I. Korrektheit II. Terminierung, Deadlock-Freiheit, Thread-Safety III. Operativer Teil Wie bei sequentiellem Code Asynchronität der Koroutinen? Structured Concurrency, Channel, Flow Was sollte bei Nebenläufigkeit getestet werden? 45 Performance-Test?
- 47. Trennung von Fork und Join 47 Fork Join
- 49. Flows 49 Werte werden Schritt für Schritt ermittelt Operation auf Flow
- 50. Testen von Flows Producer und Consumer getrennt testen Turbine-Hilfsbibliothek https://github.com/cashapp/turbine 50 https://developer.android.com/kotlin/flow/test “StepVerifier”
- 53. Assertions für Exceptions Weitere: shouldThrowExactly, shouldThrowAny 53
- 54. launch erstellt Job async erstellt Deferred<T> (erbt von Job) Lebenszyklus eines Jobs 54 Cancelling Completed Cancelled New Active Completing start complete finish finish cancel fail
- 55. Cancellation als CancellationException 55 Job - Sichtbarkeit … Ermöglicht … Status-Checks Art #2
- 56. Vortrag 56
- 58. UIs haben einen Main-Thread Der Main-Thread ● stellt UI-Elemente dar (“zeichnet Bildschirm”) ● wenn blockiert, friert Bildschirm ein Daher: Netzwerk-Requests als Koroutinen! 58 https://developer.android.com/kotlin/coroutines/test
- 59. Koroutinen mit Swing App bleibt responsiv, weil der Zähler main-safe ist. 59 Start & Stop
- 60. Thread-Confinement mit Dispatchers.Swing Aus meinen Folien vom KKON Warmup 2021 60 https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-swing/ Nicht testbar!
- 61. Extraktion in Klasse und Test 61 Virtuelle Zeit https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-test/ Kein UI
- 62. Testbarkeit durch Trennung von UI und Logik 62
- 63. Android Model, View, ViewModel (MVVM) ViewModel, Lifecycle, LiveData unterstützen Koroutinen 63 https://developer.android.com/kotlin/coroutines https://developer.android.com/topic/libraries/architecture/coroutines
- 65. kotest hat Matcher für Channels 65 https://kotest.io/docs/assertions/core-matchers.html Art #2 JVM
- 66. Android Matchers von kotest 66 https://kotest.io/docs/assertions/android-matchers.html
- 68. Nichtdeterminismus und Zeitabhängigkeit ● eventually ● continually ● until ● retry 68
- 69. Aktoren: Koroutine + Channel 69
- 70. Was gibt es noch? ● Dispatchers.IO, Dispatchers.Default, Dispatchers.Unconfined ● TestDispatcher https://developer.android.com/kotlin/coroutines/test#testdispatchers ● TimeOuts als TimeoutCancellationException ● withContext ● Mutex, Semaphore, select ● SupervisorJob ● SharedFlow, StateFlow 70
- 72. Sorgenfreie nebenläufige Softwareentwicklung Koroutinen erlauben elegante Formulierung Testgetriebene Entwicklung (TDD) Sicherheit und schnelles Feedback Funktionale Architektur Erleichtert Testbarkeit und Wartbarkeit 72
- 73. Links ● Sourcecode https://github.com/jdinkla/2022_kkon ● Koroutinen https://kotlinlang.org/docs/coroutines-overview.html ● kotest https://kotest.io/ ● mockk https://mockk.io/ ● ktor https://ktor.io/ ● kotlinx-coroutines-test https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-test/ ● kotlinx-coroutines-debug https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-debug/ ● SWAPI https://swapi.dev 73
- 74. Referenzen Kent Beck. Extreme Programming explained. Kent Beck. Test-Driven Development by Example. Vladimir Khorikov. Unit Testing Principles, Practices, and Patterns. Anm. verwendet C# 74
- 76. Vielen Dank für Ihre Aufmerksamkeit Jörn Dinkla jdinkla@thoughtworks.com 76 https://labs.openai.com/s/zMxI5JNIUL9YrQRMti13srla