Maîtriser l'art : Compétences essentielles d'un ingénieur logiciel senior

Quand j’entends “Développeur Senior”, je pense à quelqu’un qui a maîtrisé la programmation. Je pense à une personne qui peut concevoir, coder et tester un système. Elle peut parler d’architecture système ou de conception de composants. Elle comprend et utilise les modèles de conception. Cette personne peut anticiper les goulots d’étranglement de performance, mais sait qu’il ne faut pas pré-optimiser. Cette personne exploitera la programmation asynchrone, les files d’attente, la mise en cache, la journalisation, la sécurité et la persistance quand c’est approprié. Quand on le lui demande, elle peut donner une explication détaillée de son choix ainsi que les avantages et inconvénients. Dans la plupart des cas, elle a maîtrisé la programmation et la conception orientées objet, ce qui n’est pas un absolu car d’autres langages comme javascript, F#, scheme sont puissants et ne sont pas orientés objet par nature. Elle est compétente en gestion des risques et plus important encore, elle peut communiquer tout ce qui précède à ses pairs.

Qu’est-ce que la maîtrise ? Il y a une idée généralement acceptée selon laquelle pour maîtriser N’IMPORTE QUELLE compétence, il faut 10 000 heures de répétition pour que le corps et l’esprit humains saisissent et intériorisent une compétence. Ceci est longuement développé dans le livre de Malcolm GladWell Outliers.

Quelques exemples dans Outliers de Malcolm GladWell sont :

Mozart son premier concerto au jeune âge de 21 ans. Ce qui semble jeune au premier abord, mais il compose de la musique depuis l’âge de 11 ans.

The Beatles ont été initialement rejetés. On leur a dit qu’ils n’avaient pas l’étoffe et qu’ils devraient considérer un autre métier. Ils ont passé 3 ans en Allemagne à jouer environ 1200 fois dans différents lieux, chaque fois pendant 5 à 8 heures. Ils ont refait surface en tant que Beatles que nous connaissons et aimons aujourd’hui.

Et enfin, Bill Gates à l’âge de 20 ans a quitté Harvard pour fonder Microsoft. Pour certains, cela pourrait sembler insensé, mais considérant qu’à 20 ans il avait passé près de la moitié de sa jeune vie à programmer. En 1975, peut-être seulement 50 personnes au monde avaient l’expérience qu’il avait. Son expérience lui a donné la clairvoyance pour voir l’avenir dans Microsoft.

Peter Norvig discute également de la règle des 10 000 heures dans son essai “Teach Yourself Programming in Ten Years”.

Dans le livre Mastery by George Leonard, de grands détails sont donnés sur comment maîtriser une compétence. On doit pratiquer la compétence encore et encore et encore. Plus il y a de répétition, plus on devient conscient des différences dans chaque répétition. Ce n’est qu’avec cette perspicacité qu’on peut s’améliorer.

Les titres de l’industrie logicielle (Junior, Niveau Intermédiaire et Senior) sont trompeurs et incohérents d’une organisation à l’autre. J’ai travaillé avec des entreprises qui définissaient un Développeur Senior comme quelqu’un qui avait 5 ans ou plus d’expérience. Il n’y a aucune mention de la qualité de l’expérience, juste qu’ils ont été assis devant un ordinateur pendant 5 ans. En travaillant avec ces personnes, beaucoup d’entre elles n’avaient pas encore saisi la programmation orientée objet, pourtant elles étaient considérées comme des Développeurs Senior.

Il doit y avoir une meilleure façon plus objective de mesurer les compétences d’un ingénieur logiciel. John Haugeland a créé une matrice de compétences pour programmeurs informatiques. Elle donne une façon commune et objective de mesurer le niveau de compétence d’un programmeur, qui autrement est laissé principalement à l’intuition.

En regardant les ingénieurs logiciels, je vois 4 niveaux de compétences : Luminaire, Senior, Niveau Intermédiaire et Junior.

Luminaire (10+ ans) est celui qui a maîtrisé une compétence et s’est mis à améliorer sa discipline respective. Quelques exemples incluent : Ted Neward, Uncle Bob Martin, Donald Knuth, Oren Eini, Peter Norvig, Linus Torvalds. Cela dépend de votre ensemble de compétences.

Senior (7 à 10+ ans, Niveau 3) est celui qui a passé les dernières 10 000 heures à programmer dans un genre spécifique. Il y a une forte compréhension des modèles de conception. Ils exploitent la programmation asynchrone, les files d’attente, la mise en cache, la journalisation, la sécurité et la persistance quand c’est approprié.

Il est très possible qu’un Senior n’atteigne jamais le niveau Luminaire. Les Luminaires se trouvent souvent en train de parler et d’écrire. Ils essaient activement d’impacter leur discipline.

Niveau Intermédiaire (4 à 6 ans, Niveau 2) est celui qui comprend la programmation au quotidien. Ils travaillent de manière indépendante et créent des solutions robustes. Cependant, ils n’ont pas encore l’expérience de créer ou maintenir des systèmes larges ou complexes. En général, les développeurs de Niveau Intermédiaire sont excellents avec le développement au niveau des composants.

Junior (1 à 3 ans, Niveau 1) est celui qui comprend les bases de la programmation. Ils ont soit un diplôme en ingénierie logicielle ou en informatique, soit ils sont autodidactes. Leur code est continuellement révisé. Des conseils sont donnés concernant les algorithmes, la maintenabilité et la structure.