Quelle est la différence entre les développeurs Entry Level / Jr / Sr?
À part le titre et le salaire, quelle est la différence?
Quelles sont leurs différentes responsabilités.
Dans quelle mesure sont-ils bien informés/expérimentés?
Quelle est la mesure de base pour déterminer où un développeur s'inscrit dans cette structure de base?
Cela variera, mais c'est ainsi que je le vois à un endroit suffisamment grand pour faire la distinction entre les types de programmeurs.
Je dirais que le niveau d'entrée et Junior sont la même chose. Ils viennent juste de quitter l'école et ont moins de deux ans d'expérience professionnelle. Ils se voient confier les tâches les moins complexes et doivent être supervisés assez étroitement. En général, ils savent environ 10% de ce qu'ils pensent savoir. Habituellement, ils n'ont pas traversé tout le cycle de développement et font donc souvent des choix très naïfs s'ils ont la possibilité de choisir. Malheureusement, beaucoup d'entre eux ne se soucient pas réellement de la nécessité, ils veulent construire les choses à leur manière. Ils ont souvent de faibles capacités de débogage.
Le niveau intermédiaire est l'endroit où de nombreux programmeurs tombent. Ils ont plus de deux ans d'expérience et généralement moins de dix ans, bien que certains puissent rester à ce niveau toute leur carrière. Ils peuvent produire du code de travail avec moins de supervision tant qu'ils sont affectés à des tâches relativement routinières. Ils ne sont généralement pas chargés d'une conception de haut niveau ou de tâches très complexes qui nécessitent un niveau de connaissance approfondi. Ils peuvent être chargés de la conception d'une partie de l'application, d'autant plus qu'ils sont dans la zone pour devenir développeur senior. Ils sont bons dans les tâches de maintenance ou les tâches où ils peuvent se concentrer uniquement sur leur pièce du puzzle, mais ne sont généralement pas censés considérer l'application dans son ensemble, sauf s'ils travaillent avec des développeurs seniors ou sont préparés pour une promotion en tant que senior. Ils peuvent généralement faire un travail décent de dépannage et de débogage, mais ils doivent vraiment se frayer un chemin pour obtenir les plus difficiles. Ils n'ont pas encore suffisamment d'expérience pour voir les schémas des problèmes qui les indiquent à l'endroit probable où ils se produisent. Mais ils acquièrent ces compétences et ont rarement besoin de demander de l'aide pour le débogage. Ils ont probablement traversé tout le cycle de développement au moins une fois et ont vu les résultats des problèmes de conception et apprennent comment les éviter à l'avenir. Habituellement, ils ont tendance à être plus susceptibles de prendre une exigence à sa valeur nominale et de ne pas la repousser lorsqu'elle présente des problèmes ou des lacunes évidents. Ils ont suffisamment appris pour savoir ce qu'ils ne savent pas et commencent à acquérir ces connaissances. Ce sont les chevaux de bataille du monde de la programmation, ils fournissent probablement 80 à 90% du code de routine et peut-être 10% des choses très difficiles.
Personne de niveau supérieur n'a même besoin de poser cette question. Ils sont experts dans leurs piles technologiques choisies. On leur confie les tâches difficiles (celles que personne ne sait résoudre) et obtient souvent des responsabilités de conception. Ils travaillent souvent de manière indépendante car ils ont fait leurs preuves dans la livraison des marchandises. Ils devraient encadrer les développeurs juniors et intermédiaires. Ce sont souvent des dépanneurs incroyables. Ils ont déjà rencontré ces mêmes problèmes et ont une très bonne idée de l'endroit où chercher en premier. Les personnes âgées font souvent du mentorat en dehors du lieu de travail également. Ils ont généralement au moins dix ans d'expérience et ont presque toujours participé à au moins une marche de la mort et savent exactement pourquoi certaines choses doivent être évitées. Ils savent comment livrer un produit fonctionnel et respecter un délai. Ils savent quels coins peuvent être coupés et quels coins ne doivent jamais être coupés. Ils connaissent au moins une et souvent plusieurs langues au niveau expert. Ils ont vu beaucoup de "nouvelles technologies" arriver sur le lieu de travail et disparaître, ils ont donc tendance à être un peu plus conservateurs à propos de sauter dans le train pour le prochain nouvel outil de développement passionnant (mais pas complètement résistant au changement - ce serait le développeurs intermédiaires plus âgés qui ne font jamais le saut vers senior). Ils comprennent que leur travail consiste à fournir un logiciel fonctionnel qui fait ce que les utilisateurs veulent, pas à jouer avec des outils amusants. Ils sont souvent plus exigeants quant à l'endroit où ils travailleront parce qu'ils peuvent être et parce qu'ils ont vu de première main à quel point certains endroits peuvent être mauvais. Ils recherchent les endroits qui ont les tâches les plus intéressantes à faire. Souvent, ils en savent plus sur les produits de leur entreprise que quiconque, même s'ils ne sont là que depuis quelques mois. Ils savent qu'ils ont besoin de plus que des connaissances en programmation et sont également capables d'acquérir des connaissances sur le domaine commercial qu'ils prennent en charge. Ils sont souvent conscients de problèmes que les juniors ne prennent jamais en compte et les intermédiaires n'y pensent souvent pas, tels que les problèmes réglementaires et juridiques dans le domaine commercial qu'ils soutiennent. Ils peuvent et vont repousser une exigence parce qu'ils savent quels seront les problèmes et peuvent expliquer la même chose aux profanes.
Niveau d'entrée - doit leur donner des instructions explicites, vérifier tout ce qu'ils font, peu ou pas de responsabilité de conception, pas de responsabilité d'analyse
Junior - instructions moins explicites, moins de vérification, quelques responsabilités mineures de conception et d'analyse; aide les personnes débutantes à trouver le compilateur et à utiliser le référentiel
Senior - responsabilité principale de conception et d'analyse, devrait corriger les oublis par lui-même, peu/pas de vérification, peu/pas d'instructions; aide les personnes de niveau junior à apprendre/améliorer les compétences d'analyse et de conception
Vraiment, je pense que cela se résume à combien de temps vous avez été au travail. Si vous avez 10 ans d'expérience, vous êtes un développeur senior, si vous êtes diplômé, vous êtes probablement au niveau d'entrée. J'ai vu de nombreux développeurs "seniors" qui pouvaient à peine coder et ne savaient pas vraiment ce qu'ils faisaient et de nombreux développeurs juniors qui étaient fantastiques.
Je pense que les machines à sous d'apprenti, de compagnon et de maître de la vieille école s'intègrent bien dans ces machines à sous pour débutant, junior (ou tout simplement pas de préfixe) et senior.
Une personne débutante se voit confier des tâches relativement simples qui n'ont pas de conséquences profondes et son travail est contrôlé par un junior ou senior. Au fil du temps, ils obtiennent plus de responsabilités et se voient confier des tâches plus complexes, apprenant les cordes en cours de route.
À un junior (ou simplement la suppression de "niveau d'entrée"/"junior" du titre/description) vous avez terminé votre apprentissage et avez couvert les principaux domaines de développement de votre entreprise, après avoir plongé dans chaque domaine principal afin que vous soyez familier avec chacun d'eux. Vous aidez maintenant à fournir des conseils et des commentaires pour l'équivalent d'apprenti, mais votre propre travail est toujours examiné par le maître/senior, mais peut-être pas autant que lorsque vous étiez junior.
Avec le temps et la livraison de projets réussis, vous finissez par devenir senior. À un niveau supérieur, vous maîtrisez tout ce qui est couvert dans votre domaine, couvrant l'ensemble du processus de développement et tous les outils et technologies impliqués. Vous êtes autorisé à prendre des décisions techniques importantes et vous devez fournir des informations à la direction sur le processus de développement logiciel.
Donc, compte tenu de ces directives, vous devriez pouvoir regarder une personne ou un poste et déterminer dans lequel des trois bacs ils atterrissent.
Cela va se résumer aux attentes de l'entreprise envers le programmeur.
Si je suis la société d'embauche et que j'engage un programmeur débutant, je sais que cette personne ne sait presque rien et nous allons supposer qu'elle a besoin de tout apprendre. Si j'embauche une personne de niveau supérieur, en théorie, ils seront autonomes, d'un point de vue technique.
Cela dépend strictement de l'entreprise. Mais les mots sont assez évidents: le niveau d'entrée est quelqu'un qui vient juste d'entrer dans le domaine, junior est quelqu'un qui est au-delà du niveau d'entrée et connaît bien les technologies de quelques langues. Enfin, les seniors sont ceux qui sont les plus en charge du projet et qui siègent à un niveau supérieur. Ils peuvent généralement déléguer autant qu'ils codent.
Comme la plupart l'ont dit, cela varie d'une entreprise à l'autre et d'un emploi à l'autre.
Par exemple, j'ai travaillé une fois dans une entreprise qui considérait toute personne qui y travaillait depuis plus de 5 ans comme un "ingénieur logiciel principal". À l'autre extrême, un autre endroit où je travaillais avait très définitions strictes (et échelles de rémunération associées).
Certains endroits peuvent considérer "entrée de gamme" et "junior" comme signifiant la même chose.
Il peut varier en fonction d'années d'expérience, de connaissances générales, de connaissances spécifiques (c'est-à-dire de connaître les caractéristiques d'une certaine langue), d'expérience en gestion et/ou en leadership, toutes leurs combinaisons, et certainement bien plus encore.
Je vais aller avec la réponse vraiment simple ici: les développeurs seniors (en général) sont des gens qui peuvent voir la forêt pour les arbres. Ils pensent au-delà de la question immédiate devant leurs visages et ont une compréhension des changements architecturaux qui pourraient ou devraient se produire en corrigeant le problème auquel ils sont confrontés.
La plupart des éditeurs de logiciels que j'ai vus ont des personnes débutantes qui font le codage au jour le jour tandis que les développeurs principaux supervisent ce que font les nouvelles personnes et s'attaquent aux problèmes vraiment laids et épineux.
Évidemment, ce n'est que mon opinion, et non une règle stricte. YMMV.
En termes simples et à partir d'observations personnelles trouvées sur les sites d'offres d'emploi et uniquement en ce qui concerne les niveaux d'expérience.
Entrée = Votre nouveau probablement votre premier emploi.
Junior = Votre bien mais pas censé être le meilleur, vous aussi généralement avez moins de 5 ans et plus de 2 ans d'expérience.
Senior = Vous êtes censé être le meilleur et avez plus de 5 ans d'expérience.