<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Maniar Othmane on Medium]]></title>
        <description><![CDATA[Stories by Maniar Othmane on Medium]]></description>
        <link>https://medium.com/@maniar.othmane?source=rss-2c28d16fbd1c------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*Mo50aKvbL6GaHwwt.jpg</url>
            <title>Stories by Maniar Othmane on Medium</title>
            <link>https://medium.com/@maniar.othmane?source=rss-2c28d16fbd1c------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 07:15:50 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@maniar.othmane/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[L’Intelligence Artificielle et la Révolution Industrielle]]></title>
            <link>https://medium.com/@maniar.othmane/lintelligence-artificielle-et-la-r%C3%A9volution-industrielle-b7961642b90e?source=rss-2c28d16fbd1c------2</link>
            <guid isPermaLink="false">https://medium.com/p/b7961642b90e</guid>
            <category><![CDATA[history]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[industrial-revolution]]></category>
            <dc:creator><![CDATA[Maniar Othmane]]></dc:creator>
            <pubDate>Wed, 04 Mar 2026 21:16:39 GMT</pubDate>
            <atom:updated>2026-03-04T22:07:50.930Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tYEkOCx0LTE5Z5S0QdgEiQ.png" /></figure><h3>Une Analyse Comparative des Transformations du Marché du Travail</h3><h3>Abstract</h3><p>Cette étude présente une analyse comparative entre la Révolution de l’Intelligence Artificielle contemporaine et la Révolution Industrielle des 18ème et 19ème siècles. À travers l’examen de données historiques quantitatives et de recherches économiques récentes, nous identifions des parallèles significatifs dans les schémas de déplacement des travailleurs, de stagnation salariale et de transformation des emplois. Toutefois, des différences critiques émergent, notamment en termes de vitesse de transformation (80 ans vs. 5–10 ans), de nature du travail affecté (physique vs. cognitif) et de besoins infrastructurels. L’analyse révèle que si la Révolution Industrielle a finalement conduit à une prospérité généralisée après plus d’un siècle de transition difficile, la Révolution de l’IA présente le défi unique de réaliser une transformation similaire en une fraction du temps.</p><h3>1. Introduction</h3><p>Les parallèles entre la Révolution de l’Intelligence Artificielle et la Révolution Industrielle sont frappants, bien qu’il existe des différences cruciales qui méritent une analyse approfondie. Robert Emerson Lucas Junior [1] , économiste américain, souligne que la Révolution Industrielle représente l’événement le plus transformateur de l’histoire économique humaine, avec des taux de croissance maintenus à environ 2% par an depuis le 19ème siècle, ce qui a conduit à une augmentation de plus de 40 fois du PIB par habitant sur deux siècles.</p><p>La Révolution de l’Intelligence Artificielle est, ou sera, une transformation d’une profondeur comparable — peut-être équivalente, peut-être encore plus fondamentale — mais dont la vitesse d’exécution sera sans commune mesure avec celle de son prédécesseur industriel. Là où la Révolution Industrielle a mis plus d’un siècle à remodeler les économies mondiales, l’IA opère sa transformation en quelques années, laissant aux individus, aux institutions et aux États un temps d’adaptation drastiquement réduit.</p><p>Dans cet article, nous allons comparer ces deux révolutions selon les critères suivants :</p><ul><li><strong>Déplacement des travailleurs</strong> — dans quelle mesure chaque révolution a-t-elle éliminé des emplois existants ?</li><li><strong>Résistance sociale</strong> — quelles formes de résistance les travailleurs ont-ils opposées à la transformation ?</li><li><strong>Stagnation des salaires</strong> — comment les salaires réels ont-ils évolué par rapport à la productivité durant la transition ?</li><li><strong>Création de nouveaux emplois</strong> — dans quelle mesure de nouvelles catégories professionnelles ont-elles émergé ?</li><li><strong>Déclin de la part du travail dans le revenu</strong> — comment la fraction du revenu national captée par le travail a-t-elle évolué ?</li><li><strong>Vitesse du changement</strong> — en combien de temps la transformation s’est-elle déployée ?</li><li><strong>Nature du travail remplacé</strong> — s’agit-il de tâches physiques ou cognitives ?</li><li><strong>Besoins en infrastructure</strong> — quels investissements matériels la transformation requiert-elle ?</li><li><strong>Catégories de travailleurs affectés</strong> — qui sont les travailleurs les plus vulnérables ?</li></ul><p>Pour chacun de ces critères, nous examinerons d’abord les <strong>similarités</strong> entre les deux révolutions — ce que l’histoire industrielle nous apprend sur la dynamique actuelle — puis les <strong>différences critiques</strong> qui font de la Révolution de l’IA un phénomène distinct, exigeant des réponses politiques et institutionnelles inédites.</p><h3>2. Similarités Fondamentales</h3><h3>2.1 Déplacement Initial des Travailleurs</h3><p>Les deux révolutions ont déplacé des travailleurs dans leurs phases initiales. En 1800, environ 80% de la main-d’œuvre américaine était employée dans l’agriculture. En 1900, ce chiffre était tombé à 40%, et en 2000, à moins de 2%. De même, l’IA déplace aujourd’hui les travailleurs débutants à des taux significatifs.</p><p>La recherche de Lucas sur la diffusion mondiale de la Révolution Industrielle [1] révèle des données encore plus impressionnantes. Selon son analyse utilisant les données de Maddison sur 50 pays, le revenu par habitant mondial a connu une augmentation de 13 fois entre 1820 et 2018. Lucas note que “cette augmentation représente une période sans précédent dans l’histoire. Aucune période historique n’avait jamais connu une telle prospérité matérielle à l’échelle mondiale”. Avant la Révolution Industrielle, les revenus annuels des travailleurs ordinaires restaient dans une fourchette de 500 à 800 dollars (en prix actuels américains) pendant des siècles.</p><h3>2.2 Résistance et Peur : Le Mouvement Luddite Réexaminé</h3><h3>2.2.1 La Résistance à l’IA : Un Néo-Luddisme Contemporain</h3><p>La résistance à l’IA prend aujourd’hui des formes qui rappellent le mouvement Luddite, bien qu’elle s’exprime différemment — sur les plans juridiques, politiques et culturels plutôt que physiques.</p><p>La peur la plus immédiate reste celle du déplacement économique. Comme les tisserands du 19ème siècle, des millions de travailleurs du savoir — rédacteurs, développeurs, graphistes, analystes — assistent à la dévaluation de compétences acquises au prix d’années d’expérience. La grève des scénaristes américains (WGA) en 2023, près de 150 jours pour obtenir des protections contractuelles contre l’IA, en est l’illustration la plus frappante. Ce ne sont pas des réactions irrationnelles, mais des formes modernes de “négociation collective” face à une disruption perçue comme existentielle.</p><p>Sur le plan juridique, les procès contre OpenAI, Stability AI et Midjourney par des artistes et auteurs, ainsi que l’AI Act européen, reproduisent la logique luddite : contraindre les détenteurs de la technologie à des concessions et à un partage des gains.</p><p>Mais la résistance à l’IA touche à quelque chose de plus profond qu’à l’époque industrielle. Là où les Luddites craignaient de perdre leur place dans l’économie, c’est aujourd’hui l’identité humaine elle-même qui semble menacée — l’art, la créativité, le raisonnement, tout ce qui semblait hors d’atteinte des machines. Comme Hobsbawm l’avait démontré pour les Luddites, qualifier cette résistance de simple “technophobie” serait réducteur : elle exprime une demande légitime de partage des gains de productivité et de contrôle démocratique sur des technologies aux conséquences encore mal comprises.</p><h3>2.3 Stagnation des Salaires Durant la Transition</h3><p>Durant les premières décennies de la Révolution Industrielle, même si la production par travailleur augmentait, les salaires réels stagnaient. Les salaires n’ont commencé à augmenter en ligne avec la productivité qu’après le milieu du 19ème siècle. Nous observons des tendances similaires aujourd’hui avec des salaires plats malgré une productivité accrue dans de nombreux secteurs.</p><p>Les données historiques sont révélatrices : en 1900, la plupart des travailleurs industriels américains travaillaient des journées de 10 heures, mais gagnaient 20 à 40% de moins que ce qui était nécessaire pour une vie décente. Dans l’industrie textile britannique, Wood [3] rapporte que les salaires réels des tisserands à la main sont tombés à près d’un quart de leur niveau d’âge d’or malgré des centaines de milliers de personnes restant dans la profession. Ce découplage entre productivité et salaires a duré plusieurs décennies avant que les gains de productivité ne se traduisent en augmentations salariales.</p><h3>2.4 Transformation et Création d’Emplois</h3><p>La Révolution Industrielle n’a pas simplement remplacé les travailleurs par des machines — elle a fondamentalement transformé la nature du travail lui-même. L’économie industrielle a créé des classes professionnelles entièrement nouvelles : ingénieurs industriels, directeurs d’usine, opérateurs de machines. L’IA suit un schéma similaire, créant des rôles comme les éthiciens de l’IA, les ingénieurs de prompts et les spécialistes de la collaboration homme-IA.</p><p>Les recherches récentes démontrent l’ampleur de cette transformation : environ <strong>60% des travailleurs en 2018 occupaient des professions qui n’existaient pas en 1940</strong> [4]. Pendant la première Révolution Industrielle, Manchester a connu une augmentation de sa population de 600% entre 1771 et 1831, et Bradford a grandi de 50% chaque décennie entre 1811 et 1851.</p><h3>2.5 Déclin de la Part du Travail dans le Revenu</h3><p>La transition avec l’IA se rapproche étroitement des changements historiques apportés par la Révolution Industrielle, qui a vu des baisses de 5 à 15% de la part du travail dans le revenu national [1].</p><h4>2.5.1 L’Évidence Historique : La « Pause d’Engels »</h4><p>Le phénomène le plus documenté de la Révolution Industrielle britannique est ce que les économistes ont baptisé la <strong>« Pause d’Engels »</strong> (1780–1840) : une période de soixante ans durant laquelle la productivité par travailleur s’accroît considérablement, alors que les salaires réels stagnent ou régressent. La quasi-totalité des gains issus de la mécanisation est alors captée sous forme de profits et de rentes, ce qui se traduit par un transfert structurel du revenu national du travail vers le capital.</p><p>Crafts [8] estime que la part du travail dans le revenu national britannique a chuté d’environ <strong>57–60 % en 1760 à 45–50 % en 1850</strong>, soit une contraction de l’ordre de dix à quinze points de pourcentage en moins d’un siècle. Ce recul n’est pas un artefact statistique : il reflète la combinaison de trois mécanismes distincts.</p><p><strong>Mécanisme 1 — Approfondissement du capital.</strong> La substitution capital-travail modifie la fonction de production : là où il fallait dix tisserands à la main, un ouvrier et un métier mécanique suffisent. À court terme, la demande de travail n’augmente pas en proportion du surcroît de production, car le capital absorbe l’essentiel de la valeur ajoutée supplémentaire.</p><p><strong>Mécanisme 2 — Excédent de main-d’œuvre rurale.</strong> L’exode agricole massif maintient un réservoir quasi illimité de travailleurs prêts à accepter les salaires de subsistance des villes industrielles. Dans cette configuration de marché, les employeurs disposent d’un pouvoir de fixation des salaires (<em>monopsone de fait</em>) que rien n’équilibre institutionnellement avant l’émergence des syndicats.</p><p><strong>Mécanisme 3 — Faiblesse des institutions du travail.</strong> En l’absence de syndicats légaux (les <em>Combination Acts</em> de 1799 et 1800 interdisent toute organisation collective), de salaire minimum et de négociation collective, les travailleurs n’ont pas les moyens de réclamer leur part des gains de productivité. Wood [3] calcule que les salaires réels des tisserands à la main sont tombés à environ un quart de leur niveau d’avant la mécanisation, et ce malgré le maintien de centaines de milliers de personnes dans la profession.</p><h4>2.5.2 Le Retournement : Comment la Part du Travail a Fini par se Redresser</h4><p>La récupération partielle de la part du travail à partir du milieu du XIXe siècle n’est pas spontanée : elle résulte d’une série d’interventions institutionnelles qui rétablissent un rapport de forces plus équilibré. Les <em>Factory Acts</em> de 1833 et 1844 limitent la durée du travail et abolissent le travail des jeunes enfants, réduisant l’offre de travail bon marché. La légalisation des syndicats (Trade Union Act de 1871) donne aux travailleurs un levier de négociation. L’extension progressive du droit de vote (Reform Acts de 1832 à 1884) crée des incitations politiques à améliorer les conditions ouvrières.</p><p>C’est seulement lorsque ces trois conditions — réglementation du marché du travail, organisation collective, représentation politique — sont réunies que les salaires réels commencent à croître en ligne avec la productivité, à partir des années 1860–1870 environ. La leçon historique est donc sans ambiguïté : <strong>la redistribution des gains de productivité ne s’opère pas automatiquement ; elle exige des institutions explicitement conçues à cet effet</strong>.</p><h3>3. Différences Critiques</h3><h3>3.1 Vitesse du Changement : Une Compression Temporelle Sans Précédent</h3><p>Contrairement aux usines et aux chaînes de production du 19ème siècle, la Révolution de l’IA compresse des siècles de transformation en quelques décennies. La Révolution Industrielle s’est déroulée sur <strong>100–150 ans</strong> ; l’IA transforme des industries entières en <strong>5–10 ans</strong>.</p><p>Lucas [1] documente précisément cette diffusion historique : la Révolution Industrielle a débuté en Grande-Bretagne vers 1760 et s’est étendue à l’Europe continentale et aux États-Unis vers 1840 — soit un processus d’environ 80 ans. En 1800, environ 20% de la population britannique vivait dans des zones urbaines ; en 1850, cette proportion était montée à 50%, mais ce changement a pris un demi-siècle. En comparaison, la transformation numérique actuelle se produit en moins d’une décennie dans de nombreux secteurs.</p><h3>3.2 Nature du Travail Remplacé</h3><p>La Révolution Industrielle concernait les machines <strong>amplifiant les muscles humains</strong>. La Révolution de l’IA concerne les machines <strong>amplifiant — et souvent remplaçant — la pensée humaine</strong>. Cette différence fondamentale rend la perturbation actuelle plus profonde psychologiquement et socialement.</p><h3>3.3 Besoins en Infrastructure : Massif vs. Virtuel</h3><p>Les agents IA, contrairement à la chaîne de production, ne nécessitent pas d’infrastructure physique massive comparable. Ils nécessitent des données, de la puissance de calcul et une intégration dans les flux de travail. Ce changement accélère considérablement l’adoption.</p><p>Les premières usines textiles nécessitaient des investissements massifs en infrastructure. La première usine de soie hautement mécanisée était celle de John Lombe à Derby, opérationnelle dès 1721. Ces établissements nécessitaient des bâtiments pouvant accueillir plusieurs centaines à milliers de travailleurs, des systèmes de roues à eau ou de machines à vapeur, et souvent des fortifications pour protéger les machines. L’usine d’Arkwright à Cromford possédait même des canons pour sa défense.</p><h3>3.4 Catégories de Travailleurs Déplacés</h3><p>Contrairement aux vagues technologiques précédentes, <strong>l’IA peut présenter une menace plus importante pour les travailleurs hautement éduqués</strong>. La Révolution Industrielle a principalement déplacé les travailleurs manuels ; l’IA déplace les travailleurs du savoir, y compris les programmeurs, les analystes et les professionnels créatifs. Cette inversion représente un changement paradigmatique dans la nature de l’automatisation.</p><h3>3.5 Effet Paradoxal sur les Débutants vs. Expérimentés</h3><p>Les études d’OpenAI montrent que l’IA générative peut bénéficier de manière disproportionnée aux travailleurs moins expérimentés en les rendant plus productifs et en les aidant à rivaliser avec les plus expérimentés. Cela crée une dynamique inhabituelle où <strong>l’IA aide les travailleurs juniors mais menace les postes de débutants</strong> — un paradoxe sans équivalent historique clair.</p><h3>3.6 Déclin de la Part du Travail dans le Revenu à l’Ère de l’IA : Une Dynamique Accélérée et Structurellement Différente</h3><p>Si la baisse de la part du travail constitue une similitude entre les deux révolutions (§ 2.5), les mécanismes contemporains diffèrent suffisamment pour constituer une différence critique à part entière.</p><h4>3.6.1 L’Ampleur du Recul Contemporain</h4><p>Karabarbounis et Neiman [13] ont documenté, à partir des données de comptabilité nationale de plus de cinquante pays, une baisse mondiale de la part du travail d’environ <strong>cinq points de pourcentage entre le début des années 1980 et 2012</strong>, soit un recul d’une ampleur comparable à celui observé durant toute la phase haute de la Révolution Industrielle, mais comprimé en trois décennies. Aux États-Unis, le Bureau of Labor Statistics enregistre un repli de la part salariale d’environ <strong>65 % du revenu national dans les années 1970 à 56 % en 2020</strong>, soit un niveau jamais atteint depuis la Seconde Guerre mondiale.</p><p>Ce recul n’est pas uniforme : il se concentre dans les secteurs à forte intensité numérique, ce qui suggère un lien direct avec l’automatisation et l’essor des technologies de l’information.</p><h4>3.6.2 Les Mécanismes Propres à l’IA</h4><p>Contrairement à la Révolution Industrielle, où la substitution capital-travail concernait principalement des tâches physiques répétitives, l’IA opère selon trois mécanismes nouveaux qui renforcent et accélèrent la compression de la part du travail :</p><p><strong>Économies d’échelle sur les actifs immatériels.</strong> Les modèles de langage, les algorithmes de recommandation et les systèmes d’automatisation cognitive sont des biens non rivaux : une fois développés, leur coût marginal de déploiement est quasi nul. Une entreprise comme OpenAI ou Google peut servir des millions d’utilisateurs supplémentaires sans embaucher proportionnellement. Le capital immatériel — données, modèles, propriété intellectuelle — absorbe ainsi une part croissante de la valeur ajoutée que le travail ne peut pas revendiquer.</p><p><strong>Effet « firmes superstars ».</strong> Autor, Dorn, Katz, Patterson et Van Reenen [14] ont montré que la concentration du marché sur quelques firmes très productives — bénéficiaires de l’IA et des effets de réseau — explique une fraction significative du recul de la part du travail : les firmes superstars ont des parts de valeur ajoutée élevées et des parts salariales structurellement basses, car leur business model repose précisément sur la substitution du travail par le capital technologique.</p><p><strong>Compression géographique et temporelle.</strong> Là où il a fallu soixante ans de « Pause d’Engels » pour que la divergence productivité-salaires s’installe pleinement en Grande-Bretagne, les modèles économétriques actuels suggèrent que l’IA générative pourrait produire un effet équivalent en moins d’une décennie, car le déploiement logiciel ne rencontre pas les frictions physiques de la mécanisation industrielle.</p><h4>3.6.3 Une Différence Institutionnelle Majeure : Les Mécanismes de Rééquilibrage Sont Moins Bien Armés</h4><p>Le redressement de la part du travail au XIXe siècle a reposé sur des institutions du marché du travail — syndicats, droit du travail, extension du suffrage — qui ont mis des décennies à émerger. Aujourd’hui, ces institutions existent, mais elles sont calibrées pour le travail salarié traditionnel et peinent à appréhender les nouvelles formes de travail liées à l’IA : <strong>travailleurs de plateforme, free-lances déplacés par l’automatisation, travailleurs d’annotation de données dans les pays émergents</strong>.</p><p>De plus, la nature même de la valeur créée par l’IA complique la revendication salariale : une part croissante des gains de productivité prend la forme d’une réduction de coûts pour les consommateurs (prix plus bas, services gratuits financés par la publicité) plutôt que de profits mesurables redistribuables par la négociation collective. Ce phénomène rend la part du travail difficile à négocier et encore plus difficile à restaurer par les voies conventionnelles.</p><h4>3.6.4 Implications : Un Défi de Redistribution Sans Précédent</h4><p>La combinaison de ces facteurs — mécanismes structurellement différents, vitesse d’exécution accélérée et inadéquation des institutions de redistribution existantes — suggère que le recul contemporain de la part du travail sera plus difficile à inverser que lors de la Révolution Industrielle, sauf à concevoir de nouveaux outils de redistribution explicitement adaptés à l’économie des actifs immatériels : taxation du capital algorithmique, partage des données comme bien public, adaptation du droit du travail aux travailleurs algorithmiquement déplacés.</p><h3>4. Le Débat Déplacement vs. Réintégration</h3><h3>4.1 Deux Forces Concurrentes</h3><p><strong>Effet de Déplacement :</strong> Les nouvelles technologies automatisent les tâches que les travailleurs effectuaient auparavant, entraînant une réduction de la main-d’œuvre. Cela réduit la part du travail dans le revenu national et découple les salaires de la productivité.</p><p><strong>Effet de Réintégration :</strong> Les nouvelles technologies créent des catégories entièrement nouvelles de tâches et d’emplois qui nécessitent des travailleurs humains.</p><h3>4.2 Schéma Historique</h3><p>Durant la phase initiale de la Révolution Industrielle, l’effet de déplacement a dominé, nuisant aux travailleurs ; au 20ème siècle, l’effet de réintégration est devenu plus fort, faisant augmenter les salaires et les niveaux de vie. Cette transition a pris <strong>plusieurs générations</strong>.</p><h3>4.3 Défi Actuel</h3><p>Depuis la fin du 20ème siècle, les salaires réels dans de nombreuses économies avancées sont restés plats. De nombreuses innovations TIC et IA ont été orientées vers l’automatisation plutôt que vers la création de nouveaux types de tâches, soulevant la question de savoir si l’effet de réintégration sera aussi fort qu’historiquement.</p><h3>5. Leçons de l’Histoire : Données Quantitatives</h3><h3>5.1 Gains de Productivité Massifs</h3><p>Les preuves historiques suggèrent que les révolutions technologiques créent finalement plus d’emplois qu’elles n’en détruisent, mais après une période de transition douloureuse.</p><ul><li>La mécanisation du filage du coton a augmenté la production par travailleur d’un facteur d’environ <strong>500</strong></li><li>Le métier à tisser mécanique a augmenté la production d’un facteur de <strong>40</strong></li><li>En Angleterre et en Écosse en 1788, deux tiers des travailleurs dans 143 usines de coton alimentées par l’eau étaient des enfants — travaillant pour 10 à 20% du salaire d’un homme adulte</li><li>Les premières lois générales contre le travail des enfants (Factory Acts) ont été adoptées en Grande-Bretagne en <strong>1833 et 1844</strong></li></ul><h3>5.2 Le Rôle de la Puissance à Vapeur</h3><p>L’étude quantitative d’Atack, Bateman et Margo [5] sur la puissance à vapeur fournit des données précises sur les gains de productivité (données issues des recensements manufacturiers de 1850 à 1880) :</p><ul><li>En 1880, <strong>51% de tous les travailleurs manufacturiers</strong> étaient employés dans des établissements utilisant la puissance à vapeur, comparé à seulement <strong>17% en 1850</strong></li><li>Les établissements alimentés à la vapeur avaient une productivité du travail plus élevée que ceux utilisant la force manuelle, animale ou hydraulique</li><li>L’impact de la vapeur sur la productivité du travail augmentait avec la taille de l’établissement</li><li>La diffusion de la puissance à vapeur a représenté <strong>22 à 41% de la croissance de la productivité du travail</strong> entre 1850 et 1880, selon la taille de l’établissement [5]</li></ul><h3>5.3 La Transition Sera Douloureuse</h3><p>La leçon clé de l’histoire est que, bien que le résultat à long terme puisse être positif, la période de transition peut être dévastatrice pour les travailleurs déplacés. La question n’est pas de savoir si de nouveaux emplois émergeront, mais <strong>s’ils émergeront assez rapidement et si les travailleurs déplacés pourront y accéder</strong>.</p><p>Entre novembre 1811 et le printemps 1812, les autorités du Midlands ont signalé que “2000 hommes, dont beaucoup armés, traversaient de manière insurrectionnelle le comté de Nottingham” [2]. Le procès de masse à York en 1813 a abouti à de nombreuses pendaisons et déportations en Australie.</p><h3>5.4 L’Écart de Compétences Est Critique</h3><p>Il y a un besoin urgent pour les travailleurs d’acquérir de nouvelles compétences pertinentes pour une économie axée sur les données. Cela s’applique aux employés actuels qui devront se perfectionner ou se reconvertir, ainsi qu’à ceux sur le point d’entrer sur le marché du travail. L’histoire montre que ceux qui ne peuvent pas s’adapter aux nouvelles technologies subissent les coûts les plus élevés de la transition.</p><h3>5.5 Amélioration de la Productivité vs. Remplacement</h3><p>Dans certains secteurs, l’IA ne remplace pas les gens — ils accomplissent simplement plus de travail. Les entreprises qui adoptent l’IA embauchent des personnes avec des compétences en IA. Cela suggère que l’IA peut être un <strong>amplificateur de productivité</strong> plutôt qu’un simple outil de déplacement, reproduisant le modèle historique de la vapeur.</p><p>Les recherches d’Atack, Bateman et Margo [5] démontrent que les établissements utilisant la vapeur avaient une productivité du travail significativement plus élevée, mais qu’ils employaient également plus de travailleurs que les établissements comparables utilisant d’autres formes d’énergie.</p><h3>6. Conclusion</h3><p>La Révolution de l’IA reflète la Révolution Industrielle dans son schéma fondamental : déplacement initial, résistance des travailleurs, stagnation des salaires, suivis éventuellement par la création d’emplois et l’amélioration des niveaux de vie. Cependant, l’IA évolue beaucoup plus rapidement (5–10 ans vs. 80 ans), affecte le travail cognitif plutôt que physique, et nécessite beaucoup moins d’infrastructure physique pour être déployée.</p><p>La question cruciale n’est pas de savoir si l’IA créera de nouveaux emplois — les données historiques de Lucas [1], Hobsbawm [2] et Atack et al. [5] suggèrent fortement que ce sera le cas — mais <strong>si la société peut gérer la transition assez rapidement pour éviter des difficultés généralisées</strong>, et si nous pouvons nous assurer que ces nouvelles opportunités sont accessibles aux travailleurs déplacés plutôt que de créer une sous-classe permanente.</p><p>La Révolution Industrielle a finalement élevé les niveaux de vie pour la plupart, mais cela a pris <strong>plus d’un siècle</strong> et a impliqué d’énormes souffrances durant la transition. Les données quantitatives montrent que la diffusion de la puissance à vapeur a représenté 22 à 41% de la croissance de la productivité du travail entre 1850 et 1880, mais les travailleurs n’ont bénéficié de ces gains qu’après plusieurs décennies de stagnation salariale et de conflits sociaux violents.</p><p>Nous faisons maintenant face au défi de réaliser une transformation similaire en une fraction du temps, avec toutes les implications sociales et politiques que cela comporte. La différence est que nous avons maintenant <strong>l’avantage de l’histoire</strong> : nous savons que la transition est possible, mais nous savons aussi qu’elle sera douloureuse sans intervention politique proactive pour faciliter l’adaptation des travailleurs et assurer une distribution plus équitable des gains de productivité.</p><h3>Déclaration d’Assistance par Intelligence Artificielle</h3><p>L’auteur déclare avoir utilisé un assistant d’intelligence artificielle (Claude, développé par Anthropic) pour la recherche documentaire initiale, la structuration du document et la rédaction de cet article. L’outil d’IA a été utilisé pour :</p><ul><li>Identifier et localiser des sources académiques pertinentes</li><li>Structurer l’argumentation comparative selon les standards académiques</li><li>Rédiger des versions préliminaires de certaines sections</li><li>Formater le document selon les conventions LaTeX scientifiques</li></ul><p>Toutes les interprétations, conclusions et analyses présentées reflètent le jugement et la compréhension de l’auteur.</p><h3>Références</h3><p>[1] Lucas, R.E. Jr. (2009). Trade and the Diffusion of the Industrial Revolution. <em>American Economic Journal: Macroeconomics</em>, 1(1), 1–25.</p><p>[2] Hobsbawm, E.J. (1952). The Machine Breakers. <em>Past &amp; Present</em>, №1, 57–70.</p><p>[3] Wood, G.H. (1910). Statistics of Wages in the Nineteenth Century. <em>Journal of the Royal Statistical Society</em>, 73, 29–96.</p><p>[4] Chicago Federal Reserve (2024). <em>Occupational Switching During the Second Industrial Revolution</em>. Working Paper Series.</p><p>[5] Atack, J., Bateman, F., &amp; Margo, R.A. (2008). Steam power, establishment size, and labor productivity growth in nineteenth century American manufacturing. <em>Explorations in Economic History</em>, 45(2), 185–198.</p><p>[6] Lucas, R.E. Jr. (2017). What Was the Industrial Revolution? NBER Working Paper №23547.</p><p>[7] Lucas, R.E. Jr. (2002). The Industrial Revolution: Past and Future. <em>Federal Reserve Bank of Minneapolis Annual Report Essay</em>.</p><p>[8] Crafts, N.F.R. (1985). <em>British Economic Growth during the Industrial Revolution</em>. Oxford University Press.</p><p>[9] Maddison, A. (2003). <em>The World Economy: Historical Statistics</em>. OECD Development Centre.</p><p>[10] Ashton, T.S. (1948). <em>The Industrial Revolution 1760–1830</em>. Oxford University Press.</p><p>[11] Thompson, E.P. (1963). <em>The Making of the English Working Class</em>. Vintage Books.</p><p>[12] Galor, O. (2011). <em>Unified Growth Theory</em>. Princeton University Press.</p><p>[13] Karabarbounis, L., &amp; Neiman, B. (2014). The Global Decline of the Labor Share. <em>The Quarterly Journal of Economics</em>, 129(1), 61–103.</p><p>[14] Autor, D., Dorn, D., Katz, L.F., Patterson, C., &amp; Van Reenen, J. (2020). The Fall of the Labor Share and the Rise of Superstar Firms. <em>The Quarterly Journal of Economics</em>, 135(2), 645–709.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b7961642b90e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Retry pattern with resilience4j and Spring boot]]></title>
            <link>https://medium.com/@maniar.othmane/retry-pattern-with-resilience4j-and-spring-boot-cfeaa90458d?source=rss-2c28d16fbd1c------2</link>
            <guid isPermaLink="false">https://medium.com/p/cfeaa90458d</guid>
            <dc:creator><![CDATA[Maniar Othmane]]></dc:creator>
            <pubDate>Wed, 05 Jan 2022 12:37:40 GMT</pubDate>
            <atom:updated>2022-01-05T12:54:51.032Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*463nFnw1PClrWh-SwZzGrg.jpeg" /></figure><p>In this series of articles we will introduce resilience4j, we will learn about different resiliency patterns and we will implement them in a Spring boot application</p><h3>What You Need</h3><ul><li>Any text editor or IDE</li><li>JDK 13 or later</li><li>Maven 3+</li><li>Apache benchmarck</li></ul><h3>Why should we think about resiliency</h3><p>There are many reasons why resiliency is important in our daily jobs, mainly in microservices architectures.</p><p>In real microservices world :</p><ul><li>error happens inevitably</li><li>communication between services is no more a simple method call, it will go through many infrastructure layers</li><li>we do not have control on the producer services, or infrastructure to reach them</li></ul><h3>Introduction to resilience4j</h3><p>Resilience4j is a <strong><em>modular</em></strong>, <strong><em>lightweight</em></strong>, <strong><em>easy to use </em></strong>, fault tolerance library, build with and for java 8.</p><ul><li><strong><em>modular</em></strong> : you can use only the dependencies that you need, there is no all or nothing</li><li><strong><em>lightweight</em></strong> : have only one external dependency (Vavr)</li><li><strong><em>easy to use</em></strong> : based on decorators, higher order functions, to enhance any function (functional interface, lambda expression, method reference)</li></ul><p>Resilience4j implements multiple resiliency patterns :</p><p>- Circuit Breaker<br>- RateLimiter<br>- TimeLimiter<br>- Retry<br>- Bulkhead<br>- Cache</p><p>Now that Hystrix is dead, resilience4j is the first choice fault tolerance library for java developers.</p><h4>More about resilience4j modularity</h4><p>Resilience4j provides different modules, core, addons, frameworks, reactive and metrics.</p><p>In your application you can pick only what you really need,</p><p>In one project that needs to implement retry pattern on a feign client i will choose as dependencies :</p><p>- resilience4j-retry<br>- resilience4j-feign</p><p>In an another spring boot project needing a circuit breaker a bulkhead the dependencies will be :</p><p>- resilience4j-circuitbreanker <br>- resilience4j-bulkhead<br>- resilience4j-spring-boot2</p><p>NB : you can use a <strong><em>resilience4j-all</em></strong> that envelopes all core modules</p><p>- resilience4j-retry<br>- resilience4j-circuitbreaker<br>- resilience4j-ratelimiter<br>- resilience4j-bulkhead<br>- resilience4j-cache<br>- resilience4j-timelimiter</p><h3>Retry Patten</h3><p>Each resiliency pattern solves a specific set of problems, below we will talk about the use cases where a retry strategy can help improve our app resiliency.</p><p>The first thing that we need to define is the concept of transient error.</p><h4>What is a transient error</h4><p>A transient error is an error that occurs once or at unpredictable intervals.</p><h4>Examples of real scenarios transient errors</h4><p>- loss of network connectivity<br>- timeouts requests<br>- temporarily unavailable services<br>- unavailable shared resources , limited resources (db connections, threads pools …)<br>- a failing instance that still receive requests from loadbalancer (the client requests will face 1 error each N call, N being the producer instances number)</p><h4>Retry Pattern definition</h4><p>The retry pattern, let your consumer retry calls whenever they fail. This solution can solve cascading failure caused by transient errors, The basic deal is that if the error cause will resolve itself, we can be pretty sure one of the next retry calls will succeed, and this will prevent our consumer from cascading failure.</p><h4>Simple resilience4j retry configuration</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JXM7Et7omQonmo7gGi8gIw.png" /><figcaption>NB: resilience4j offers much more configuration options, for example we can configure a retry based on some result or exception predicate ,we can configure a waiting interval function</figcaption></figure><h3>Code demo</h3><h4>Get the code</h4><p>You can download the code using this url <a href="https://github.com/mothmane/resilience4j-demo/archive/refs/heads/main.zip">github-main.zip</a> or clone the project using the below command</p><pre>git clone <a href="https://github.com/mothmane/resilience4j-demo.git">https://github.com/mothmane/resilience4j-demo.git</a></pre><p>The demo project is composed of two maven modules, <em>producer</em> and <em>retry-consumer</em>, each one is a standalone spring boot application</p><h4>Build the project</h4><p>You can use below command to build the project</p><pre>./mvnw clean package</pre><h4>Producer code</h4><p>the producer app is a simple spring boot webflux project exposing <em>/unstable</em> endpoint wish has an average failure of 20%</p><pre><a href="http://twitter.com/RestController">@RestController</a><br>public class UnstableController {</pre><pre>public static final int BOUND = 5;</pre><pre><a href="http://twitter.com/GetMapping">@GetMapping</a>(“/unstable”)<br> public Mono&lt;Product&gt; unstable() throws Exception {<br> if(new Random().nextInt(BOUND)==1){<br>   throw new Exception(“oups something bad has happend”);<br> }<br> return Mono.just(new Product(“TV”,350.00));<br> }<br>}</pre><h4>Retry consumer code</h4><p>To add resilience4j to our consumer app we will need the following maven configuration</p><pre>&lt;properties&gt;<br>  &lt;resilience4j-spring-boot2.version&gt;1.7.1&lt;/resilience4j-spring-boot2.version&gt;<br>&lt;/properties&gt; <br>...<br>&lt;dependency&gt;<br>      &lt;groupId&gt;io.github.resilience4j&lt;/groupId&gt;<br>      &lt;artifactId&gt;resilience4j-spring-boot2&lt;/artifactId&gt;<br>      &lt;version&gt;${resilience4j-spring-boot2.version}&lt;/version&gt;<br>    &lt;/dependency&gt;<br>    &lt;dependency&gt;<br>      &lt;groupId&gt;io.github.resilience4j&lt;/groupId&gt;<br>      &lt;artifactId&gt;resilience4j-annotations&lt;/artifactId&gt;<br>      &lt;version&gt;${resilience4j-spring-boot2.version}&lt;/version&gt;<br>      &lt;scope&gt;compile&lt;/scope&gt;<br>    &lt;/dependency&gt;<br>    &lt;dependency&gt;<br>      &lt;groupId&gt;io.github.resilience4j&lt;/groupId&gt;<br>      &lt;artifactId&gt;resilience4j-retry&lt;/artifactId&gt;<br>      &lt;version&gt;${resilience4j-spring-boot2.version}&lt;/version&gt;<br>    &lt;/dependency&gt;<br>    &lt;dependency&gt;<br>      &lt;groupId&gt;io.github.resilience4j&lt;/groupId&gt;<br>      &lt;artifactId&gt;resilience4j-reactor&lt;/artifactId&gt;<br>      &lt;version&gt;${resilience4j-spring-boot2.version}&lt;/version&gt;<br>    &lt;/dependency&gt;</pre><h4>Retry consumer application.yaml config</h4><p>resilience4j is configured in spring boot application properties files below is the configuration used in this demo</p><pre>resilience4j.retry:<br>  instances:<br>    unstableService:<br>      maxAttempts: 5<br>      waitDuration: 100<br>      enableExponentialBackoff: true<br>      exponentialBackoffMultiplier: 2</pre><h4>Retry consumer client code</h4><pre>@Service<br>public class UnstableClient {</pre><pre>  private static final String UNSTABLE_SERVICE = &quot;unstableService&quot;;</pre><pre>  private final WebClient webClient;</pre><pre>  public UnstableClient(WebClient webClient) {<br>    this.webClient = webClient;<br>  }</pre><pre>  public Mono&lt;Product&gt; unstable() {<br>    return webClient.get()<br>            .uri(&quot;/unstable&quot;)<br>            .retrieve()<br>            .bodyToMono(Product.class);<br>  }</pre><pre>  @Retry(name = UNSTABLE_SERVICE,fallbackMethod = &quot;defaultProduct&quot;)<br>  public Mono&lt;Product&gt; unstableWithRetry() {<br>    return webClient.get()<br>             .uri(&quot;/unstable&quot;)<br>             .retrieve()<br>              .bodyToMono(Product.class);<br>  }</pre><pre>  private Mono&lt;Product&gt; defaultProduct(Exception ex) {<br>    return Mono.just(new Product(&quot;DVD&quot;,12));<br>  }</pre><pre>}</pre><p>In the code above we have a simple non resilient client , and another one annotated with the resilience4 <strong><em>Retry</em></strong> annotation, this annotation have two properties, <strong><em>name</em></strong> that is valued with “<em>unstableService”</em> the instance name in application yaml file. and <strong><em>fallbackMethod</em></strong> wish take a method name that will be used as fall back in case all retry attempts fails, (the fall back method will be executed and it’s return value returned to the client).</p><p>Below a simple controller that exposes the client’s calls</p><pre>@RestController<br>public class ConsumerController {</pre><pre>  private final UnstableClient unstableClient;</pre><pre>  public ConsumerController(UnstableClient unstableClient) {<br>    this.unstableClient = unstableClient;<br>  }</pre><pre>  @GetMapping(&quot;/unstable-client&quot;)<br>  public Mono&lt;Product&gt; unstable() {<br>    return unstableClient.unstable();<br>  }</pre><pre>  @GetMapping(&quot;/unstable-with-retry-client&quot;)<br>  public Mono&lt;Product&gt; unstableWithRetry() {<br>    return unstableClient.unstableWithRetry();<br>  }<br>}</pre><h3>Run Demo</h3><p>First, we will start the producer.</p><p>Using your favorite IDE you can import the project and start it.</p><p>The producer app will run on port 8081 and the retry-consumer on 8082</p><p>or you can use the following commands</p><pre>java -jar producer/target/producer-0.0.1-SNAPSHOT.jar<br>java -jar retry-consumer/target/retry-consumer-0.0.1-SNAPSHOT.jar</pre><p>The producer app last log line should look like this</p><pre><br>2021-12-15 00:23:06.356  INFO 17401 --- [main] com.producer.demo.ProducerApplication    : Started ProducerApplication in 1.261 seconds (JVM running for 1.787)</pre><p>and the consumer app log :</p><pre><br>2021-12-15 00:25:48.997  INFO 19026 --- [           main] demo.RetryConsumerApplication            : Started RetryConsumerApplication in 2.714 seconds (JVM running for 3.234)</pre><p>Now that both our apps are running, let see what happends when we call the producer with a resilient client and with non resilient one.</p><p>In order to do it, we will use apache bench to get some stats about the producer unstable endpoint. for this you need to run this command</p><pre>ab -n 100 -c 1 <a href="http://localhost:8082/unstable-client">http://localhost:8082/unstable-client</a></pre><p>The result of the command should look like this</p><pre>Complete requests:      100<br>Failed requests:        36<br>   (Connect: 0, Receive: 0, Length: 36, Exceptions: 0)<br>Non-2xx responses:      36</pre><p>The apache bench shows that 36 request has failed, the errors propagated from producer api to non resilient client app causing it to fail each time the produced has failed.</p><p>let’s now use the resilience client</p><pre>ab -n 100 -c 1 <a href="http://localhost:8082/unstable-with-retry-client">http://localhost:8082/unstable-with-retry-client</a></pre><p>result</p><pre>Complete requests:      100<br>Failed requests:        0</pre><p>It’s clear that the error did not propagate to our consumer the retry pattern protected our system from cascading failures.</p><h3>Conclusion :</h3><p>In this article we learned about transient failure, we learned basic configuration options for retry pattern and we demonstrated how this pattern prevent from cascading failure. In the next article we will learn about another type of resiliency pattern wish is the Bulkhead.</p><h3>Contact</h3><p>Maniar Othmane</p><p><strong>Linkedin</strong> = <a href="https://linkedin.com/in/othmane-maniar-2364b518/"><em>https://linkedin.com/in/othmane-maniar-2364b518/</em></a></p><p><strong>Instagram</strong> =<a href="https://www.instagram.com/othmane_m/">https://www.instagram.com/othmane_m/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cfeaa90458d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TDD and Open/Closed Principle applied to FizzBuzz Kata]]></title>
            <link>https://medium.com/@maniar.othmane/tdd-and-open-closed-principle-applied-to-fizzbuzz-kata-2ce366b6f71a?source=rss-2c28d16fbd1c------2</link>
            <guid isPermaLink="false">https://medium.com/p/2ce366b6f71a</guid>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[tdd]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[kata]]></category>
            <dc:creator><![CDATA[Maniar Othmane]]></dc:creator>
            <pubDate>Wed, 24 Nov 2021 12:02:08 GMT</pubDate>
            <atom:updated>2021-11-25T21:24:11.822Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/519/1*5bm_wbtDaZ_leKW7JBTFtQ.png" /><figcaption><strong>image by :</strong> opensource.com</figcaption></figure><p>In this article we will see how the TDD and the (SOLID) Open/Closed principle can help us create a clean and extendable FizzBuzz kata solution.</p><h3><strong>What You Need</strong></h3><p>Any text editor or IDE</p><ul><li>JDK 11 or later</li><li>Gradle 4+</li></ul><h3>Fizz Buzz Kata</h3><h3>Problem Description</h3><p>Write a program that prints one line for each number from 1 to 100</p><ul><li>For multiples of three print Fizz instead of the number</li><li>For multiples of five print Buzz instead of the number</li><li>For numbers which are multiples of both three and five print FizzBuzz instead of the number</li></ul><h3>Result example</h3><pre>1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz, 11, Fizz, 13, 14, Fizz Buzz, 16, 17, Fizz, 19, Buzz, Fizz, 22, 23, Fizz, Buzz, 26, Fizz, 28, 29, Fizz Buzz, 31, 32, Fizz, 34, Buzz, Fizz, ...</pre><h3>Step by step solution</h3><p>First let’s configure our dependencies by adding the lines below to our <em>gradle.build</em> file dependencies section.</p><pre>dependencies {<br>    testImplementation &#39;org.assertj:assertj-core:3.20.2&#39;<br>    testImplementation &#39;org.junit.jupiter:junit-jupiter-api:5.7.0&#39;<br>    testRuntimeOnly &#39;org.junit.jupiter:junit-jupiter-engine:5.7.0&#39;<br>    testImplementation &#39;org.junit.jupiter:junit-jupiter-params:5.7.0&#39;<br>}</pre><h4>iteration 1</h4><p>Let’s write a first test and then make it pass with the simplest solution.</p><pre>class FizzBuzzTest {<br>  FizzBuzz fizzbuzz = new FizzBuzz();<br>  @Test<br>  void should_return_1_when_input_is_1() {<br>    assertThat(fizzbuzz.apply(1)).isEqualTo(&quot;1&quot;);<br>  }<br>}</pre><p><em>tests results : </em>⛔️</p><pre>public class  FizzBuzz {<br>   public String apply(int input){<br>    return &quot;1&quot;;<br>   }<br>}</pre><p><em>tests results : </em>✅</p><h4>iteration 2</h4><p>Write a second test and make sure the new implementation validates both tests.</p><pre>class FizzBuzzTest {</pre><pre>  FizzBuzz fizzbuzz = new FizzBuzz();</pre><pre>  @Test<br>  void should_return_1_when_input_is_1() {<br>    assertThat(fizzbuzz.apply(1)).isEqualTo(&quot;1&quot;);<br>  }</pre><pre>  @Test<br>  void should_return_2_when_input_is_2() {<br>    assertThat(fizzbuzz.apply(2)).isEqualTo(&quot;2&quot;);<br>  }<br>}</pre><p><em>tests results : </em>⛔️</p><pre>public class  FizzBuzz {<br>  public String apply(int input){<br>    return String.valueOf(input);<br>  }<br>}</pre><p><em>tests results : </em>✅</p><h4>iteration 2 (refactoring)</h4><p>At this point, our tests are basically identical except for input and expected result, so let’s create a junit parameterized test.</p><pre>class FizzBuzzTest {<br>  <br>  FizzBuzz fizzbuzz= new FizzBuzz();<br>  <br>  @ParameterizedTest(name = &quot;should return {1} when input is {0}&quot;)<br>  @CsvSource({&quot;1,1&quot;, &quot;2,2&quot;})<br>  void should_return_the_expected_string(int input, String expected) {<br>    assertThat(fizzbuzz.apply(input)).isEqualTo(expected);<br>  }<br>}</pre><p><em>tests results : </em>✅</p><h4>iteration 3</h4><p>Let’s add the third test and make it pass.</p><pre>class FizzBuzzTest {</pre><pre>  FizzBuzz fizzbuzz = new FizzBuzz();</pre><pre>  @ParameterizedTest(name = &quot;should return {1} when input is {0}&quot;)<br>  @CsvSource({&quot;1,1&quot;, &quot;2,2&quot;, &quot;3,Fizz&quot;})<br>  void should_return_the_expected_string(int input, String expected) {<br>    assertThat(fizzbuzz.apply(input)).isEqualTo(expected);<br>  }<br>}</pre><p><em>tests results : </em>⛔️</p><pre>public class FizzBuzz {<br>  public String apply(int input){<br>      if(input % 3 == 0)<br>         return &quot;Fizz&quot;;<br>      return String.valueOf(input);<br>  }<br>}</pre><p><em>tests results : </em>✅</p><h4>iteration 4</h4><p>Another test …</p><pre>class FizzBuzzTest {</pre><pre>  FizzBuzz fizzbuzz = new FizzBuzz();</pre><pre>  @ParameterizedTest(name = &quot;should return {1} when input is {0}&quot;)<br>  @CsvSource({&quot;1,1&quot;, &quot;2,2&quot;, &quot;3,Fizz&quot;, &quot;4,4&quot;})<br>  void should_return_the_expected_string(int input, String expected) {<br>    assertThat(fizzbuzz.apply(input)).isEqualTo(expected);<br>  }<br>}</pre><p><em>tests results : </em>✅</p><h4>iteration 5</h4><p>Add a test that will test the ‘Buzz’ output.</p><pre>class FizzBuzzTest {</pre><pre>  FizzBuzz fizzbuzz = new FizzBuzz();</pre><pre>  @ParameterizedTest(name = &quot;should return {1} when input is {0}&quot;)<br>  @CsvSource({&quot;1,1&quot;, &quot;2,2&quot;, &quot;3,Fizz&quot;, &quot;4,4&quot;, &quot;5,Buzz&quot;})<br>  void should_return_the_expected_string(int input, String expected) {<br>    assertThat(fizzbuzz.apply(input)).isEqualTo(expected);<br>  }<br>}</pre><p><em>tests results : </em>⛔️</p><pre>public class FizzBuzz {  <br>  <br>  public String apply(int input){<br>      if(input % 3 ==0)<br>        return &quot;Fizz&quot;;<br>      if(input % 5 ==0)<br>        return &quot;Buzz&quot;;<br>      return String.valueOf(input);<br>  }<br>}</pre><p><em>tests results : </em>✅</p><h4>iteration 6</h4><p>Continue adding more tests.</p><pre>class FizzBuzzTest {</pre><pre>  FizzBuzz fizzbuzz = new FizzBuzz();</pre><pre>  @ParameterizedTest(name = &quot;should return {1} when input is {0}&quot;)<br>  @CsvSource({&quot;1,1&quot;, &quot;2,2&quot;, &quot;3,Fizz&quot;, &quot;4,4&quot;, &quot;5,Buzz&quot;,&quot;6,Fizz&quot;})<br>  void should_return_the_expected_string(int input, String expected) {<br>    assertThat(fizzbuzz.apply(input)).isEqualTo(expected);<br>  }<br>}</pre><p><em>tests results : </em>✅</p><h4>iteration 7</h4><p>Continue adding more tests.</p><pre>class FizzBuzzTest {</pre><pre>  FizzBuzz fizzbuzz = new FizzBuzz();</pre><pre>  @ParameterizedTest(name = &quot;should return {1} when input is {0}&quot;)<br>  @CsvSource({&quot;1,1&quot;, &quot;2,2&quot;, &quot;3,Fizz&quot;, &quot;4,4&quot;, &quot;5,Buzz&quot;,&quot;6,Fizz&quot;,&quot;10,Buzz&quot;})<br>  void should_return_the_expected_string(int input, String expected) {<br>    assertThat(fizzbuzz.apply(input)).isEqualTo(expected);<br>  }<br>}</pre><p><em>tests results : </em>✅</p><h4>iteration 8</h4><p>Add a ‘FizzBuzz’ output test use case and make it green.</p><pre>class FizzBuzzTest {</pre><pre>  FizzBuzz fizzbuzz = new FizzBuzz();</pre><pre>  @ParameterizedTest(name = &quot;should return {1} when input is {0}&quot;)<br>  @CsvSource({&quot;1,1&quot;, &quot;2,2&quot;, &quot;3,Fizz&quot;, &quot;4,4&quot;, &quot;5,Buzz&quot;,&quot;6,Fizz&quot;,&quot;10,Buzz&quot;,&quot;15,FizzBuzz&quot;})<br>  void should_return_the_expected_string(int input, String expected) {<br>    assertThat(fizzbuzz.apply(input)).isEqualTo(expected);<br>  }<br>}</pre><p><em>tests results : </em>⛔️</p><pre>public class FizzBuzz {  <br>  <br>  public String apply(int input){</pre><pre>      if(input % 15 ==0)<br>        return &quot;FizzBuzz&quot;;<br>      if(input % 3 ==0)<br>        return &quot;Fizz&quot;;<br>      if(input % 5 ==0)<br>        return &quot;Buzz&quot;;<br>     <br>      return String.valueOf(input);<br>  }<br>}</pre><p><em>tests results : </em>✅</p><h4>iteration 9</h4><p>Add more tests.</p><pre>class FizzBuzzTest {</pre><pre>  FizzBuzz fizzbuzz = new FizzBuzz();</pre><pre>  @ParameterizedTest(name = &quot;should return {1} when input is {0}&quot;)<br>  @CsvSource({&quot;1,1&quot;, &quot;2,2&quot;, &quot;3,Fizz&quot;, &quot;4,4&quot;, &quot;5,Buzz&quot;,&quot;6,Fizz&quot;,&quot;10,Buzz&quot;,&quot;15,FizzBuzz&quot;,&quot;39,Fizz&quot;,&quot;45,FizzBuzz&quot;})<br>  void should_return_the_expected_string(int input, String expected) {<br>    assertThat(fizzbuzz.apply(input)).isEqualTo(expected);<br>  }<br>}</pre><p><em>tests results : </em>✅</p><h4>to summarize</h4><p>First we have a working, well tested, and “ready to production” implementation of FizzBuzz, second, as a side effect of TDD, the coverage is quite high, we covered a lot of use cases and this can help us refactor mercilessly our code. The tests being green is an absolute guarantee that our code has no error, It make us confident in test capacity to detect any potential regression.</p><p>Let’s refactor the code and make it better.</p><h3>refactoring</h3><h4>iteration 1</h4><p>First let’s get rid of the line with the number 15 in it, in the kata problem description the number ‘15’ is not mentioned once, it was our solution to return ‘FizzBuzz’ when the input number is a multiple of 3 and 5.</p><pre>public class FizzBuzz {  <br>  <br>  public String apply(int input){</pre><pre>      String value = &quot;&quot;;<br>      if(input % 3 == 0)<br>        value = &quot;Fizz&quot;;<br>      if(input % 5 == 0)<br>        value = value + &quot;Buzz&quot;;<br>      return value.isEmpty() ?  String.valueOf(input) :value;<br>  }<br>}</pre><p><em>tests results : </em>✅</p><h4>iteration 2</h4><p>Our code is better, but it still lacks an important property wich is extensibility.</p><p>Whenever the FizzBuzz requirement changes, we will need to edit and recompile the FizzBuzz class code, if this class was sealed in a jar, there will be no way to add or change behavior unless we inherit from it and change the whole implementation.</p><p>This class is closed to extension.</p><p>In the next refactoring steps we will try to reverse this tendency and make it open to extension.</p><pre>public class FizzBuzz {  <br>  <br>  Predicate&lt;Integer&gt; moduloThree= i -&gt; i % 3 ==0;<br>  String fizz = &quot;Fizz&quot;;<br>  <br>  Predicate&lt;Integer&gt; moduloFive= i -&gt; i % 5 ==0;<br>  String buzz = &quot;Buzz&quot;;<br>  <br>  public String apply(int input){</pre><pre>      String value=&quot;&quot;;<br>      if(moduloThree.test(input))<br>        value=fizz;<br>      if(moduloFive.test(input))<br>        value=value+ buzz;<br>      return value.isEmpty()?String.valueOf(input):value;<br>  }<br>}</pre><p><em>tests results : </em>✅</p><h4>iteration 3</h4><p>Let’s group the predicate with the associate replacement value.</p><pre>public class FizzBuzz {</pre><pre>ReplacementRule fizzReplacementRule=  new ReplacementRuleImpl(i -&gt; input % 3 ==0,&quot;Fizz&quot;);<br>  ReplacementRule buzzReplacementRule=  new ReplacementRuleImpl(i -&gt; input % 5 ==0,&quot;Buzz&quot;);<br> <br>  <br>  public String apply(int input){</pre><pre>String value=&quot;&quot;;<br>      if(fizzReplacementRule.appliable(input))<br>        value=fizzReplacementRule.getReplacement();<br>      if(buzzReplacementRule.appliable(input))<br>        value=value+ fizzReplacementRule.getReplacement();<br>      return value.isEmpty()?String.valueOf(input):value;<br>  }<br>}</pre><pre>public interface ReplacementRule {</pre><pre>boolean appliable(Integer i);</pre><pre>String  getReplacement();<br>}</pre><pre>public class ReplacementRuleImpl implements  ReplacementRule{</pre><pre>  private Predicate&lt;Integer&gt; rule;<br>  private Supplier&lt;String&gt; replacementSupplier;</pre><pre>  public ReplacementRuleImpl(Predicate&lt;Integer&gt; rule, Supplier&lt;String&gt;  replacementSupplier) {<br>    this.rule = rule;<br>    this.replacementSupplier = replacementSupplier;<br>  }</pre><pre>  public boolean appliable(Integer i) {<br>    return rule.test(i);<br>  }</pre><pre>  public String  getReplacement() {<br>    return replacementSupplier.get();<br>  }<br>}</pre><p><em>tests results : </em>✅</p><h4>iteration 4</h4><p>We can change the two replacement rules to a list of rules that we stream.</p><p>Each time the rule condition applies , we replace the input number with the correspondent replacement, then we concatenate all the returned strings.</p><pre>public class FizzBuzz {</pre><pre>  private List&lt;ReplacementRule&gt; replacementRules;</pre><pre>  public FizzBuzz() {<br>    this.replacementRules= List.of(<br>            new ReplacementRuleImpl(i -&gt; i % 3 == 0, () -&gt; &quot;Fizz&quot;),<br>            new ReplacementRuleImpl(i -&gt; i % 5 == 0, () -&gt; &quot;Buzz&quot;)<br>        );<br>  }</pre><pre>  public String apply(Integer i) {<br>    return replacementRules.stream()<br>        .filter(r -&gt; r.appliable(i))<br>        .map(ReplacementRule::getReplacement)<br>        .reduce(String::concat)<br>        .orElse(String.valueOf(i));<br>  }<br>}</pre><h4>iteration 5</h4><p>We can create a good level of abstraction for our replacement engine. by creating an interface, a default implementation, and a FizzBuzz implementation.</p><pre>public interface ReplacementEngine extends Function&lt;Integer, String&gt; {}</pre><pre>public class ReplacementEngineDefault implements ReplacementEngine {</pre><pre>private final List&lt;ReplacementRule&gt; replacementRules;</pre><pre>public ReplacementEngineDefault(List&lt;ReplacementRule&gt; replacementRules) {<br>    this.replacementRules = Collections.unmodifiableList(replacementRules);<br>  }</pre><pre>public String apply(Integer i) {<br>    return replacementRules.stream()<br>        .filter(r -&gt; r.appliable(i))<br>        .map(ReplacementRule::getReplacement)<br>        .reduce(String::concat)<br>        .orElse(String.valueOf(i));<br>  }<br>}</pre><pre>public class FizzBuzz extends ReplacementEngineDefault {</pre><pre>  public static final String FIZZ = &quot;Fizz&quot;;<br>  public static final String BUZZ = &quot;Buzz&quot;;</pre><pre>  public FizzBuzz() {<br>    super(<br>        List.of(<br>            new ReplacementRuleImpl(i -&gt; i % 3 == 0, () -&gt; FIZZ),<br>            new ReplacementRuleImpl(i -&gt; i % 5 == 0, () -&gt; BUZZ))<br>    );<br>  }<br>}</pre><p><em>tests results : </em>✅</p><h4>iteration 6</h4><p>Now our replacement engine implements the fizz buzz kata , but can be used in more complicated scenarios, our client code can inject behavior into different point, it can inject new replacement rules, to create a new engine from the default one, the code client can use a whole new specific implementation of the replacement engine if the default one is not as extensible as our client needs.</p><pre>class ReplacementEngineTest {</pre><pre>  ReplacementEngine fizzbuzz = new FizzBuzz();</pre><pre>  ReplacementEngine blabliOupla = new ReplacementEngineDefault(<br>      List.of(new ReplacementRuleImpl(i -&gt; i % 7 == 0, () -&gt; &quot;Bla&quot;)<br>          , new ReplacementRuleImpl(i -&gt; i % 8 == 0, () -&gt; &quot;Bli&quot;),<br>          new ReplacementRuleImpl(i -&gt; i == 100, () -&gt; &quot;Oupla&quot;)));</pre><pre>  @ParameterizedTest(name = &quot;should return {1} when input is {0}&quot;)<br>  @CsvSource({&quot;1,1&quot;, &quot;2,2&quot;, &quot;3,Fizz&quot;, &quot;4,4&quot;, &quot;5,Buzz&quot;, &quot;6,Fizz&quot;, &quot;10,Buzz&quot;, &quot;15,FizzBuzz&quot;,<br>      &quot;39,Fizz&quot;, &quot;45,FizzBuzz&quot;})<br>  void test_fizzBuzz(int input, String expected) {<br>    assertThat(fizzbuzz.apply(input)).isEqualTo(expected);<br>  }</pre><pre>  @ParameterizedTest(name = &quot;should return {1} when input is {0}&quot;)<br>  @CsvSource({&quot;1,1&quot;, &quot;2,2&quot;, &quot;3,3&quot;, &quot;4,4&quot;, &quot;5,5&quot;, &quot;7,Bla&quot;, &quot;56,BlaBli&quot;, &quot;100,Oupla&quot;, &quot;101,101&quot;})<br>  void test_for_bla_bli_blou(int input, String expected) {<br>    assertThat(blabliOupla.apply(input)).isEqualTo(expected);<br>  }</pre><pre>}</pre><p><em>tests results : </em>✅</p><h4>the FizzBuzz demo</h4><pre>public class MainClass {</pre><pre>  public static void main(String[] args) {<br>    new MainClass().fizzBuzzUseCase();<br>    System.out.println();<br>    new MainClass().extendedUseCase();<br>  }</pre><pre>  public void fizzBuzzUseCase() {<br>    ReplacementEngine fizzBuzz = new FizzBuzz();<br>    IntStream.range(1, 101).forEach(i -&gt; System.out.print(fizzBuzz.apply(i) + &quot; &quot;));<br>  }</pre><pre>  public void extendedUseCase() {<br>    ReplacementEngine moneyEngine = new ReplacementEngineDefault(<br>        List.of(<br>            new ReplacementRuleImpl(i -&gt; i % 10 == 0, () -&gt; &quot;Multiple of ten&quot;),<br>            new ReplacementRuleImpl(i -&gt; i == 100, () -&gt; &quot;This is the End&quot;)<br>        )<br>    );<br>    IntStream.range(1, 101).forEach(i -&gt; System.out.println(moneyEngine.apply(i)));<br>  }<br>  <br>}</pre><h3>Conclusion</h3><p>In this article we explored how <strong>TDD</strong>, can help us focus on what is needed.</p><p>We have seen how this simple practice helped us design our code, in this case, we designed FizzBuzz as a pure function, it then helped us refactor our code and validate that our refactoring iterations did not introduce any bugs.</p><p>In refactoring phases we used a simple <strong>SOLID</strong> technique, that made our core extensible, it helped us make not only working software, but also evolutionary and well-crafted software.</p><p><strong>Source code</strong> = <a href="https://github.com/mothmane/fizz-buzz-kata.git$">https://github.com/mothmane/fizz-buzz-kata.git</a></p><p><strong>Linkedin</strong> = <a href="https://linkedin.com/in/othmane-maniar-2364b518/"><em>https://linkedin.com/in/othmane-maniar-2364b518/</em></a></p><p><strong>Instagram</strong> =<a href="https://www.instagram.com/othmane_m/">https://www.instagram.com/othmane_m/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2ce366b6f71a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>