23 - Résumés de livres de référence

Objectifs pédagogiques

À la fin de ce chapitre, vous serez capable de :

1. Choisir le bon livre selon votre niveau et votre objectif
2. Extraire les concepts clés de chaque ouvrage
3. Mettre en pratique les recommandations de chaque auteur
4. Constituer une bibliothèque d'ingénieur mobile solide

Plan du chapitre

Fichiers du chapitre

Temps estimé

• Lecture des résumés : 2 h
• Lecture intégrale d'un livre : 20 à 30 h
• Application (projets) : 40 h+

Méthode de lecture recommandée

1. Lisez le résumé pour situer le livre et ses chapitres forts.
2. Lisez le livre avec un projet sous la main : chaque concept doit être testé.
3. Prenez des notes sous forme d'« ADR personnels » (décision + pourquoi).
4. Relisez le résumé 2 semaines après pour consolider.

---

Section 1 — « Kotlin in Action »

Auteurs : Dmitry Jemerov et Svetlana Isakova (JetBrains) Édition : 2ᵉ édition (2024), Manning Publications Niveau : Intermédiaire. Requiert des bases de programmation (Java ou autre langage OO).

Ce que couvre le livre

1. Fondations : types, null-safety, classes, fonctions, lambdas.
2. Fonctions et collections : stdlib, séquences, destructuring.
3. Interopérabilité Java/Kotlin : annotations, génériques, chaînes de caractères.
4. Coroutines : la partie la plus attendue de la 2ᵉ édition.
5. Flux : Flow et son intégration avec les coroutines.
6. DSL et builders : comment Kotlin permet de créer des DSL type Gradle KTS.
7. Kotlin Multiplatform : aperçu du partage de code.

Les 5 concepts clés à retenir

1. Null-safety par le type

String? ≠ String. Le compilateur interdit d'utiliser une valeur potentiellement null sans contrôle. C'est la différence avec Java : les bugs « billion dollar mistake » deviennent des erreurs de compilation.

2. Immuabilité par défaut

val pour la lecture seule, data class pour les objets de valeur (equals/hashCode/copy générés), copy() pour produire de nouvelles instances. Un état immuable est plus facile à raisonner et à tester.

3. Les fonctions d'extension

fun String.isValidEmail(): Boolean = ...

Une extension n'est pas une modification de classe : c'est une fonction statique « sugarcoated ». Attention : elle ne remplace pas une méthode réelle (pas de polymorphisme sur extension).

4. Coroutines : la concurrence structurée

• launch (fire-and-forget), async (résultat), suspend (fonction suspensive).
• La structure : un scope parent attend ses enfants, l'annulation se propage.
• Les Dispatchers : Main, IO, Default, Unconfined (à éviter).

5. Flow : le flux froid de données

• Froid : chaque collecteur déclenche son propre flux.
• Opérateurs : map, filter, debounce, flatMapLatest, catch, stateIn.
• Le « hot » flow : StateFlow/SharedFlow pour partager entre plusieurs UI.

Les chapitres incontournables

Points forts

• Écrit par les membres de JetBrains : autorité sur le sujet.
• Exemples concrets et comparatifs Java → Kotlin.
• 2ᵉ édition : ajouts coroutines, Flow, KMP — à jour (2024).

Points faibles / limites

• Peu d'exemples « produit » : c'est un livre de langage, pas d'architecture.
• Les parties Compose ne sont pas traitées (choix volontaire).

Mise en pratique

1. Recodez les exemples de coroutines dans un projet scratch.
2. Refactorisez un fichier Java en Kotlin idiomatique (de Java 8 à Kotlin).
3. Implémentez un Flow de recherche avec debounce + flatMapLatest.

---

Section 2 — « Android Programming: The Big Nerd Ranch Guide »

Auteur : Bill Phillips, Chris Stewart, Kristin Marsicano (édition 4, 2019) Niveau : Débutant → Intermédiaire. Aucun prérequis Android.

Ce que couvre le livre

1. Première app : activités, layouts, Gradle, emulator.
2. UI classique : XML layouts, widgets, RecyclerView, fragments.
3. Navigation : fragment manager, back stack.
4. Données : SQLite via une base maison, puis Room.
5. Threads : appels réseau, AsyncTask → coroutines (édition récentes).
6. Services, BroadcastReceivers, notifications.
7. Architecture : ViewModel, LiveData (basé sur le guide d'architecture Google).

Les 5 concepts clés à retenir

1. Le cycle de vie d'une Activity

onCreate → onStart → onResume → (rotation) onPause → onStop → onDestroy. La rotation détruit et recrée l'activité : tout état perdu doit être restauré (onSaveInstanceState).

2. Fragment = unité de réutilisation

Un fragment encapsule une partie d'écran avec son propre cycle de vie. Le FragmentManager contrôle la pile de navigation. (Note : avec Compose, cette notion évolue — Navigation Compose gère les destinations.)

3. RecyclerView pour les listes

Adapter + ViewHolder + LayoutManager. C'est le pattern central des listes Android : « recycle » les vues pour la performance.

4. Room et la couche de données

@Entity (table), @Dao (requêtes), @Database (point d'accès). Les requêtes peuvent renvoyer LiveData/Flow → l'UI se met à jour automatiquement.

5. Architecture : ViewModel + LiveData

• Le ViewModel survit à la rotation.
• LiveData (ou StateFlow) observe les changements de données.
• L'UI observe, ne contrôle pas : le flux est unidirectionnel.

Les chapitres incontournables

Points forts

• Pédagogie incrémentale : on construit une vraie app chapitre après chapitre.
• Exercices « Challenges » en fin de chapitre.
• Très accessible pour un débutant complet.

Points faibles / limites

• Édition 2019 : n'inclut pas Compose (sorti 2021). À compléter par les codelabs Compose.
• Approche historique (fragments/XML) : utile pour la maintenance d'apps existantes.

Mise en pratique

1. Refaire « CriminalIntent » (l'app du livre) en parallèle.
2. Porter une partie de l'app en Compose pour comparer.
3. Ajouter Room + coroutines aux exemples.

---

Section 3 — « Swift Programming: The Big Nerd Ranch Guide »

Auteur : Mikey Ward, Paul Hudson (éditions successives, dernière 2021) Niveau : Débutant → Intermédiaire.

Ce que couvre le livre

1. Fondations Swift : types, optionals, collections, control flow.
2. Structs et classes : value type vs reference type.
3. Enums et pattern matching : la force du langage.
4. Protocols et generics : la programmation générique.
5. Closures : fonctions de première classe.
6. Gestion des erreurs : try, catch, Error.
7. Concurrence (éditions récentes) : GCD, async/await.

Les 5 concepts clés à retenir

1. Les optionals

Int? peut être nil. Le déballage forcé (!) est un code smell ; on préfère if let, guard let et le chaînage ?..

2. Struct vs Class

• struct : valeur (copie), immuable par sémantique, parfait pour les modèles.
• class : référence (partage), utile pour les objets avec identité.
• En SwiftUI, les modèles sont souvent des structs ; les controllers des classes (ou actors).

3. Enums avec valeurs associées

enum Result<Success, Failure> {
    case success(Success)
    case failure(Failure)
}

Le switch exhaustif rend le code sûr : le compilateur vérifie que tous les cas sont traités.

4. Protocol-Oriented Programming

Les protocols + extensions permettent de définir des comportements par défaut. SwiftUI l'utilise massivement (View, ViewModifier).

5. La concurrence moderne

• async/await remplace les closures de complétion pour la lisibilité.
• async let et TaskGroup pour le parallélisme.
• Les actor pour protéger les états partagés.

Les chapitres incontournables

Points forts

• Pédagogie « Big Nerd Ranch » : exercices progressifs et challenges.
• Style idiomatique : on apprend le « Swift way ».
• Bonne intro avant d'aborder SwiftUI.

Points faibles / limites

• N'inclut pas SwiftUI en profondeur (compléter avec Hacking with Swift).
• Édition 2021 : à compléter avec Swift 6 (strict concurrency).

Mise en pratique

1. Résoudre les challenges de fin de chapitre.
2. Recoder un modèle de domaine avec enums + structs.
3. Convertir une fonction à complétion en async/await.

---

Section 4 — « Flutter: The Complete Reference »

Auteur : Alberto Miola Édition : 2021 Niveau : Débutant → Avancé.

Ce que couvre le livre

1. Fondations Dart : variables, fonctions, classes, async.
2. Les widgets : le modèle de composition Flutter.
3. Layouts : Row, Column, Stack, Flex, CustomPaint.
4. Interactions : gestes, animations.
5. Navigation et routes.
6. State management : setState, InheritedWidget, Bloc, Provider, Riverpod.
7. Persistance : SharedPreferences, Hive, SQLite.
8. Réseau : http, dio, WebSocket.
9. Intégrations plateforme : plugins, platform channels.
10. Tests et performance.

Les 5 concepts clés à retenir

1. Tout est widget

L'UI est un arbre de widgets. Chaque élément visuel (marge, padding, layout, dessin) est un widget. C'est une architecture déclarative et réactive.

2. Stateless vs Stateful

• StatelessWidget : immuable, reconstruit quand le parent change.
• StatefulWidget : possède un State mutable (setState déclenche le rebuild).

3. Les deux types de « build »

Le framework reconstruit l'arbre rapidement car les widgets sont des configurations légères ; le rendu réel est géré par les RenderObject sous-jacents. Optimiser = construire les widgets const quand possible.

4. State management

setState suffit pour un widget ; au-delà on monte en gamme : InheritedWidget, Provider, Riverpod, Bloc. Le choix dépend de la taille du projet.

5. Platform channels

Pour toucher le natif (batterie, caméra, sensors), Flutter passe par des channels : code Dart ↔ code Kotlin/Swift via messages typés.

Les chapitres incontournables

Points forts

• Très complet : « Complete Reference » mérite son nom.
• Couvre Dart (langage) + Flutter (framework).
• Exemples variés (jeux, apps, UI).

Points faibles / limites

• Édition 2021 : certaines APIs ont évolué (impeller, etc.).
• Plus dense qu'un livre pédagogique : plutôt un ouvrage de référence.

Mise en pratique

1. Reproduire la galerie de widgets officielle avec le livre.
2. Implémenter une app avec Riverpod (state management).
3. Créer un plugin minimal (platform channel) pour comprendre le pont natif.

---

Section 5 — « Clean Mobile Architecture »

Auteur : Petteri Häkkinen Édition : 2022 Niveau : Intermédiaire → Avancé. S'adresse aux ingénieurs qui veulent structurer des apps complexes.

Ce que couvre le livre

1. Les principes de l'architecture : SOLID, DRY, YAGNI.
2. Clean Architecture appliquée au mobile : domain, data, presentation.
3. Flux unidirectionnel : MVI, Redux, unidirectional data flow.
4. Modularisation : découpage par features.
5. Injection de dépendances : Dagger/Hilt, Koin, ou manuelle.
6. Gestion d'état : StateFlow, Combine, Redux.
7. Tests : testabilité par l'architecture.
8. Étude de cas : exemples Android et iOS.

Les 5 concepts clés à retenir

1. SOLID au service du mobile

• Single Responsibility : chaque classe a une raison de changer.
• Open/Closed : extension sans modification (protocol/interface).
• Liskov : les sous-types remplacent leurs parents sans casse.
• Interface Segregation : interfaces fines.
• Dependency Inversion : dépendre des abstractions, pas des concrétions.

2. Les trois couches

L'inversion des dépendances pointe toujours vers le domaine.

3. Le flux unidirectionnel

Intention → réduction d'état → rendu → (nouvelle intention). L'état est immutable et centralisé : chaque changement est traçable, chaque test est déterministe.

4. Modularisation par feature

Chaque fonctionnalité est un module indépendant (cart, checkout, profil). Les modules « core » (ui, network, design) sont partagés. Bénéfices : build parallèle, responsabilités claires, découplage.

5. La testabilité est une propriété d'architecture

Une bonne architecture rend les tests triviaux : fakes en injection, dépendances explicites, pas d'effets de bord cachés. Si tester est difficile, l'architecture est mauvaise.

Les chapitres incontournables

Points forts

• Pragmatique : des schémas de dépendances, des études de cas.
• Indépendant de la plateforme : applicable Android ET iOS.
• Traite la gestion d'état comme une décision d'architecture, pas un détail.

Points faibles / limites

• Suppose des bases solides : pas pour débutants.
• Les exemples nécessitent d'adapter les APIs à votre stack (Kotlin/Swift).

Mise en pratique

1. Refactoriser l'app du projet fil rouge (chapitre 18) vers Clean Architecture.
2. Écrire les tests qui valident le découpage (fakes par couche).
3. Documenter les règles dans un ADR.

---

Comparatif final

Roadmap de lecture

1. Débutant Android : Big Nerd Ranch Android → Kotlin in Action.
2. Débutant iOS : Big Nerd Ranch Swift → compléter SwiftUI.
3. Flutter : Flutter Complete Reference → state management.
4. Tous : Clean Mobile Architecture une fois vos 2 premières apps faites.

Pour aller plus loin

1. Choisissez votre prochain livre et fixez un rythme (1 chapitre/semaine).
2. Chaque concept lu doit produire un test ou une démo dans vos projets.
3. Partagez un résumé de chaque chapitre fort (blog ou notes).