Une seule facette du modèle objet de Ruby,
disséquée jusqu'à l'os. One facet of Ruby's object model,
dissected to the bone.

Le code naïf croit que 1 + 2 est une opération câblée. En Ruby, c'est 1.+(2) — un message + envoyé à l'objet 1. Il n'y a pas de fonction libre, pas d'opérateur primitif : seulement des objets qui s'envoient des messages, et un receveur, fût-il implicite. Naive code thinks 1 + 2 is a wired-in operation. In Ruby it's 1.+(2) — a + message sent to the object 1. There are no free functions, no primitive operators: only objects sending each other messages, and a receiver, even an implicit one.

Si tout appel est un message à un receveur, qui peut recevoir ? La réponse de Ruby n'a aucune exception : 42, nil, true, et les classes elles-mêmes. Integer est une instance de Class, et Class une instance de Class. Une règle, zéro cas particulier. If every call is a message to a receiver, who can receive? Ruby's answer has no exception: 42, nil, true, and the classes themselves. Integer is an instance of Class, and Class an instance of Class. One rule, zero special cases.

On traduit nil par null et on attend un crash de pointeur. Erreur : nil est l'unique instance de NilClass, un objet présent qui répond aux messages. Son NoMethodError n'est pas un segfault — c'est un receveur qui décline un message qu'il ne connaît pas. Remonte à la source du nil. We translate nil as null and brace for a pointer crash. Wrong: nil is the sole instance of NilClass, a present object that answers messages. Its NoMethodError isn't a segfault — it's a receiver declining a message it doesn't know. Trace back to the source of the nil.

On lit each { |n| … } comme « la boucle de Ruby ». C'est tout rater. each est une méthode ; le bloc est un morceau de code qu'on lui confie ; et c'est elle qui le rappelle, via yield, quand et autant de fois qu'elle veut. Tu fournis le quoi, la méthode garde le comment. We read each { |n| … } as 'Ruby's loop'. That misses everything. each is a method; the block is a piece of code you hand it; and it calls back, via yield, when and as often as it likes. You supply the what, the method keeps the how.

Capturer un bloc dans un objet donne un proc ou une lambda. Même classe Proc, même .call — et deux comportements opposés : la lambda exige la bonne arité et son return est local ; le proc s'arrange de tout et son return sort de la méthode englobante. Une fonction, ou un fragment ? Choisis. Capturing a block in an object gives a proc or a lambda. Same Proc class, same .call — and two opposite behaviors: the lambda demands the right arity and its return is local; the proc shrugs everything off and its return exits the enclosing method. A function, or a fragment? Choose.

Un bloc n'emporte pas que du code : il emporte les variables qui l'entouraient à sa naissance — la variable vivante, pas une copie figée. C'est ce qui fait les compteurs et les caches, et ce qui piège quand plusieurs closures partagent la même variable de boucle. A block carries more than code: it carries the variables that surrounded it at birth — the live variable, not a frozen copy. That's what makes counters and caches, and what traps you when several closures share one loop variable.

Avant les trois numéros, le pourquoi. Ruby refuse de demander le type et fait confiance au message — une seule discipline en trois temps : la confiance (réponds-tu ?), ses présupposés (les protocoles tacites), son prix (l'erreur tardive, regagnée à la frontière). Confiance par défaut, vérification à un seul endroit. Before the three issues, the why. Ruby refuses to ask the type and trusts the message — one discipline in three beats: trust (do you answer?), its assumptions (the tacit protocols), its price (the late error, regained at the boundary). Trust by default, checking in one place.

Une méthode qui appelle x.quack fonctionne sur n'importe quel objet répondant à quack — sans interface à implémenter, sans superclasse commune. Le seul contrat, c'est le message. On ne demande pas quel type tu es : on demande si tu réponds. A method calling x.quack works on any object that responds to quack — no interface to implement, no shared superclass. The only contract is the message. We don't ask what type you are: we ask whether you respond.

Le duck typing dit « réponds au message » — mais lesquels ? Ruby en attend certains sans jamais les déclarer : to_s, <=>, each, hash. Fournis le bon hook et inclus le mixin, et tu obtiens des familles entières de méthodes. Une « interface » que personne n'a écrite, et un marché : un hook contre une famille. Duck typing says 'answer the message' — but which? Ruby expects some without ever declaring them: to_s, <=>, each, hash. Provide the right hook, include the mixin, and you get whole method families. An 'interface' nobody wrote, and a bargain: one hook for a family.

Le duck typing déplace l'erreur à l'exécution, loin de sa cause : le NoMethodError au pire endroit. La parade n'est pas de tout vérifier, mais de regagner une garantie à la frontière — au runtime sur la donnée (dry-struct), ou à l'analyse sur le code (Steep, RBS). Une frontière, deux façons de la tenir. Duck typing pushes the error to runtime, far from its cause: the NoMethodError at the worst place. The remedy isn't to check everything, but to regain a guarantee at the boundary — at runtime on the data (dry-struct), or at analysis on the code (Steep, RBS). One boundary, two ways to hold it.

Avant les trois numéros, le pourquoi. En Ruby, a = b ne copie rien : l'objet est partagé. Les trois numéros répondent à une question — qui partage quoi — avec une même limite : chaque geste s'arrête au premier niveau. Nommer le danger, geler pour neutraliser, copier pour isoler — et freeze comme dup ne couvrent qu'une couche. Before the three issues, the why. In Ruby, a = b copies nothing: the object is shared. The three issues answer one question — who shares what — with one same limit: each move stops at the first level. Name the danger, freeze to neutralize, copy to isolate — and freeze like dup cover one layer only.

En Ruby, a = b ne copie pas l'objet : les deux noms désignent le même. Muter par l'un (<<, gsub!) se voit par l'autre — d'où le tableau « local » qu'un appelant retrouve modifié à distance. Le réflexe : avant de muter, qui d'autre tient ce même objet ? In Ruby, a = b doesn't copy the object: both names point at the same one. Mutating through one (<<, gsub!) shows through the other — hence the 'local' array a caller finds modified at a distance. The reflex: before mutating, who else holds this same object?

Si l'objet partagé est le danger du № 1, freeze en est la parade : un objet gelé refuse toute mutation par un FrozenError franc, donc se partage sans risque. Deux réserves — le gel est définitif, et superficiel : il ne gèle qu'un seul niveau. If the shared object is № 1's danger, freeze is its remedy: a frozen object refuses every mutation with a plain FrozenError, so it shares without risk. Two caveats — freezing is permanent, and shallow: it freezes one level only.

Copier un objet ne copie pas son contenu imbriqué : dup et clone ne dupliquent qu'un niveau, les sous-objets restent partagés. Le réflexe : ma copie est-elle assez profonde pour ce que je vais en faire ? Et le piège du Marshal « pour être sûr ». Copying an object doesn't copy its nested contents: dup and clone duplicate one level only, the sub-objects stay shared. The reflex: is my copy deep enough for what I'm about to do? And the Marshal 'just to be sure' trap.

Un module fait deux métiers : ranger (espace de noms accédé par ::) et partager (mixin injecté par include). Le verbe trahit l'intention. Le piège : mixer tout un module là où l'on voulait juste nommer une constante. A module does two jobs: organizing (a namespace reached via ::) and sharing (a mixin injected via include). The verb betrays the intention. The trap: mixing a whole module where you only wanted to name a constant.

Résoudre un message, c'est parcourir ancestors jusqu'au premier ancêtre qui répond. include insère le module sous la classe, prepend au-dessus (pour envelopper), super appelle le maillon suivant. Le diamant n'existe pas : la chaîne est une liste linéarisée et lisible. Resolving a message is walking ancestors to the first ancestor that answers. include inserts the module below the class, prepend above (to wrap), super calls the next link. The diamond doesn't exist: the chain is a linearized, readable list.

extend mixe au niveau d'un objet : dans une classe, des méthodes de classe ; sur une instance, un décorateur. Et quand on ne veut ni être ni mixer, la composition délègue (has-a, Forwardable). Le piège : sous-classer un conteneur pour trois méthodes et en hériter cent. extend mixes at the object level: in a class, class methods; on an instance, a decorator. And when you want neither to be nor to mix, composition delegates (has-a, Forwardable). The trap: subclassing a container for three methods and inheriting a hundred.

Avant les quatre numéros, le pourquoi. La métaprog est code qui écrit du code (Vol 1) — et chaque outil gagne en portée (un objet, une classe, tout le programme) ce qu'il perd en traçabilité. Vise toujours le cran le plus faible qui suffit ; et d'abord, demande si une méthode explicite ne réglait pas la question. Before the four issues, the why. Metaprogramming is code that writes code (Vol 1) — and each tool gains in reach (one object, one class, the whole program) what it loses in traceability. Always aim for the weakest rung that suffices; and first, ask whether an explicit method didn't settle it.

Au bout de la chaîne d'ancêtres, quand rien n'a répondu, Ruby appelle method_missing. Le redéfinir intercepte les messages inconnus — mais jamais sans son jumeau respond_to_missing?, sinon l'objet ment au duck typing. Et seulement pour un ensemble ouvert : le connu se génère. At the end of the ancestor chain, when nothing answered, Ruby calls method_missing. Redefining it intercepts unknown messages — but never without its twin respond_to_missing?, or the object lies to duck typing. And only for an open set: the known is generated.

define_method crée de vraies méthodes à partir d'un nom calculé : listées, vues par respond_to?, trouvées par grep — l'inverse de l'interception. attr_accessor n'est que cette boucle. Le réflexe : générer si les noms sont des données ou nombreux ; sinon, def gagne. define_method creates real methods from a computed name: listed, seen by respond_to?, found by grep — the opposite of interception. attr_accessor is just that loop. The reflex: generate if names are data or many; otherwise, def wins.

Une classe Ruby n'est jamais fermée : on rouvre n'importe laquelle, même String. Mais il n'en existe qu'une — la rouvrir agit à distance, sur tout le programme. Le réflexe : ce patch doit-il être visible partout (monkey-patch), ou seulement dans mon fichier (refinement) ? Souvent, pas de patch du tout. A Ruby class is never closed: you reopen any of them, even String. But there's only one — reopening it acts at a distance, on the whole program. The reflex: must this patch be visible everywhere (monkey-patch), or only in my file (refinement)? Often, no patch at all.

Définir une méthode ne donne aucune valeur à transporter : il faut la demander, obj.method(:m), pour obtenir un objet Method appelable comme une lambda. Mais ce handle est un instantané — il fige l'implémentation au moment de la capture. Envoyer le message, lui, ré-résout à chaque appel. Toute la différence entre une méthode et un message tient là. Defining a method gives you no value to carry: you have to ask for it, obj.method(:m), to get a Method object callable like a lambda. But that handle is a snapshot — it freezes the implementation at capture time. Sending the message instead re-resolves on every call. The whole difference between a method and a message lives there.

Une exception est un objet levé par raise, qui déroule la pile jusqu'à un rescue du bon type. rescue trie par classe (un rescue nu en attrape trop) ; ensure garantit le nettoyage sans rien avaler. Trois mots, trois rôles : signaler, rattraper, nettoyer — qu'on ne mélange jamais. An exception is an object raised by raise, unwinding the stack to a rescue of the right type. rescue sorts by class (a bare rescue catches too much); ensure guarantees cleanup without swallowing. Three words, three roles: signal, catch, clean up — never to be mixed.

Les exceptions forment un arbre où une frontière commande tout : StandardError (le rattrapable, et tes erreurs) sous Exception (qui contient aussi les signaux). Hérite de StandardError, rattrape StandardError, jamais Exception — sinon on avale le Ctrl-C. Et bannis le rescue fourre-tout qui rend nil. Exceptions form a tree where one boundary commands everything: StandardError (the rescuable, and your errors) under Exception (which also holds the signals). Inherit from StandardError, rescue StandardError, never Exception — or you swallow Ctrl-C. And ban the catch-all rescue that returns nil.

Une exception déroule la pile, construit une stack trace et détourne le flux — justifié pour l'imprévu, gaspillé pour l'attendu. Pour une absence ou un échec prévu : rends une valeur (nil, Result, fetch avec défaut). Le signal infaillible : si tu rattrapes l'exception là où tu la lèves, c'est un if déguisé. An exception unwinds the stack, builds a trace and diverts the flow — justified for the unforeseen, wasted on the expected. For an absence or an expected failure: return a value (nil, Result, fetch with a default). The infallible signal: if you rescue the exception where you raise it, it's a disguised if.

Avant les trois numéros, le pourquoi. map, select, reduce ne sont pas des fonctions de liste mais des messages d'Enumerable, débloqués par un seul each (Vol 2). Le volume se bâtit : fonder (each débloque 50 méthodes) → composer (chaîner les transformations) → raffiner (différer avec lazy). Chacun repose sur celui d'en dessous. Before the three issues, the why. map, select, reduce aren't list functions but Enumerable messages, unlocked by a single each (Vol 2). The volume builds upward: found (each unlocks 50 methods) → compose (chain transformations) → refine (defer with lazy). Each rests on the one below.

Implémente un seul each qui yielde tes éléments, include Enumerable, et tu hérites map, select, reduce, sort, group_by — une cinquantaine de méthodes, sur n'importe quelle structure. Le mixin appelle ton each, il n'a aucune autre source. Le piège : réécrire ces méthodes une par une. Implement a single each that yields your elements, include Enumerable, and you inherit map, select, reduce, sort, group_by — some fifty methods, on any structure. The mixin calls your each, it has no other source. The trap: rewriting these methods one by one.

Une boucle qui accumule cache son intention dans la mécanique ; une chaîne la nomme étape par étape. map transforme, select filtre, reduce replie, each_with_object bâtit. Le piège du style : chaîner pour chaîner — si tu jettes un map, tu voulais each ; si un mot suffit (find, tally), écris-le. A loop that accumulates hides its intent in machinery; a chain names it step by step. map transforms, select filters, reduce folds, each_with_object builds. The style's trap: chaining for its own sake — discard a map and you wanted each; if one word fits (find, tally), write it.

Une chaîne stricte matérialise un Array à chaque maillon ; lazy diffère et fait descendre les éléments un à un, ne produisant que ce qu'on demande — d'où l'infini calculable. Sous lazy, l'Enumerator (next, peek, Enumerator.new). Le piège : lazy sur dix éléments, où l'overhead dépasse le gain. A strict chain materializes an Array at every link; lazy defers and sends elements down one by one, producing only what's asked — hence computable infinity. Beneath lazy, the Enumerator (next, peek, Enumerator.new). The trap: lazy on ten elements, where overhead beats the gain.

Chaque message se résout en remontant la chaîne d'ancêtres (Vol 5), mais Ruby met le résultat en cache : la profondeur ne se paie qu'au premier appel. Le coût ne reparaît qu'hors du cache — method_missing, ou la modification de classes en boucle. La règle : mesure avant de croire, jamais l'inverse. Every message resolves by walking the ancestor chain (Vol 5), but Ruby caches the result: depth is paid only on the first call. The cost reappears only outside the cache — method_missing, or modifying classes in a loop. The rule: measure before believing, never the reverse.

Chaque littéral "…"/[]/{} alloue un objet, et le GC paie pour le libérer. Le coût n'est pas dans le littéral isolé mais dans sa fréquence : un objet par tour de boucle chaude pèse, le même sur un chemin froid non. On ne le lit pas — on le compte (GC.stat, ObjectSpace, memory_profiler). Le piège : geler à l'aveugle. Every literal "…"/[]/{} allocates an object, and the GC pays to free it. The cost isn't in the lone literal but in its frequency: one object per hot-loop turn weighs, the same on a cold path doesn't. You don't read it — you count it (GC.stat, ObjectSpace, memory_profiler). The trap: freezing blindly.

En MRI, le GVL n'autorise qu'un thread Ruby à la fois : les threads ne parallélisent pas le calcul, mais chevauchent l'attente (le GVL se libère pendant l'I/O). La question avant tout : mon goulot est-il de l'attente (threads, async) ou du calcul (Ractors, processus) ? Le piège : des threads sur du CPU, sans avoir mesuré. In MRI, the GVL allows only one Ruby thread at a time: threads don't parallelize computation, but overlap waiting (the GVL releases during I/O). The question before all: is my bottleneck waiting (threads, async) or computing (Ractors, processes)? The trap: threads on CPU, without having measured.