# 🎯 Problem → Model → Algorithm → Architecture — La séquence d'or **Problem-Model-Algorithm-Architecture** = la séquence logique pour résoudre n'importe quel problème technique, du plus simple au plus complexe. > **Sauter une étape = solution bancale.** --- ## 🎯 Le principe > 💡 **L'invariant** : "Un bon modèle révèle l'algorithme. Un bon algorithme dicte l'architecture." --- ## 🧠 Les 4 étapes détaillées ### 1️⃣ **Problem** — Qu'est-ce qu'on résout exactement ? Clarifier : - **Input** : Quelles données en entrée ? - **Output** : Quel résultat attendu ? - **Contraintes** : Limites (temps, mémoire, données) ? - **Cas limites** : Que se passe-t-il si... ? **Exemple : Système de recommandation** ``` Problem: - Input: User (historique, préférences) - Output: Top 10 produits recommandés - Contraintes: < 100ms, 10M users, données temps réel - Cas limites: Nouvel user (cold start), user sans historique ``` --- ### 2️⃣ **Model** — Comment représenter le problème ? Choisir la structure de données : - Graphe ? Arbre ? Matrice ? - Relations entre entités ? - État vs flux ? **Exemple : Recommandation** ``` Model: - User = vecteur de préférences (sparse matrix) - Product = vecteur de features (embeddings) - Similarité = cosine similarity entre vecteurs ``` ```mermaid graph TD U[User Vector
100 dimensions] --> S[Similarity Score] P[Product Vector
100 dimensions] --> S S --> R[Ranking] style S fill:#f59e0b,stroke:#d97706,stroke-width:2px,color:#fff ``` --- ### 3️⃣ **Algorithm** — Comment résoudre avec ce modèle ? Définir l'algorithme : - Quelle opération sur le modèle ? - Quelle complexité (O(n), O(log n)) ? - Trade-offs (vitesse vs précision) ? **Exemple : Recommandation** ``` Algorithm: 1. Pré-calculer embeddings produits (offline) 2. À la requête user : a. Récupérer vecteur user (cache) b. Calculer similarité avec top 1000 produits populaires (ANN) c. Appliquer filtres business (stock, catégorie) d. Ranking final 3. Retourner top 10 Complexité: O(1) pour user vector + O(log n) pour ANN ``` --- ### 4️⃣ **Architecture** — Comment organiser le code ? Traduire l'algorithme en composants : - Séparation des responsabilités - Abstractions (interfaces) - Scalabilité **Exemple : Recommandation** ```ts // Model interface UserVector { userId: string; features: Float32Array; // 100 dimensions } interface ProductVector { productId: string; features: Float32Array; } // Algorithm (service) class RecommendationEngine { constructor( private vectorStore: IVectorStore, private similarityCalculator: ISimilarityCalculator ) {} async recommend(userId: string, limit = 10): Promise { // 1. Get user vector const userVector = await this.vectorStore.getUserVector(userId); // 2. Find similar products (ANN) const candidates = await this.vectorStore.findSimilar( userVector, 1000 // top candidates ); // 3. Apply business filters const filtered = this.applyFilters(candidates); // 4. Rank and return top N return this.rank(filtered).slice(0, limit); } } // Architecture (layers) // Presentation → Service → Domain → Infrastructure ``` --- ## 📊 Visualisation de la séquence --- ## 🔍 Exemple concret : Système de cache ### 1️⃣ Problem ``` Input: key (string), value (any) Output: cached value ou null Contraintes: - < 1ms latency - 1M clés max - Éviction automatique (LRU) Cas limites: - Key inexistante → null - Cache plein → éviction LRU ``` --- ### 2️⃣ Model ``` Structure: HashMap + Doubly Linked List HashMap: key → node (O(1) lookup) Linked List: ordre d'utilisation (MRU en tête, LRU en queue) Opérations: - get(key): move to head - set(key, value): insert at head, évict tail si plein ``` --- ### 3️⃣ Algorithm ``` get(key): 1. Check HashMap 2. If exists: move node to head, return value 3. Else: return null set(key, value): 1. If key exists: update value, move to head 2. Else: a. If cache full: remove tail node from list + HashMap b. Create new node c. Insert at head d. Add to HashMap ``` **Complexité** : O(1) pour get et set --- ### 4️⃣ Architecture ```ts // Model class CacheNode { constructor( public key: string, public value: T, public prev: CacheNode | null = null, public next: CacheNode | null = null ) {} } // Algorithm + Architecture class LRUCache { private map: Map>; private head: CacheNode | null = null; private tail: CacheNode | null = null; constructor(private capacity: number) { this.map = new Map(); } get(key: string): T | null { const node = this.map.get(key); if (!node) return null; // Move to head (MRU) this.moveToHead(node); return node.value; } set(key: string, value: T): void { let node = this.map.get(key); if (node) { // Update existing node.value = value; this.moveToHead(node); } else { // Insert new node = new CacheNode(key, value); this.map.set(key, node); this.addToHead(node); // Evict if full if (this.map.size > this.capacity) { const removed = this.removeTail(); if (removed) this.map.delete(removed.key); } } } private moveToHead(node: CacheNode): void { this.removeNode(node); this.addToHead(node); } private removeNode(node: CacheNode): void { if (node.prev) node.prev.next = node.next; if (node.next) node.next.prev = node.prev; if (node === this.head) this.head = node.next; if (node === this.tail) this.tail = node.prev; } private addToHead(node: CacheNode): void { node.next = this.head; node.prev = null; if (this.head) this.head.prev = node; this.head = node; if (!this.tail) this.tail = node; } private removeTail(): CacheNode | null { if (!this.tail) return null; const removed = this.tail; this.removeNode(removed); return removed; } } ``` --- u.email === email); // O(n) }`, description: "Structure inadaptée au problème" }, problem: "Avec 1M users, recherche = 1M itérations", solution: "Bon modèle = HashMap", goodExample: { code: `// Bon modèle: HashMap (email → user) const usersByEmail = new Map(); function findByEmail(email: string) { return usersByEmail.get(email); // O(1) }`, description: "1M users ou 1 user = même perf" } }, { title: "Architecture sans algorithme défini", badExample: { code: `// Dev crée l'architecture sans définir l'algo class SearchService { search(query: string) { // ... ??? Comment on fait ? } }`, description: "Architecture vide, pas d'algorithme" }, problem: "Impossible de coder sans savoir COMMENT résoudre", solution: "Définir l'algorithme AVANT l'architecture", goodExample: { code: `// Algorithme défini: // 1. Tokenize query // 2. Build inverted index // 3. TF-IDF scoring // 4. Rank results class SearchService { async search(query: string): Promise { const tokens = this.tokenizer.tokenize(query); const docs = this.index.findDocs(tokens); const scored = this.scorer.score(docs, tokens); return this.ranker.rank(scored); } }`, description: "Architecture reflète l'algorithme" } } ]} /> --- ## 🧪 Application de la séquence ### Exemple 1 : Autocomplete ``` 1. Problem: - Input: texte partiel "hel" - Output: suggestions ["hello", "help", "helicopter"] - Contraintes: < 50ms, prefix match 2. Model: - Trie (arbre de préfixes) - Chaque nœud = lettre + fréquence 3. Algorithm: - Parcourir Trie jusqu'au préfixe - DFS pour collecter mots - Trier par fréquence 4. Architecture: - TrieNode (model) - TrieBuilder (construction) - AutocompleteService (search) ``` --- ### Exemple 2 : Rate Limiting ``` 1. Problem: - Limiter à 100 requêtes/min par IP - Bloquer si dépassement 2. Model: - Sliding window (queue timestamps) - HashMap: IP → queue 3. Algorithm: - À chaque requête: 1. Supprimer timestamps > 1min 2. Compter restants 3. Si < 100: autoriser + ajouter timestamp 4. Sinon: rejeter 4. Architecture: - RateLimiter (service) - IStorage (Redis pour distribué) - Middleware Express ``` --- 1 fichier.", explanation: "O(n) avec hashing", }, { key: "Architecture", value: "FileHasher, DuplicateDetector, ReportGenerator", explanation: "Pipeline: hash → detect → report", }, ], explanation: "Bon modèle (hash) rend l'algo trivial.", }, ]} /> --- --- ## 🗺️ Carte mentale de synthèse --- ## 🚀 Résultat attendu En maîtrisant cette séquence, tu deviens capable de : - **Résoudre** n'importe quel problème technique méthodiquement - **Choisir** le bon modèle qui révèle l'algorithme naturel - **Éviter** les architectures bancales (fondations solides) - **Communiquer** ta solution clairement (séquence logique) Et surtout : Tu cesses de coder à tâtons. **Tu construis méthodiquement.** Problem → Model → Algorithm → Architecture. C'est la séquence d'or.