Illustration par ChatGPT
« Le monde n’est pas fait de choses, mais de processus. »
— Alfred North Whitehead
Introduction : L’illusion classificatoire
Java est un excellent langage de programmation. Il est robuste, performant, et a prouvé son efficacité dans d’innombrables systèmes critiques — banques, hôpitaux, infrastructures. Ce n’est pas Java le problème. C’est ce que Java présuppose sur la nature du monde.
Car derrière chaque langage de programmation se cache une ontologie — une théorie implicite de ce qui existe et de comment les choses s’articulent entre elles. Et l’ontologie de Java, comme celle de la plupart des langages orientés objet, est profondément ancrée dans une vision du monde qui date du XVIIIesiècle : celle de la taxonomie linnéenne, des hiérarchies fixes, des essences stables.
Cette vision était « rassurante » : elle promettait un monde où chaque chose avait sa place, où les catégories étaient nettes, où l’ordre préexistait au désordre. Mais que faire quand le monde réel refuse de se conformer à ces boîtes bien rangées ?
I. L’héritage du XIXe siècle
La taxonomie comme promesse d’ordre
Au XVIIIe siècle, Carl von Linné entreprit de classifier l’ensemble du vivant. Son Systema Naturae (1735) proposait une hiérarchie stricte : règne → embranchement → classe → ordre → famille → genre → espèce. Chaque organisme avait sa place, déterminée par des caractères essentiels et immuables.
Cette approche triompha au XIXe siècle. Les naturalistes se lancèrent dans un immense projet de catalogage du monde. Les musées d’histoire naturelle se remplirent de spécimens étiquetés, rangés dans des tiroirs, chacun à sa place dans l’arbre du vivant. L’ordre était là, il suffisait de le découvrir.
Cette vision classificatoire débordait au-delà de la biologie. Elle imprégnait toute la pensée occidentale : les bibliothèques adoptèrent la classification décimale de Dewey (1876), les entreprises s’organisèrent en organigrammes pyramidaux, les sciences se compartimentèrent en disciplines étanches.
De Linné à Java : la filiation cachée
Quand les pionniers de l’informatique inventèrent les langages orientés objet dans les années 1960-1980, ils importèrent — consciemment ou non — cette vision classificatoire. Simula, puis Smalltalk, puis C++, puis Java, tous reposent sur le même schéma mental :
1. Les entités du monde sont des objets discrets, aux frontières nettes.
2. Chaque objet appartient à une classe qui définit son essence.
3. Les classes s’organisent en hiérarchies d’héritage, du général au particulier.
4. L’ordre est pensé a priori, avant même que les objets existent.
En Java, avant même qu’un chat puisse exister, il faut avoir déclaré class Chat extends Animal. La hiérarchie précède l’existence. C’est du platonisme pur : les Idées (les classes) préexistent aux choses (les objets).
II. Le cauchemar du lichen
Une entité qui défie les catégories
Le lichen est l’exemple parfait de ce que la vision classificatoire ne peut pas penser. Un lichen n’est pas un organisme — c’est une relation stabilisée entre un champignon et une algue (ou une cyanobactérie). Les deux vivent en symbiose si étroite qu’on les a longtemps pris pour un organisme unique.
Comment modéliser cela en Java ? Le problème apparaît immédiatement :
class Lichen extends Champignon { } // Faux
class Lichen extends Algue { } // Faux aussi
class Lichen extends Champignon, Algue { } // INTERDIT
Java interdit l’héritage multiple (pour de bonnes raisons techniques). On pourrait tenter la composition :
class Lichen {
private Champignon champignon;
private Algue algue;
}
Mais c’est un mensonge ontologique. Cette modélisation dit : « le lichen possède un champignon et une algue ». Or le lichen est leur relation. Il n’existe pas indépendamment de ses composants, et ses composants n’ont plus vraiment d’existence séparée non plus.
Quand la relation EST la substance
Le lichen révèle une faille fondamentale dans l’ontologie orientée objet. Java (et l’OOP en général) présuppose que :
— Les entités ont des frontières nettes
— L’identité est intrinsèque à l’objet
— Les relations sont secondaires par rapport aux substances
Le lichen dit exactement le contraire : parfois, la relation EST la substance. Le motif émergent de la coopération est plus réel que les parties qui le composent.
Et le monde est plein de « lichens conceptuels » : une entreprise n’est pas la somme de ses employés, une conversation n’est pas la juxtaposition de deux monologues, un marché n’est pas un agrégat d’acheteurs et de vendeurs. Ce sont des patterns relationnels qui ont leur propre réalité — une réalité que Java ne sait pas exprimer.
III. L’ordre qui émerge vs l’ordre qui précède
Le typage statique comme présomption d’omniscience
Le compilateur Java vérifie avant l’exécution que tout est cohérent. C’est un atout pour la fiabilité des systèmes. Mais c’est aussi une présomption métaphysique : cela suppose que les catégories du monde sont connues et fixes.
Dans un univers où l’organisation n’est que locale et temporaire, cette vérification statique devient une contrainte artificielle. Elle exige qu’on sache à l’avance ce qu’on ne peut découvrir qu’en chemin.
L’interface comme contrat rigide
Une interface Java est un contrat absolu : soit tu l’implémentes entièrement, soit pas du tout. Il n’y a pas de demi-mesure, pas de « presque conforme », pas de « ça dépend du contexte ».
Mais les motifs naturels ont des frontières poreuses. L’ornithorynque est « un peu mammifère », « un peu ovipare ». Le virus est « presque vivant ». La conscience est « plus ou moins présente » selon les espèces. Java ne tolère pas ce flou catégoriel — or c’est précisément ce flou qui caractérise le réel.
La causalité inversée
Java exige qu’on déclare class Animal avant class Chat extends Animal. Le général précède le particulier. Mais dans le monde réel, le concept « animal » est une abstraction a posteriori — ce sont les chats, les chiens, les oiseaux qui existent d’abord, et « animal » est le motif qu’on extrait ensuite.
Java inverse la causalité ontologique. Il demande de penser le monde à l’envers — du concept abstrait vers l’instance concrète — alors que c’est le concret qui engendre l’abstrait.
IV. GENESIS : vers une programmation du devenir
Un moteur d’émergence, pas une machine à classer
Le projet GENESIS, développé au sein de Pribor.ai, prend le contre-pied exact de la philosophie Java. Au lieu de partir de classes prédéfinies et de hiérarchies fixes, GENESIS observe ce que le système révèle de lui-même : comment il se structure, se déstructure, se reconfigure au fil du temps.
L’intuition fondatrice est simple : lorsqu’un système gagne soudain en cohérence, plusieurs tendances internes convergent au même moment. Le rôle de GENESIS est de détecter cette convergence, d’en mesurer la stabilité, et de suivre sa trajectoire.
Du calcul syntaxique à la transformation reproductive
Dans la philosophie des machines de Turing (et donc dans la langage de programmation Java), le calcul est une réécriture syntaxique : on manipule des symboles selon des règles fixes. Dans GENESIS, le calcul est une transformation reproductive : des instances s’accouplent, synthétisent, valident leur descendance.
La différence est capitale. Une machine de Turing simule toutes les fonctions imaginables. Une machine GENESIS s’engendre elle-même dans toutes les fonctions imaginables. C’est la différence entre un automate qui exécute ce qu’on lui enjoint d’exécuter et un organisme qui apprend comment exister dans son environnement.
Le lichen enfin pensable
Dans GENESIS, le lichen trouverait sa place naturelle : il ne serait pas une « chose » appartenant à une classe, mais un attracteur stable dans l’espace des relations possibles entre champignons et algues. Sa réalité serait celle d’un motif émergent, détectable par sa cohérence et sa reproductibilité — pas par son appartenance à une catégorie prédéfinie.
C’est exactement ce que proposait Aristote avec sa distinction entre substance première (l’individu concret) et substance seconde (la catégorie abstraite). Mais Java a oublié Aristote pour ne garder que Platon : les Idées éternelles, les essences immuables.
V. Pourquoi Java reste utile (et ses limites)
Il ne s’agit pas de jeter Java aux oubliettes. Pour les systèmes bancaires, les architectures d’entreprise, les infrastructures critiques, la rigidité de Java est une vertu. Quand on veut que les choses restent en place, que les contrats soient respectés, que les catégories soient stables, Java excelle.
Mais cette même qualité le rend inadapté pour modéliser un monde où l’ordre est émergent, local et contingent. C’est un peu comme vouloir décrire un nuage avec un plan d’architecte : l’outil est excellent, mais inapproprié pour ce cas précis.
Le XXIe siècle exige une nouvelle génération de langages — pas pour remplacer Java, mais pour penser ce que Java ne peut pas penser : les processus, les relations, les émergences, les devenirs.
Conclusion : Au-delà du rassurant
La vision classificatoire du XIXe siècle était rassurante parce qu’elle promettait un monde ordonné, stable, connaissable. Elle a porté l’essor industriel, la rationalisation administrative, l’informatique de gestion.
Mais nous savons aujourd’hui que cette vision était partiellement un artefact — une projection de nos besoins d’ordre sur un monde qui ne s’y conforme qu’à contrecœur. Le réel est plein de lichens, d’hybrides, de transitions, de flous, d’émergences imprévues.
Oublier Java — ou du moins, suspendre ses présupposés — c’est accepter que l’ordre n’est pas donné mais construit, qu’il n’est pas global mais local, qu’il n’est pas éternel mais processuel.
C’est accepter, avec Whitehead, que le monde n’est pas fait de choses, mais de processus — et qu’il nous faut des langages capables de les penser.
GENESIS est une tentative dans cette direction. D’autres viendront. L’essentiel est de ne plus confondre la carte (nos catégories rassurantes) avec le territoire (le devenir du monde).
Références
Jorion, P. (2009). Comment la vérité et la réalité furent inventées. Paris : Gallimard.
Jorion, P. (2025). « GENESIS : Une machine de Turing vitalisée ». Blog de Paul Jorion.
Whitehead, A.N. (1929). Process and Reality. New York : Macmillan.
Simondon, G. (1958). Du mode d’existence des objets techniques. Paris : Aubier.
Laisser un commentaire