👋 Bonjour, je suis Gérard Kouakou Siaka

Ingénieur Logiciel

🇨🇮 Abidjan, Côte d'Ivoire

• 🏗️ J'apprends : Clean Architecture, DDD (Domain-Driven Design), Architecture Hexagonale
• 💼 Je travaille sur : Migration progressive Layered Architecture → Clean Architecture
• 🚀 Projets 2025 : E-Commerce Platform avec DDD, Architecture Evolution Showcase
• 📝 Je partage : Bonnes pratiques architecturales et retours d'expérience
• 🤝 Ouvert à : CDI, Freelance, Collaborations Open-Source, Mentorat

Ingénieur logiciel passionné par la conception de systèmes robustes et maintenables, je me spécialise dans le développement d'applications Full-Stack et Mobile avec une forte attention portée à l'architecture logicielle.

Mon parcours professionnel m'a permis de maîtriser l'architecture en couches traditionnelle et le monolithe modulaire, deux approches que j'applique quotidiennement dans mes projets pour garantir séparation des responsabilités, testabilité et évolutivité.

Aujourd'hui, je franchis une nouvelle étape dans mon évolution professionnelle en approfondissant les architectures avancées telles que la Clean Architecture, l'Architecture Hexagonale et le Domain-Driven Design (DDD). Cette démarche reflète ma conviction profonde qu'une architecture bien pensée est le socle de tout système pérenne.

Je crois fermement que le code est un moyen, pas une fin. L'objectif ultime est de créer des systèmes qui :

• Résolvent des problèmes métier réels
• Sont faciles à comprendre, maintenir et faire évoluer
• Résistent aux changements technologiques grâce à une architecture découplée
• Permettent aux équipes de travailler efficacement avec un code propre et organisé

Architectures Maîtrisées

• Architecture en Couches : Organisation hiérarchique (Presentation → Business → Data Access → Database)
  • Maîtrise complète : Entity, Repository, Service, Controller, DTO, Mapper, Config
  • Application des principes de séparation des responsabilités
  • Gestion des transactions et des validations à chaque niveau
• Monolithique Classique : Applications unifiées avec déploiement simplifié
• Monolithe Modulaire : Découpage en modules métier tout en conservant un déploiement unique
  • Organisation par bounded contexts
  • Communications inter-modules bien définies
  • Préparation à une éventuelle migration vers microservices

Architectures en Apprentissage Actif

• Clean Architecture : Indépendance vis-à-vis des frameworks, UI, DB et services externes
  • Règle de dépendance : les couches internes ne connaissent pas les couches externes
  • Use Cases centraux qui encapsulent la logique métier
  • Inversion de dépendances via interfaces
• Architecture Hexagonale (Ports & Adapters) : Isolation complète du domaine métier
  • Ports (interfaces) définissant les contrats
  • Adapters primaires (API REST, GraphQL, UI) et secondaires (DB, services externes)
  • Testabilité maximale grâce à l'injection de dépendances
• Domain-Driven Design (DDD) : Modélisation centrée sur le domaine métier
  • Tactical Patterns : Entities, Value Objects, Aggregates, Domain Events, Repositories
  • Strategic Patterns : Bounded Contexts, Context Mapping, Ubiquitous Language
  • Event Storming et collaboration avec les experts métier

Principes & Patterns

• SOLID (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion)
• Design Patterns : Factory, Strategy, Observer, Repository, Unit of Work, CQRS
• TDD (Test-Driven Development) et BDD (Behavior-Driven Development)

Je suis actuellement dans une phase intensive d'apprentissage des architectures logicielles avancées. Cette démarche structurée me permet de progresser du niveau intermédiaire vers l'expertise en architecture.

Comprendre en profondeur

• Les motivations et contextes d'utilisation de chaque architecture
• Les trade-offs entre complexité et bénéfices
• Quand utiliser architecture en couches vs Clean Architecture vs Hexagonale
• Comment migrer progressivement d'une architecture simple vers une architecture avancée

Maîtriser les concepts

• Inversion de dépendances et Dependency Injection avancée
• Séparation stricte entre logique métier et infrastructure
• Modélisation du domaine avec DDD Tactical Patterns
• Découpage en Bounded Contexts avec DDD Strategic Patterns
• Event Sourcing et CQRS pour les systèmes complexes

Appliquer sur toute la stack

• Backend : Implémentation complète en Spring Boot et Ktor
• Frontend : Architecture en couches dans Angular avec séparation UI/Business Logic
• Mobile : Clean Architecture dans Flutter avec BLoC Pattern

Livres en cours

• "Clean Architecture" - Robert C. Martin (Uncle Bob)
• "Domain-Driven Design" - Eric Evans
• "Implementing Domain-Driven Design" - Vaughn Vernon
• "Patterns of Enterprise Application Architecture" - Martin Fowler

Apprentissage pratique

• Étude de projets open-source bien architecturés
• Refactoring de code existant vers Clean Architecture
• Prototypes et POCs sur différentes stacks
• Documentation des décisions architecturales (ADR)

Communauté & Veille

• Suivi de conférences (DDD Europe, KotlinConf, ng-conf)
• Articles techniques et blogs d'experts
• Participation à des discussions sur l'architecture logicielle

interface CurrentFocus {
  // ✅ Ce que je maîtrise et applique professionnellement
  mastered: {
    architecture: [
      "Layered Architecture (N-Tier)",
      "Modular Monolith",
      "Repository Pattern",
      "Service Layer Pattern"
    ],
    practices: [
      "SOLID Principles",
      "Design Patterns (GoF)",
      "Clean Code",
      "TDD/BDD basics"
    ],
    stack: {
      frontend: ["Angular + TypeScript"],
      backend: ["NestJS + TypeScript", "Spring Boot + Java/Kotlin", "Ktor + Kotlin"],
      mobile: ["Flutter + Dart"],
      databases: ["PostgreSQL", "MongoDB", "Redis"]
    }
  },
  
  // 🎯 Ce que j'apprends activement
  learning: {
    architectures: [
      "Clean Architecture (Ports & Adapters pattern)",
      "Hexagonal Architecture (isolation du domaine)",
      "Domain-Driven Design (Tactical & Strategic patterns)",
      "Event-Driven Architecture",
      "CQRS (Command Query Responsibility Segregation)"
    ],
    concepts: [
      "Bounded Contexts & Context Mapping",
      "Ubiquitous Language",
      "Aggregates & Domain Events",
      "Value Objects & Entities",
      "Anti-Corruption Layer"
    ]
  },
  
  // 🔨 Projets en préparation
  upcomingProjects: [
    "Migration progressive : Layered → Clean Architecture",
    "Comparaison architecturale : études de cas complètes",
    "E-commerce DDD : implémentation bounded contexts",
    "Blog technique : retours d'expérience architecturaux"
  ],
  
  // 💼 Disponibilités
  openTo: [
    "Opportunités CDI (Ingénieur Full-Stack/Architecte)",
    "Missions freelance (développement Full-Stack)",
    "Collaborations open-source sur projets bien architecturés",
    "Mentoring et pair programming"
  ]
}

Mon objectif pour 2025 est de démocratiser les bonnes pratiques architecturales en créant des ressources concrètes et accessibles pour la communauté francophone des développeurs.

Concept : Une application identique implémentée avec 4 architectures différentes

• Version 1 : Layered Architecture (architecture en couches traditionnelle)
• Version 2 : Modular Monolith (monolithe modulaire avec bounded contexts)
• Version 3 : Clean Architecture (règle de dépendance stricte)
• Version 4 : Hexagonal Architecture (ports & adapters pattern)

Objectifs pédagogiques

• Comparer concrètement les structures de code
• Mesurer la complexité, la testabilité et la maintenabilité
• Documenter les trade-offs de chaque approche
• Montrer quand utiliser quelle architecture

Stack technique

• Backend : NestJS + TypeScript + PostgreSQL
• Tests : Jest (unit), Supertest (integration), stratégie de mocking
• Documentation : ADR, diagrammes C4, README détaillés

Concept : Plateforme e-commerce complète appliquant Domain-Driven Design

Bounded Contexts identifiés

• Catalog Context : Gestion des produits, catégories, recherche
• Order Context : Panier, commande, paiement, états de commande
• Inventory Context : Gestion des stocks, réservations
• Shipping Context : Livraison, tracking, transporteurs
• Customer Context : Comptes clients, adresses, préférences

Patterns DDD appliqués

• Aggregates avec invariants métier
• Domain Events pour communication inter-contextes
• Value Objects pour concepts métier
• Repositories avec interfaces dans le domaine
• Anti-Corruption Layer entre contextes

Stack technique

• Frontend : Angular + Signal Store (state management)
• Backend : Spring Boot + Kotlin + PostgreSQL
• Mobile : Flutter + BLoC Pattern
• Communication : REST + RabbitMQ pour événements asynchrones

Concept : Application de gestion de tâches avec Clean Architecture sur Flutter

Architecture en couches

• Presentation Layer : Widgets Flutter, BLoC/Cubit pour state management
• Domain Layer : Use Cases, Entities, Repository interfaces
• Data Layer : Repository implementations, Data sources (API + Local DB)

Features avancées

• Synchronisation online/offline avec conflict resolution
• Tests exhaustifs (unit, widget, integration)
• Architecture plugin pour faciliter l'ajout de features

Stack technique

• Flutter + Dart
• BLoC Pattern pour state management
• Dio pour HTTP, Isar pour stockage local
• Mockito pour tests

Concept : Plateforme de partage de connaissances architecturales

Contenu prévu

• Articles détaillés sur les architectures étudiées
• Vidéos de live coding et refactoring
• Diagrammes et schémas explicatifs
• Templates et boilerplates pour démarrer rapidement
• Études de cas de projets réels

Objectif : Créer une ressource francophone de qualité sur l'architecture logicielle

Maîtrise confirmée de l'architecture en couches et du monolithe modulaire, avec une compréhension profonde des principes SOLID et des design patterns. Stack complète Frontend, Backend et Mobile.

En phase active d'apprentissage des architectures avancées (Clean Architecture, Hexagonale, DDD). Je ne me contente pas de suivre les tendances, je comprends les fondamentaux et les contextes d'application.

Code propre, testé et documenté. Je crois que le code est lu beaucoup plus souvent qu'il n'est écrit, donc je priorise la lisibilité et la maintenabilité.

Capacité à travailler en équipe, partager mes connaissances et apprendre des autres. Je crois au pouvoir de la revue de code et du pair programming.

Pragmatique dans mes approches : j'utilise l'architecture appropriée au contexte, sans sur-ingénierie ni sous-architecture. L'objectif est toujours de résoudre des problèmes métier réels.