Devops for Growth
107.5K views | +0 today
Follow
Devops for Growth
For Product Owners/Product Managers and Scrum Teams: Growth Hacking, Devops, Agile, Lean for IT, Lean Startup, customer centric, software quality...
Curated by Mickael Ruau
Your new post is loading...
Your new post is loading...

Popular Tags

Current selected tag: 'software craftmanship'. Clear
Scooped by Mickael Ruau
Scoop.it!

Technical agile coaching - Agile Boarding

Technical agile coaching - Agile Boarding | Devops for Growth | Scoop.it
Quelques questions sur mes motivations avant de lire ce livre.Coaching ou plutôt Mentoring technique ?Le terme coaching est employé à tors et à travers. L’intention est d’aider les autres à apprendre à résoudre des problèmes par eux-mêmes.
Mickael Ruau's insight:

Pour partager les valeurs et pratiques (techniques) des membres de l’équipe, quelques outils

  • le prélude à Scrum et son canvas, de Claude Aubry
  • l’Enveloppe culturelle minimale
No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Software Craftsmanship : Qu'est-ce ? · Sébastien Allemand Blog



La communauté d’acteurs du logiciel est composée de profil très différents, certains voient les “craftsman” comme des artisans qui pourraient avoir la tentation de se comporter en diva et de ne se concentrer uniquement sur leur “art”.

Robert C. Martin dans Bringing Balance to the force répond à ces fausses idées, en communiquant sur le fait que la pratique technique est un bon moyen pour répondre aux problèmes d’évolution et de sécurité d’une application. Situation souvent rencontré par les équipe agiles se concentrant peut-être un peu trop sur la méthode au détriment du reste.

Des échanges et points de vues intéressant qui permettent d'établir un ensemble de valeurs humaines et compétences techniques.
Des valeurs humaines

Humilité : une constante remise en question et recherche d’amélioration
Apprentissage: j’apprend en permanence de manière a mieux répondre aux besoins
Beaucoup de partage : Je tente de partager avec mes pairs mes expériences et découvertes
Pragmatisme : une compréhension des besoins et dans quel contexte ils s’inscrivent
Professionnalisme : Je traite mon clients comme un pair, je sais communiquer mes points de vues quand nécessaire.

Techniquement

Vision de la conception juste : tiny is beautiful.
Adhérence aux notion DDD & SOLID
Clean code
Refactoring
Techniques de testing.

Ou en sommes nous ?

En 2018, la philosophie des méthodes agile est plus présente dans les équipes. On observe globalement un changement de paradigme dans les échanges entre les acteurs projets. La culture craftsman est encore a construire et défendre au sein de ces équipes. Dans The Tragedy of Craftsmanship, Robert C. Martin (Uncle Bob) défend l’idée que le craftman n’occupe pas la place qu’il devrait et que les esprits ont encore besoin d’évoluer.
No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Revisiting Switch and If-then-else – DZone Web Dev | Mac Pro Tricks

Revisiting Switch and If-then-else – DZone Web Dev | Mac Pro Tricks | Devops for Growth | Scoop.it

Even Uncle Bob has addressed the subject. In npm alone, countless packages have been released to provide an alternative. People tend to think that the catch with Contact and if-then-else is that the more branches in your code, the more opportunities for untested and unexpected behavior. Each branch requires different use cases to be thoroughly tested, and although some tools, such as Istanbul, provide an indication of how many branches have been performed, in addition to the traditional feature coverage. But branches are part of the nature of programming, there is nothing we can do about it.

In this brief statement, I would like to give a new spin on when to use control structures and when to use some functional alternatives.

Mickael Ruau's insight:

 

Ever since I discovered Dr. Lamport’s Temporal Logic of Action, my programming style has changed to become more explicit about tasks versus mutations of the application mode and more aware of temporal logic. For me, there are three core patterns in programming: object-oriented programming, functional programming, and temporal programming. One developer should master all three and use them accordingly, no pattern wins over the other. We can not write good programs with only one pattern.

One of the key concepts in temporal programming is the concept control mode: when the light is off, and if the switch is in the off position, I can trip the light is on Or else check the switch (in bold we have actions as expected in a given control mode). These are extremely familiar concepts we use every day, but for some reason we rarely come across control mode in the code we write. My view of this is that the situation arose due to the lack of alternative constructions with a good enough developer experience, and partly due to the ease of use of the switch and if-so-otherwise, over the stringency required to use temporal programming constructions, but that discussion is for another article. I would like to focus here on something that is much simpler and more practical.

First, we must absolutely stop using these control structures for (complex) tasks, it leads to some pretty ugly code that is hard to read and debug. How many times have you written such a code? plain on, tell me in the comments …

How about a functional alternative?

No comment yet.
Scooped by Mickael Ruau
Scoop.it!

The Pragmatic Programmer

The Pragmatic Programmer | Devops for Growth | Scoop.it
“The Pragmatic Programmer” est une bible pour les développeurs. Il est l’œuvre d’Andrew Hunt et Dave Thomas d’après leurs expériences en tant que développeurs. Leur objectif est simple, faire du lecteur un Pragmatic Programmer, un développeur fier de son travail et qui utilise les meilleures techniques à sa disposition pour faire un travail de qualité.
Mickael Ruau's insight:


Pour le résumé de “The Pragmatic Programmer”, je vais reprendre les “tips” qui accompagne les 46 items.

Tips :

1. Care About Your Craft Pourquoi passer son temps à développer des logiciels si on ne prend pas le soin de le faire bien ?
2. Think! About Your Work Désactiver le pilote automatique et prenez le contôle. Ayez un sens critique et réévaluez constamment votre travail.
3. Provide Options, Don’t Make Lame Excuses Au lieu de fournir des excuses, proposez des solutions de contournement. Au lieu de dire que c’est impossible, expliquez ce qu’il est possible de faire à la place.
4. Don’t Live with Broken Windows Améliorer les mauvais choix de conception, les mauvaises décisions et le code “sale” quand vous tombez dessus.
5. Be a Catalyst for Change Vous ne pouvez pas imposer le changement aux personnes. Montrez leur plutôt comment pourrait être le futur et encouragez-les à participer à sa création.
6. Remember the Big Picture Ne restez pas le “nez dans le guidon” et levez la tête pour voir ce qui se passe autour de vous.
7. Make Quality a Requirements Issue Impliquez vos utilisateurs à définir le niveau réel de qualité du projet.
8. Invest Regularly in Your Knowledge Portfolio Apprendre doit devenir une habitude, un réflexe.
9. Critically Analyze What You Read and Hear Ne vous laisser pas influencer par les vendeurs, “buzzs” médiatiques, ou dogmes. Analyser les informations dans votre contexte et celui de votre projet.
10. It’s Both What You Say and the Way You Say It De bonnes idées ne sont rien sans une communication efficace.
11. DRY - Don’t Repeat Yourself Chassez la duplication. Chaque connaissance, au sens large, doit avoir une représentation unique, non ambigu et faisant référence pour tout le système.
12. Make It Easy to Reuse Si votre code est facilement réutilisable, il sera réutilisé. Créer un environnement qui encourage la réutilisabilité.
13. Eliminate Effects Between Unrelated Things Concevez des composants indépendants et qui ont un but unique et bien défini.
14. There Are No Final Decisions Aucune décision n’est gravé dans la pierre. Voyez-les plutôt comme inscrites dans du sable à la plage et préparez-vous aux changements.
15. Use Tracer Bullets to Find the Target L’utilisation de “balles traçantes” permet de raffiner vos idées en essayent des choses et en voyant comment elles se comportent en situation réelle.
16. Prototype to Learn Le prototypage est une expérience d’apprentissage. Sa valeur n’est pas dans le code que vous produisez mais dans les leçons que vous pouvez en tirer.
17. Program Close to the Problem Domain
Concevez et codez dans le langage de vos utilisateurs.
18. Estimate to Avoid Surprises
Estimer avant de commencer. Vous ferez remonter les problèmes potentiels à la surface
19. Iterate the Schedule with the Code
Utiliser l’expérience acquise au cours du projet pour affiner vos estimations.
20. Keep Knowledge in Plain Text
Contrairement à des formats fermés, le “plain text” ne peut devenir obsolète. De plus, il facilite le debuggage et les tests.
21. Use the Power of Command Shell
Ne sous-estimez pas la puissance des commandes Shell face aux interfaces graphiques.
22. Use a Single Editor Well
L’éditeur de texte devrait être une extension de vos mains. Assurez-vous que votre éditeur est configurable, extensible et programmable.
23. Always Use Source Code Control
Un gestionnaire de versions est une machine à voyager dans le temps pour votre travail : vous pouvez revenir dans le passé.
24. Fix the Problem, Not the Blame
Peu importe si un bug est votre faute ou celle d’un autre, ça reste toujours votre problème et il nécessite toujours d’être corrigé.
25. Don’t Panic When Debugging Prenez une grosse inspiration et réfléchissez sur la cause du bug.
26. “select” Isn’t Broken
Il est rare de trouver un bug dans le système d’exploitation ou dans le compilateur, ou même dans une bibliothèque tierce. Le problème est plus vraisemblablement dans l’application.
27. Don’t Assume It, Prove It
Prouver vos intuitions dans l’environnement du projet avec les données réelles et les conditions limites.
28. Learn a Text Manipulation Language
Vous passez la majeure partie de votre journée à travailler avec du texte. Pourquoi ne pas laisser l’ordinateur en faire un peu à votre place ?
29. Write Code That Writes Code
Les générateurs de code augmente votre productivité et évite la duplication d’information.
30. You Can’t Write Perfect SoftwareIl n’y a pas de logiciel parfait. Protéger votre code et les utilisateurs des inévitables erreurs.
31. Design with Contracts
Utiliser la notion de contrat comment documentation et pour vous assurer que votre code ne fasse ni plus ni moins que ce qu’il prétend.
32. Crash Early
Un programme mort fait normalement moins de dégât qu’un programme estropié.
33. Use Assertions to Prevent the Impossible
Une assertion valide vos hypothèses. Utilisez-les pour protéger votre code d’un monde incertain.
34. Use Exceptions for Exceptional ProblemsRéservez les exceptions aux choses exceptionnelles.
35. Finish What You Start
Quand c’est possible, une routine ou un objet qui alloue une ressource devrait aussi être responsable de sa désallocation.
36. Minimize Coupling Between Modules
Évitez le couplage en écrivant du code “timide” et en appliquant la Loi de Déméter.
37. Configure, Don’t IntegrateImplémentez les choix de technologies pour une application avec des options de configuration plutôt que par de l’intégration.
38. Put Abstractions in Code, Details in Metadata
Programmez pour le cas général et placer les spécificités en dehors du code compilé.
39. Analyze Workflow to Improve Concurrency
Utiliser la concurrence pour améliorer les flux de votre application.
40. Design Using Services
Concevez en termes de services : des objets indépendants, concurrents derrière des interfaces bien définies et cohérentes.
41. Always Design for ConcurrencyAutorisez l’accès concurrent et vous concevrez des interfaces plus propres avec moins d’hypothèses.
42. Separate Views from Models
Gagnez en flexibilité facilement en concevant vos applications en termes de modèles et de vues.
43. Use Blackboards to Coordinate Workflow
Utiliser des “tableaux noirs” permet de coordonner des faits et des agents très différents tout en maintenant l’indépendance et l’isolation des différents participants.
44. Don’t Program by Coincidence
Ne compter que sur des choses fiables. Méfiez-vous des complexités accidentelles et ne confondez pas une heureuse coïncidence avec un plan bien déterminé.
45. Estimate the Order of Your Algorithms
Ayez une idée de combien de temps vont prendre vos routines avant de les écrire.
46. Test Your Estimates
L’analyse mathématique de vos algorithmes ne vous dit pas tout. Essayez de mesurer votre code dans l’environnement cible.
47. Refactor Early, Refactor Often
Tout comme réarranger un jardin et enlever la mauvaise herbe, réécrivez, retravailler et revoyez l’architecture de votre code quand c’est nécessaire. Attaquez-vous à la racine du problème.
48. Design to Test
Commencer à réfléchir aux tests avant d’écrire la moindre ligne de code.
49. Test Your Software, or Your Users Will
Tester impitoyablement. Ne laissez pas les utilisateurs trouver les bugs pour vous.
50. Don’t Use Wizard Code You Don’t Understand
Les assistants peuvent générer des portions de code. Soyez sûr de les comprendre dans leur globalité avant de les intégrer dans votre projet.
51. Don’t Gather Requirements, Dig for Them
Les besoins émergent rarement tous seuls. Ils sont souvent enfouis sous des couches d’hypothèses, de méconnaissance et de politique.
52. Work with a User to Think Like a User
C’est la meilleure façon de voir comment un système est utilisé dans des conditions réelles.
53. Abstractions Live Longer than Details
Investissez dans l’abstraction, pas dans l’implémentation. Les abstractions peuvent survivre aux changements d’implémentations et de technologies.
54. Use a Project Glossary
Créez et maintenez une source unique de tous les termes et vocabulaire spécifiques au projet.
55. Don’t Think Outside the Box, Find the Box
Devant un problème impossible, identifiez les contraintes réelles. Demandez-vous : “Est-ce que ce doit être traité de cette façon ? Est-ce que ça doit être fait tout court ?”
56. Start When You’re Ready
Vous augmentez votre expérience toute votre vie. Ne sous-estimez pas vos doutes et votre petite voix intérieure.
57. Some Things Are Better Done than Described
Ne tombez pas dans la spirale de spécifications, à un moment il faut commencer à coder.
58. Don’t Be a Slave to Formal Methods
N’adoptez pas les yeux fermés n’importe quelle technique sans la confronter avec le contexte des pratiques et capacités de développement de votre projet.
59. Costly Tools Don’t Produce Better Designs
Méfiez-vous des super vendeurs, des dogmes de l’industrie et de l’aura des prix. Jugez les outils sur leurs mérites.
60. Organize Teams Around Functionality
Ne séparez pas les concepteurs des codeurs et des testeurs. Construisez vos équipes comme vous construisez votre code.
61. Don’t Use Manual Procedures
Un script exécutera les mêmes instructions dans le même ordre, jour après jour.
62. Test Early, Test Often, Test Automatically
Des tests joués à chaque “build” sont beaucoup plus efficaces que des plans de tests qui dorment sur une étagère.
63. Coding Ain’t Done Until All the Tests RunTout est dit !
64. Use Saboteurs to Test Your Testing
Placer des bugs volontairement dans une copie du code source pour vérifier que vous tests les capturent.
65. Test State Coverage, Not Code Coverage
Identifier et tester les états significatifs de votre programme. Tester seulement les lignes de code n’est pas suffisant.
66. Find Bugs Once
Une fois qu’un testeur humain trouve un bug, ça devrait la dernière fois qu’un humain trouve ce bug.
67. English is Just a Programming LanguageÉcrivez vos documents comme vous écrivez votre code : respectez le principe “DRY“, utilisez les metadata, MVC, génération automatique, etc
68. Build Documentation In, Don’t Bolt It On
La documentation écrite en dehors du code a peu de chance d’être correcte et à jour.
69. Gently Exceed Your Users’ Expectations
Commencez par comprendre les attentes de vos utilisateurs, et ensuite délivrez-leur à peine plus.
70. Sign Your Work
De tout temps, les artisans sont fiers de ce qu’ils produisent. Vous devriez l’être aussi.

No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Big Code : fléau ou bénédiction pour les développeurs ?

Big Code : fléau ou bénédiction pour les développeurs ? | Devops for Growth | Scoop.it


Un rapport* de Dimensional Research pour Sourcegraph met en exergue la croissance du volume et de la complexité du code que livrent les équipes de développement.

503 développeurs et responsables informatiques ont participé à l’enquête* américaine.

Plus de 9 répondants sur 10 considèrent que le volume et la variété du code ont fortement augmenté ces dix dernières années. Il en va de même de la pression exercée pour accélérer la fréquence de livraison applicative.

Interrogés sur l’évolution de la taille de la base de code dans toute leur entreprise, base mesurée en mégaoctets et en nombre de référentiels, 51% considèrent que le volume du code a été multiplié par 100 en 10 ans. 18% disent que ce volume est 500 fois plus élevé.

Par ailleurs, plus de 60% des professionnels constatent une « forte » ou « très forte » augmentation des plateformes et terminaux supportés et de l’utilisation de l’open source.

Code et dépendances

74% des répondants déclarent que leurs équipes retardent des changements dans le code car elles ne sont pas sûres des dépendances.
Mickael Ruau's insight:

Les difficultés les plus souvent citées concernent : le maintien d’un haut niveau de qualité (57%), la sécurité (51%), les retards de deploiement (49%) et la hausse redoutée des coûts (47%).

No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Fluent-API : Créer Un Code Plus Facile Et Plus Intuitif Avec Une API Fluent

Fluent-API : Créer Un Code Plus Facile Et Plus Intuitif Avec Une API Fluent | Devops for Growth | Scoop.it
Dans un monde où il est de plus en plus facile de rendre le code sûr et naturel, cela devient de plus en plus critique. Dans cet article, nous couvrirons un modèle qui rendra votre API naturelle, intuitive et sécurisée avec Fluent-API.
Mickael Ruau's insight:
 

Lorsque l'on parle dans le contexte du génie logiciel, une fluent-API est une API orientée objet dont la conception est largement basée sur le chaînage de méthodes.

Ce concept, créé en 2005 par Eric Evans et Martin Fowler, vise à augmenter la lisibilité du code en créant un langage spécifique au domaine (DSL).

En pratique, créer une API fluent, c'est développer une API dans laquelle il n'est pas nécessaire de mémoriser les prochaines étapes ou méthodes, permettant une séquence naturelle et continue comme s'il s'agissait d'un menu d'options.

 

Cette cadence naturelle fonctionne de la même manière qu'un restaurant ou même une chaîne de restauration rapide en ce sens que lorsque vous préparez un plat, les options varient en fonction des choix que vous faites. Si, par exemple, vous choisissez un sandwich au poulet, les accompagnements vous seront proposés en fonction du plat choisi et ainsi de suite.

No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Les 6 étapes à suivre pour le Software Craftsmanship / artisanat logiciel

Les 6 étapes à suivre pour le Software Craftsmanship / artisanat logiciel | Devops for Growth | Scoop.it
Découvrez quels sont nos conseils expérimentés pour mettre en place l'artisanat logiciel ou software craftsmanship
No comment yet.
Scooped by Mickael Ruau
Scoop.it!

the-craftsman-book/originals at master · jeremiahflaga/the-craftsman-book ·

the-craftsman-book/originals at master · jeremiahflaga/the-craftsman-book · | Devops for Growth | Scoop.it
Contains Uncle Bob's "The Craftsman" articles. I did nothing more than putting them in a single book to make it more accesible. All credit goes to Uncle Bob (Robert C. Martin) for creating such a wonderful story. - jeremiahflaga/the-craftsman-book
No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Software Craftsmanship 2011 Calendar | Blog

Software Craftsmanship 2011 Calendar | Blog | Devops for Growth | Scoop.it
The folks at NimblePros have put together a pretty sweet 2011 calendar showcasing principles of software craftsmanship and agile software development. The calendars are arriving from the printer today and should start shipping out over the next week or so to those who have pre-ordered them (or won them in the twitter contest, which lasts until 8 December 2010). Here’s my review of the calendar (before having an actual one in hand, mind you).
No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Game Programming Patterns

Game Programming Patterns | Devops for Growth | Scoop.it
Game Programming Patterns is a collection of patterns I found in games that make code cleaner, easier to understand, and faster.

This is the book I wish I had when I started making games, and now I want you to have it. It’s available in four formats
No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Craftsman possédez-vous la Triforce ?

Craftsman possédez-vous la Triforce ? | Devops for Growth | Scoop.it
Le but de cet article est de parler de Zelda de vous amener à réfléchir sur vous-même et d’identifier si vous êtes Craftsman ou non. Essayons ensemble d’aborder ce qu’est le mouvement Software Craftsmanship en faisant une petite introspection : Comment vous percevez-vous ? Comment percevez-vous votre métier ?

À la fin de cet article vous aurez, je l’espère, plus d’éléments pour savoir dans quel mesure vous êtes un artisan du logiciel.
No comment yet.
Scooped by Mickael Ruau
Scoop.it!

People who influenced the programming world series : Uncle Bob. – JArchitect Blog

People who influenced the programming world series : Uncle Bob. – JArchitect Blog | Devops for Growth | Scoop.it
No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Certified Scrum Developer® : Software Craftsmanship | AGILBEE

Certified Scrum Developer® : Software Craftsmanship | AGILBEE | Devops for Growth | Scoop.it
Mickael Ruau's insight:

 

Programme indicatif

 

Jour 1 Partie I. Scrum
  • Introduction à Scrum et aux Pratiques d’ingénierie logicielle Agile
  • Fonctionnement des 5 jours
  • Scrum
    • Transparence, introspection, adaptation et leadership
    • La science de Scrum
    • Atelier : Optimiser sa production
    • Scrum dans la pratique
    • Atelier : ScrumGame
    • Création et gestion du "Product Backlog"
    • Atelier : Le Product Backlog
Jour 2
  • Ecrire les User Stories et leurs tests de recette
    • Atelier : Création d'un projet
    • Atelier : Remanier les User Stories
  • Collaboration
    • Travailler ensemble comme une seule équipe
    • Inclure le client dans le processus
    • Atelier : Réunion quotidienne d'enfer
    • Définition of "Done"
    • Rétrospective
    • Principe du Pair Programming
    • Autre mode de collaboration
Jour 3 Partie II - Pratiques d’Ingénierie Agile Cette partie est réalisée dans un mode en immersion. Tout le contenu est réalisé en travaillant sur ordinateur.
  • Architecture et Conception
    • Principes d'architecture dans un environnement Agile
    • Pratique de Conception dans une équipe Agile
    • Principes qui permet d'amplifier facilement la testabilité et le Refactoring
  • Test Driven Development
    Etude du développement à base de "Test-First" incluant les concepts suivants :
    • Définition et Principes
    • Théorie et xUnit
    • Les 3A
    • Gérer les exceptions
Jour 4
  • Refactoring
    • Conception émergeante
    • Test Driven Design
    • Quand faut-il refactorer ?
    • Comment éviter les grandes dettes techniques
    • Refactoring pour la maintenance
  • Les meilleures practiques de Développement Agile
    • Conditions Limites
    • TDD et Gestion de base de données SGBDR
    • TDD et Gestion des données liées aux fichiers et aux repository (SVN, Git, Sourcesafe)
    • TDD et Gestion des IHM
  • Techniques avancées avec le TDD
    • Corriger des anomalies
    • Gérer la montée en charge et la sécurité des produits NTIC
    • Gestion de la sécurité logicielle
    • Gestion de la performance
    • Stress tests
  • Les objects Mock
    • Mock, Stub et Fake
    • Application de la théorie sans utiliser de bibliothèque
    • Découverte des bibliothèques du marché
Jour 5 : Sujet au choix
  • Self-Test et Outils collaboratifs
    • Intégration Continue (SVN, CVS, Sourcesafe)
    • Intégrateur Continu (Hudson, Cruisecontrol)
    • Couverture
    • Test Driven Requirement avec Fitnesse
    • Behaviour Driven Development
  • Immersion
    • TDD en environnement complexe avec Integration Continue et Test Driven Requirement (Fitnesse)
  • Coding Dojo
    • Behaviour Driven Development par la pratique
    • Gros refactoring par la pratique
    • Test Driven Requirement avec Fitnesse par la pratique
    • Scala et TDD pour les Développeurs Java
    • ASP.Net MVC 2 et TDD par la pratique
    • Spring et TDD par la pratique
    • C++ and TDD for .Net developers par la pratique
  • Agile Dojo
    • Agile Estimating and Planning dans la pratique : Simulation des Projets et Refactoring de UserStories
    • Facilitation et Practique
  • Conclusion
No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Agilité et-le-mal-agile tourbdx-27-10-2016

Presentation donnée à l'Agile Tour Bordeaux le 27/102016
No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Software Architecture is Overrated, Clear and Simple Design is Underrated

Software Architecture is Overrated, Clear and Simple Design is Underrated | Devops for Growth | Scoop.it


I had my fair share in designing and building large systems. I've taken part in rewriting Uber's distributed payment systems, designing and shipping Skype on Xbox One and open-sourcing RIBs, Uber's mobile architecture framework. All of these systems had thorough designs, going through multiple iterations and had lots of whiteboarding and discussion. The designs then boiled down to a design document that was circulated for more feedback before we started building.

All of these systems were large at scale: hundreds of developers build them - or on top of them - and they power systems used by millions of people per day. They were also not just greenfield projects. The payments system rewrite had to replace two, existing payments systems, used by tens of systems and dozens of teams, all without having any business impact. Rewriting the Uber app was a project that a few hundred engineers worked simultaneously on, porting existing functionality to a new architecture.

Let me start with a few things that might sound surprising. First, none of these designs used any of the standard software architecture planning tools. We did not use UML, nor the 4+1 model, nor ADR, nor C4, nor dependency diagrams. We created plenty of diagrams, but none of them followed any strict rules. Just plain old boxes and arrows, similar this one describing information flow or this one outlining class structure and relationships between components. Two diagrams within the same design document often had a different layout and were often added and modified by different engineers.

Second, there were no architects on the teams that owned the design. No IT architects or enterprise architects. True, neither Uber nor Skype/Microsoft have hands-off software architect positions. Engineers at higher levels, like staff engineers, are expected to still regularly code. For all the projects, we did have experienced engineers involved. However, no one person owned the architecture or design. While these experienced developers drove the design process, even the most junior team members were involved, often challenging decisions and offering other alternatives to discuss.

Third, we had practically no references to the common architecture patterns and other jargon referenced in common software architecture literature, such as Martin Fowler's architecture guide. No mentions of microservices, serverless architecture, application boundaries, event-driven architecture, and the lot. Some of these did come up during brainstormings. However, there was no need to reference them in the design documents themselves.
Mickael Ruau's insight:

The best software design is simple and easy to understand. The next time you're starting a new project, instead of thinking, "How will I architect this system, what battle-tested patterns should I use and what formal methodology should I document it with?", think "How can I come up with the simplest possible design, in a way that's easy for anyone to understand?".

Software architecture best practices, enterprise architecture patterns, and formalized ways to describe systems are all tools that are useful to know of and might come in handy one day. But when designing systems, start simple and stay as simple as you can. Try to avoid the complexity that more complex architecture and formal tools inherently introduce.

No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Summary of the book The Pragmatic Programmer by Andrew Hunt and David Thomas

Summary of the book The Pragmatic Programmer by Andrew Hunt and David Thomas | Devops for Growth | Scoop.it

This is my summary of the The Pragmatic Programmer, by Andrew Hunt and David Thomas. I use it while learning and as quick reference. It is not intended to be an standalone substitution of the book so if you really want to learn the concepts here presented, buy and read the book and use this repository as a reference and guide.

No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Java Is More Like English Than You Think - DZone Java

Java Is More Like English Than You Think - DZone Java | Devops for Growth | Scoop.it
As computer code is written by humans, languages must be easy on the brain. Similarities with human language may even predict something about their evolution.
No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Writing Clean Code: Naming - DZone Performance

Writing Clean Code: Naming - DZone Performance | Devops for Growth | Scoop.it
"One difference between a smart programmer and a professional programmer is that the professional understands that clarity is king. Professionals use their powers for good and write code that others can understand." - Clean Code: A Handbook of Agile Software Craftsmanship by Robert C Martin.
No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Software craftsmanship — Wikipédia

Software craftsmanship - Wikipédia

Le software craftsmanship (ou l'" artisanat du logiciel ") est une approche de développement de logiciels qui met l'accent sur les compétences de développement des développeurs. Il se propose comme une réponse aux maux récurrents de l'industrie du logiciel et à la tendance à l'externalisation, qui priorise les préoccupations financières avant la responsabilité du développeur.

No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Des Lego pour Apprendre les Pratiques Techniques

Des Lego pour Apprendre les Pratiques Techniques | Devops for Growth | Scoop.it
Expliquer les techniques de craft est compliqué, surtout au plus haut niveau de hiérarchie. La compréhension étant une des clés pour changer l'état d'esprit, et les pratiques techniques un pré requis pour créer du code de qualité, il est important de les expliquer. Mike Bowler a facilité un atelier à l'Agile Games Conference, montrant l'usage des Lego pour expliquer les pratiques techniques.
Mickael Ruau's insight:

 

L'atelier de Mike Bowler est le même que celui de Bryan Beecham. Ils le font d'habitude ensemble. L'atelier est plutôt simple à mener si vous comprenez les pratiques, bon marché (il vous faut des Lego), et très efficace : vous pouvez passer les pratiques principales en moins d'une heure. Les principales pratiques expliquées sont :

  • Le TDD
  • Le Pair Programming
  • Le Refactoring
  • La dette technique
  • L'Integration continue

L'atelier n'est pas Lego Serious Play (R)[LSP]. Vous pouvez trouver les instructions sur le site de Mike (la partie TDD devrait bientôt être en ligne).

L'atelier se déroule de la manière suivante :

  • Un peu d'échauffement avec la construction d'une maison et d'une personne : c'est un point structurant dans une démarche LSP pour favoriser la sécurité et l'engagement.
  • La première question venant après cela est le coût de la maison ou du personnage : combien de briques avez-vous ? Combien vous en faut-il vraiment ? Ces questions touchent la pensée Lean et le principe du "juste assez".
  • Mike introduit les TDD et Pair Programming : par deux, l'un écrit un test tandis que l'autre construit pour faire passer les tests.
  • La phase d'après touche au refactoring : tous les tests sont jetés, et sont relancés, en refactorant au fil de l'eau.
  • La partie Dette Technique est sans doute la plus drôle : Mike jette des tests les uns après les autres, et il faut construire pour les faire passer, sans enlever aucune des briques utilisées. Le résultat est... pas terrible. Pour comprendre la différence, Mike refait la même chose (en mélangeant les tests), en enlevant la contrainte. L'image du dessous montre la différence entre avec et sans dette technique.
  • La partie sur l'Intégration Continue est possible avec au moins trois équipes (et beaucoup de Lego) : chaque équipe doit construire quelque chose qui accueille le travail de l'équipe précédente. Evidemment, le premier résultat est peu en phase, et mieux le suivant.
No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Comment rendre un code legacy à nouveau maintenable | by Adrien Joly | shodo.io

Comment rendre un code legacy à nouveau maintenable | by Adrien Joly | shodo.io | Devops for Growth | Scoop.it
Le code legacy n’est pas une fatalité ! Avec Adrien Joly, découvrez quelques techniques pour maintenir votre legacy, ne plus avoir peur de modifier votre code et transformer le tout en défi passionnant !
No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Continuous delivery: Software craftsmanship is not enough

Continuous delivery: Software craftsmanship is not enough | Devops for Growth | Scoop.it
Establish an engineering mindset

I believe that our industry needs to take the next step on our journey. We have discovered techniques that work. We have data that shows that these techniques work better than other approaches. If we don't take this step at some point, a software disaster will happen on a bigger scale than the VW emissions scandal, and legislation will take over.

Let us take this into our own hands. We are the experts. Let us create a discipline of genuine software engineering and create better software, faster. And maybe along the way we will adopt a stronger sense of professional ethics to complement our more disciplined approach.

It is time to take back the term software engineering. Craftsmanship is not enough.
Mickael Ruau's insight:

Keep learning

No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Fiche de lecture : Clean Agile — Robert C. Martin (aka Uncle Bob) | by Mickaël Wegerich

Fiche de lecture : Clean Agile — Robert C. Martin (aka Uncle Bob) | by Mickaël Wegerich | Devops for Growth | Scoop.it
Après avoir lu Clean Code et Clean Architecture du même auteur, j’avais été déçu après la lecture du dernier. En effet, sur les 430 pages seulement quelqu’unes d’entres elles m’ont semblé…
No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Users - Excellent series of videos by Uncle Bob Martin

I think everyone can benefit from viewing this material:
 
 
Enjoy!
Alan
No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Le coach craftsmanship

Le coach craftsmanship | Devops for Growth | Scoop.it


On parle de plus en plus de tests unitaire, de TDD, de BDD, d’ATDD, de DDD… Si beaucoup de développeurs savent à peut prêt ce que veut dire ces termes, très peu sont capables de mettre ces techniques en place.

Et c’est là que nos coachs craftsmanships apparaissent ; ils vont aider ces équipes techniques à mettre la qualité technique au centre de leurs préoccupations. D’ailleurs, ils vont également accompagner la partie fonctionnelle à se familiariser avec ces notions car ils seront eux mêmes acteurs de celles-ci.

On parle de coachs car ils ne sont pas là pour imposer une panoplie de pratiques techniques mais ils sont là pour accompagner les équipes à trouver leur voix. En effet, c’est comparable à la posture du coach agile sur certains aspects sauf qu’il est très axé sur l’excellence technique.
No comment yet.