Le Dr. Park Mun-ho souligne toujours l'importance de la modularisation.

Le cerveau apprend de cette manière.

• Diviser en petites unités (cellules, fonctions)

• Regrouper ces unités pour former des modules

• Ces modules se rassemblent pour former un système

La programmation fonctionne de la même manière.

• Méthode : une action

• Classe : un objet (existence)

• Module : regroupe plusieurs classes/méthodes en un concept plus large

En Ruby, un Module peut être utilisé de la manière suivante :

1. Regrouper des espaces de noms (Namespace)

2. Partager des fonctionnalités communes (Mixin)

3. Créer un concept supérieur définissant un domaine (monde thématique)

Dès que vous comprenez cela,

le code ne semble plus être simplement une "collection de fichiers",

mais commence à ressembler à une "carte structurée de l'univers dans le cerveau".

1. Espace de noms (Namespace) : Cadre divisant les perspectives

Par exemple,

disons que vous voulez utiliser la classe User à plusieurs endroits.

• Utilisateur sur la page d'administration

• Utilisateur sur le site de commerce électronique

• Utilisateur pour une API

Si vous créez simplement une classe User ?

Il y aura des conflits de noms. Cela devient confus.

C'est là qu'un module sépare les perspectives.

module Admin
  class User
    def info
      puts "C'est un utilisateur de la page d'administration."
    end
  end
end

module Shop
  class User
    def info
      puts "C'est un utilisateur client du magasin en ligne."
    end
  end
end

utilisateur_admin = Admin::User.new
utilisateur_boutique = Shop::User.new

utilisateur_admin.info  # => C'est un utilisateur de la page d'administration.
utilisateur_boutique.info   # => C'est un utilisateur client du magasin en ligne.

Dans ce cas, le module est littéralement :

"C'est un utilisateur du monde Admin"

"C'est un utilisateur du monde Shop"

et devient un cadre divisant les perspectives.

Vue cérébrale à la Park Mun-ho

• Cadre : Même nom, mais rôle différent selon le cadre supérieur

• Tridimensionnalité : Le concept d'utilisateur n'est pas plat, mais stocké dans une structure avec des coordonnées comme "Admin-User", "Shop-User"

• Modularisation : Une sensation que des "tiroirs par domaine" se forment dans le cerveau

Maintenant, votre cerveau considère

que même si les noms sont les mêmes, s'ils appartiennent à des mondes différents, ce sont des entités complètement différentes,

et acquiert une compréhension plus avancée.

2. Mixin : Module insérant des capacités communes dans plusieurs classes

Le deuxième usage est vraiment puissant.

Un module peut devenir un bloc de capacités réutilisables en regroupant des fonctionnalités communes.

Par exemple,

supposons que plusieurs types d'objets doivent tous "enregistrer des journaux".

• Journal d'activité de l'utilisateur

• Journal de modification d'état de la commande

• Journal d'échec de paiement

Si vous copiez-collez cela dans chaque classe ?

• Duplication de code

• Enfer de la maintenance

• Pour corriger un bug, vous devez modifier trois endroits

C'est là que brille le module + include.

module Enregistrable
  def journal(message)
    temps = Time.now
    puts "[#{temps}] #{message}"
  end
end

class Utilisateur
  include Enregistrable

  def connexion
    journal("L'utilisateur s'est connecté.")
  end
end

class Commande
  include Enregistrable

  def soumettre
    journal("La commande a été reçue.")
  end
end

utilisateur = Utilisateur.new
utilisateur.connexion
# [2025-12-09 23:12:34] L'utilisateur s'est connecté.

commande = Commande.new
commande.soumettre
# [2025-12-09 23:12:35] La commande a été reçue.

Ce qui s'est passé ici

• Le module Enregistrable a modularisé la capacité de "journalisation"

• En faisant include Enregistrable,
  
  cette classe peut utiliser la méthode journal comme si c'était la sienne

• En d'autres termes, c'est comme insérer un paquet de compétences dans plusieurs classes

Vue cérébrale

• Lorsque vous partagez une fonctionnalité dans plusieurs endroits,
  
  le cerveau la regroupe en un "concept supérieur"

• Le module joue exactement ce rôle de concept supérieur

• Non seulement le code, mais la structure de la pensée elle-même est abstraite

"Ah, le journal n'est pas une partie de User ou Order,

c'est une capacité supérieure partagée par plusieurs entités."

Dès que vous réalisez cela,

la programmation ne consiste plus simplement à "écrire du code",

mais commence à se sentir comme la conception d'une structure pour l'univers.

3. Abstraction : Les modules créent un "langage de domaine" au niveau

En utilisant bien les modules en Ruby,

le code devient progressivement un "langage de domaine".

Par exemple, imaginons un domaine appelé "système de paiement".

module Paiement
  module Passerelle
    def facturer(montant)
      puts "Demande de paiement de #{montant} Wons."
    end
  end

  module Remboursable
    def rembourser(montant)
      puts "Remboursement de #{montant} Wons."
    end
  end
end

class Commande
  include Paiement::Passerelle
  include Paiement::Remboursable
end

commande = Commande.new
commande.facturer(50000)
commande.rembourser(20000)

Ici, les modules ne sont pas seulement des fonctionnalités simples.

Ils représentent des concepts du domaine exprimés en code.

• Paiement::Passerelle → un module représentant la fonction "demande de paiement"

• Paiement::Remboursable → un module représentant la fonction "remboursement"

• Commande combine ces deux aspects

En répétant cela,

le code Ruby commence à ressembler à cela.

"Les concepts commerciaux que j'imagine se transforment directement en code ?"

À ce stade, le développeur

n'est plus seulement un exécutant de code,

mais une personne qui conçoit le domaine, un concepteur/théoricien.

4. Module vs Classe : Quelle est la différence ?

Résumons.

En Ruby, un Module ne crée pas d'instances par lui-même.

MyModule.new ne fonctionne pas.

Au lieu de cela :

• Il devient un bloc de capacités insérées dans d'autres classes ou

• Il devient un cadre fournissant un espace de noms

En d'autres termes,

une classe est une "existence"

tandis qu'un module est un "concept/capacité/vision partagée par des existences".

5. Ce qui est vraiment important, c'est "comment le cerveau évolue"

En comprenant les modules,

le cerveau évolue ainsi.

1. Voir le code en termes de concepts, pas de fichiers.

- "Où cette fonctionnalité appartient-elle ?"  
    → "Elle est utilisée par User, Order et Payment, donc je vais en faire un module."

1. Créer un langage de domaine.

- "Payment::Passerelle", "Notification::Sender", "Auth::Tokenizable"  
    → Votre propre vocabulaire spécifique à vos services apparaît

1. Réduction significative de la complexité.

- Les endroits à modifier deviennent clairs :  
    "Je vais changer la logique de journalisation" → modifier uniquement le module `Enregistrable`

1. La structure mentale se range comme un module.

- Cela est directement lié à la "structuration tridimensionnelle de la connaissance" dont parlait vraiment Park Mun-ho.

6. Mission pratique : Créer votre propre module

Maintenant,

l'objectif est d'intégrer un module dans votre cerveau.

Tâche 1 : Créer le module Timestamped

Exigences :

• Créez un module appelé Timestamped

• Fournissez une méthode stamp

  • Lorsqu'elle est appelée : affiche le message au format [heure actuelle] message

• Incluez-le dans les classes Post et Comment pour une utilisation commune

Flux attendu :

module Timestamped
  # Créer ici la méthode stamp
end

class Post
  include Timestamped

  def publier
    stamp("Le message a été publié.")
  end
end

class Commentaire
  include Timestamped

  def écrire
    stamp("Le commentaire a été écrit.")
  end
end

post = Post.new
post.publier

commentaire = Commentaire.new
commentaire.écrire

Tâche 2 : Regrouper vos propres modules de domaine

Choisissez un sujet :

• Étude (Study)

• Exercice physique (Fitness)

• Blogging (Blog)

• Shopping (Shop)

• Répétition en groupe (Band)

Par exemple, le domaine Étude

• Study::Trackable – un module pour enregistrer le temps d'étude

• Study::Report – un module pour générer des statistiques hebdomadaires/mensuelles

Ensuite, créez des classes telles que DayStudy, TaskStudy

et incluez Study::Trackable pour les utiliser.

En faisant cela,

vous êtes déjà en train de devenir une personne qui conçoit son propre monde en Ruby.

Conclusion : Une fois que vous comprenez les modules, le code devient un "langage de conception de monde"

Le flux jusqu'à présent :

• Méthode : l'unité minimale d'action

• Classe : le cadre de l'existence (objet)

• Module : un concept/capacité/vision partagé par plusieurs existences

Maintenant, lorsque vous écrivez du code,

vous pouvez penser de cette façon.

"S'agit-il d'une propriété unique d'un objet ?"

→ Le placer dans une classe

"S'agit-il d'une fonctionnalité partagée par plusieurs objets ?"

→ L'extraire en tant que module

"S'agit-il d'un concept commercial de ce service ?"

→ Le définir avec un module + un espace de noms

À ce moment-là,

la programmation n'est plus simplement "apprendre la syntaxe d'un langage",

"La conception de la structure de mon monde intérieur

sous forme de code."

Et une fois que ce sentiment arrive,

cela vous fait vraiment battre le cœur.