Stage chez JetBrains et comment j'ai failli y arriver

Comme beaucoup de jeunes développeurs, quand il y a un désir de trouver un emploi / stage, je regarde dans la direction des entreprises IT cool.

Récemment, j'ai essayé d'entrer dans les rangs de JetBrains et sous la coupe, je suis prêt à partager mon expérience.

Pourquoi «presque» a-t-il réussi?

Vous avez sûrement immédiatement une telle question.

À mon avis, j'ai un bon curriculum vitae avec un tas de réalisations et une bonne compétence, que j'améliore jour après jour les 8-9 dernières années.

J'ai terminé la tâche de test (et cela me semble bien), j'ai déjà visité le bureau de JB, qui est situé dans ma ville, parlé à HH et à certains développeurs de l'entreprise, et en conséquence, on m'a refusé un stage sans aucun commentaire.

Très probablement, la raison réside dans le fait que JetBrains sélectionne exclusivement les étudiants pour le stage, et pour le moment je viens de terminer le 11 et de passer les examens les uns après les autres.

Eh bien, c'est l'occasion pour une autre année entière de se relever et de postuler pour l'année suivante.

Analyse de la tâche de test

Les délais de soumission des demandes de stage et de test des devoirs de test sont dépassés, ce qui signifie que tous ceux qui les ont résolus, y compris moi, peuvent publier une analyse de ces missions afin que l'année prochaine tout étudiant intéressé puisse se familiariser avec le niveau approximatif des missions avant de commencer les stages JB, avec auquel il devra faire face et dans ce cas pour remonter ses connaissances.

J'ai postulé pour un stage avec l'équipe de développement du débogueur Corotin pour Kotlin.

La tâche de cette équipe lors d'un stage pour ceux qui l'ont touchée cette année sera de finaliser cette partie du débogueur et son intégration avec l'IDE.

La tâche était un peu attendue - écrire un débogueur pour un petit PL.

Je ne dirais pas que c'est complexe, bien au contraire. Il ne nécessite aucune connaissance approfondie de la théorie de la construction de traducteurs et une compétence cool. Mais néanmoins, ceux qui postulent pour un stage dans ce domaine devraient au moins avoir ces bases et faire face à cette tâche sans aucun problème. J'ai été surpris lorsque j'ai décidé de rechercher sur github des mots-clés les solutions de mes "concurrents" et trouvé 1-2 solutions plus ou moins fonctionnelles contre environ 6-7 référentiels vides ou avec quelques morceaux de code après quoi les gens ont abandonné. Peut-être que je regardais mal, mais néanmoins, les résultats ne m'ont pas plu. Si ce post sera lu par des personnes qui ont abandonné cette tâche - pas besoin de le faire à l'avenir. Dans un cas extrême, il suffisait de s'asseoir sur la tâche pendant quelques jours et je suis sûr que vous vous en occuperiez.


J'écris en C ++, Java et Object Pascal.

Au début, il y avait des pensées pour tout écrire dans mon même MPS, mais je pensais que ce ne serait pas très pratique de vérifier pour un employé JB, et j'ai soumis la candidature 2 jours avant la clôture de la soumission (examens tout de même ...), et c'était déjà le soir devant la fenêtre - j'ai décidé d'écrire rapidement tout dans des langues plus connues.

À mon avis, Pascal est le plus approprié pour résoudre le problème, au moins en raison de la mise en œuvre la plus pratique des chaînes ...

Du moins pour moi. De plus, il est dans TIOBE TOP 50, j'ai donc lancé hardiment l'IDE, à savoir Lazarus, car il n'est pas commercial :) et se mit à résoudre le problème.

Malgré le fait qu'ils donnent à JB jusqu'à 7 jours, cela m'a pris environ une heure pour terminer le projet, et le projet s'est avéré être environ 500 lignes de code.

Par où commencer?

Tout d'abord, vous devez imaginer comment le débogage de code fonctionnera à la fin.

Nous devons implémenter l'exécution de code étape par étape - cela signifie que chaque instruction doit être présentée sous la forme d'une structure / classe et, en général, les instructions doivent ressembler à une liste de ces classes ou, comme dans mon implémentation, se référer les unes aux autres formant une séquence (je noterai pourquoi je l'ai fait plus tard).

Pour obtenir cette séquence, notre débogueur doit traiter le code dans le langage proposé, ce qui signifie que nous devons également implémenter un petit analyseur, ainsi qu'une analyse syntaxique et sémantique du code.

Commençons par l'implémentation de l'analyseur. Parce que Étant donné que la langue Guu se compose d'un ensemble de jetons, séparés par un espace, il est logique d'écrire d'abord un petit et simple tokenizer:

function GetToken(s: string; tokenNum: word): string; var p: word; begin s := Trim(s); s := StringReplace(s, ' ', ' ', [rfReplaceAll]); while tokenNum > 1 do begin p := Pos(' ', s); if p > 0 then Delete(s, 1, p) else begin s := ''; break; end; dec(tokenNum); end; p := Pos(' ', s); if p > 0 then Delete(s, p, Length(s)); Result := s; end; 

Ensuite, déclarez l'énumération des jetons:

 type TGuuToken = (opSub, opSet, opCall, opPrint, opUnknown); const GuuToken: array[opSub..opPrint] of string = ( 'sub', 'set', 'call', 'print' ); 

Et la classe d'instruction elle-même, dans laquelle nous analyserons les lignes de code:

 type TGuuOp = class public OpType : TGuuToken; OpArgs : TStringList; OpLine : Cardinal; OpUnChangedLine: string; NextOp : TGuuOp; OpReg : Pointer; function Step(StepInto: boolean; CallBacks: TList; Trace: TStringList): TGuuOp; constructor Create(LineNum: Cardinal; Line:string); destructor Destroy; override; end; 

Dans OpType, l'instruction sera stockée, dans OpArgs - le reste de la construction.
OpLine, OpUnChangedLine - informations pour le débogueur.

NextOp est un pointeur vers l'instruction suivante. S'il est égal à nil (null en Pascal), il n'y a pas d'autres instructions et vous devez compléter le code ou retourner via la pile de rappel.

OpReg est un petit registre de pointeurs, qui sera utilisé plus tard pour une petite optimisation de l'exécution du code.

Après la déclaration de classe a été écrite - j'ai décidé que la solution la plus compacte et la plus belle serait d'ajouter l'analyseur et un peu d'analyse dans son constructeur, ce que j'ai fait ensuite:

 constructor TGuuOp.Create(LineNum: Cardinal; Line:string); (* * That method parse code line. *) var s: string; w: word; begin inherited Create; OpArgs := TStringList.Create; OpLine := LineNum; OpUnChangedLine := Line; NextOp := nil; OpReg := nil; s := GetToken(Line, 1); OpType := TGuuToken(AnsiIndexStr(s, GuuToken)); case OpType of opSub : begin // sub <name> s := GetToken(Line, 2); if Length(s) > 0 then OpArgs.Add(s) else begin writeln('[Syntax error]: Invalid construction "sub" at line ', OpLine, '.'); halt; end; if Length(GetToken(Line, 3)) > 0 then begin writeln('[Syntax error]: Invalid construction "', Line, '" at line ', OpLine, '.'); halt; end; end; opSet : begin // set <var> <value> OpArgs.Add(GetToken(Line, 2)); OpArgs.Add(GetToken(Line, 3)); w := 1; while w < Length(OpArgs[1]) + 1 do begin if not (OpArgs[1][w] in ['0'..'9']) then begin writeln('[Syntax error]: Invalid variable assigment "', Line, '" at line ', OpLine, '.'); halt; end; inc(w); end; if (Length(OpArgs[0]) = 0) or (Length(OpArgs[1]) = 0) or (Length(GetToken(Line, 4)) > 0) then begin writeln('[Syntax error]: Invalid construction "', Line, '" at line ', OpLine, '.'); halt; end end; opCall : begin // call <name> s := GetToken(Line, 2); if Length(s) > 0 then OpArgs.Add(s) else begin writeln('[Syntax error]: Invalid construction "call" at line ', OpLine, '.'); halt; end; if Length(GetToken(Line, 3)) > 0 then begin writeln('[Syntax error]: Invalid construction "', Line, '" at line ', OpLine, '.'); halt; end; end; opPrint: begin // print <var> s := GetToken(Line, 2); if Length(s) > 0 then OpArgs.Add(s) else begin writeln('[Syntax error]: Invalid construction "print" at line ', OpLine, '.'); halt; end; if Length(GetToken(Line, 3)) > 0 then begin writeln('[Syntax error]: Invalid construction "', Line, '" at line ', OpLine, '.'); halt; end; end; else begin writeln('[Syntax error]: Invalid token "', s, '" at line ', OpLine, '.'); halt; end; end; end; destructor TGuuOp.Destroy; begin FreeAndNil(OpArgs); inherited; end; 

Ici, nous vérifions essentiellement le début de la construction (c'est-à-dire le premier mot), puis regardons les jetons restants et leur nombre. Si quelque chose ne va clairement pas avec le code, nous affichons une erreur.

Dans le morceau de code principal, nous lisons simplement le code dans la TStringList du fichier, appelons les constructeurs TGuuOp ligne par ligne et enregistrons les pointeurs vers les instances de classe dans GuuOps: TList.

Annonces:

 var LabelNames: TStringList; GuuOps, GuuVars: TList; SubMain: TGuuOp = nil; 

Avec l'analyse de code, il serait intéressant d'effectuer quelques actions supplémentaires:

 procedure ParseNext(LineNum: Cardinal; Line: string); (* * Parsing code lines and define variables and labels. *) var Op: TGuuOp; GV: TGuuVar; c: cardinal; begin if Trim(Line) <> '' then begin Op := TGuuOp.Create(LineNum, Line); GuuOps.Add(Op); case Op.OpType of opSet: begin // define variable and/or optimisation var calling GV := nil; c := 0; while c < GuuVars.Count do begin if TGuuVar(GuuVars[c]).gvName = Op.OpArgs[0] then begin GV := TGuuVar(GuuVars[c]); break; end; inc(c); end; if GV = nil then begin GV := TGuuVar.Create(Op.OpArgs[0]); GuuVars.Add(GV); end; Op.OpReg := GV; end; opSub: begin // Check for label dublicade declaration if Op.OpArgs[0] = 'main' then SubMain := Op; if LabelNames.IndexOf(Op.OpArgs[0]) <> -1 then begin writeln('[Error]: Dublicate sub "', Op.OpArgs[0], '" declaration at line ', Op.OpLine, '.'); halt; end else LabelNames.Add(Op.OpArgs[0]); end; end; end; end; 

À ce stade, vous pouvez vérifier les points d'entrée au moment de la redéfinition et penser à OpReg - je l'ai utilisé pour stocker un pointeur sur une variable Guu.

En parlant de variables, j'ai pris ce petit morceau de code dans une unité distincte:

 unit uVars; {$mode objfpc}{$H+} interface uses Classes, SysUtils; type TGuuVar = class public gvName: string; gvVal: variant; constructor Create(VarName: string); end; implementation constructor TGuuVar.Create(VarName: string); begin inherited Create; gvName := VarName; gvVal := 0; end; end. 

Nous avons maintenant un code analysé qui semble être correct dans la syntaxe. Il reste à l'analyser et vous pouvez commencer à effectuer la chose la plus importante - le débogage.

Ensuite, vous devez implémenter une petite analyse sémantique et préparer simultanément tout pour l'exécution de code et le débogage:

 procedure CheckSemantic; (* * Semantic analyse and calls optimisation. *) var c, x: cardinal; op: TGuuOp; begin if GuuOps.Count > 0 then begin if TGuuOp(GuuOps[0]).OpType <> opSub then begin writeln('[Error]: Operation outside sub at line ', TGuuOp(GuuOps[0]).OpLine, '.'); halt; end; c := 0; while c < GuuOps.Count do begin case TGuuOp(GuuOps[c]).OpType of opSub:; opCall: begin TGuuOp(GuuOps[c - 1]).NextOp := TGuuOp(GuuOps[c]); x := 0; op := nil; while x < GuuOps.Count do begin if TGuuOp(GuuOps[x]).OpType = opSub then if TGuuOp(GuuOps[x]).OpArgs[0] = TGuuOp(GuuOps[c]).OpArgs[0] then begin op := TGuuOp(GuuOps[x]); break; end; inc(x); end; if op <> nil then TGuuOp(GuuOps[c]).OpReg := op else begin writeln('[Error]: Calling to not exist sub "', TGuuOp(GuuOps[c]).OpArgs[0], '" at line ', TGuuOp(GuuOps[c]).OpLine, '.'); halt; end; end; opPrint: begin TGuuOp(GuuOps[c - 1]).NextOp := TGuuOp(GuuOps[c]); x := 0; while x < GuuVars.Count do begin if TGuuVar(GuuVars[x]).gvName = TGuuOp(GuuOps[c]).OpArgs[0] then begin TGuuOp(GuuOps[c]).OpReg := TGuuVar(GuuVars[x]); break; end; inc(x); end; if TGuuOp(GuuOps[c]).OpReg = nil then begin writeln('[Error]: Variable "', TGuuOp(GuuOps[c]).OpArgs[0], '" for print doesn''t exist at line ', TGuuOp(GuuOps[c]).OpLine, '.'); end; end; else TGuuOp(GuuOps[c - 1]).NextOp := TGuuOp(GuuOps[c]); end; inc(c); end; end; end; 

Dans TGuuOp.NextOp de chaque jeton, écrivez un pointeur sur le jeton suivant.
Pour l'opcode call, nous le faisons délicat et simple - dans NextOp, nous écrivons un pointeur vers le point d'entrée appelé.

Nous vérifions également les variables de sortie via l'instruction print ...

Peut-être qu'ils n'ont pas été annoncés avant la conclusion?

Vous devez maintenant implémenter l'exécution de code. Revenez à la classe TGuuOp et implémentez la méthode Step:

 function TGuuOp.Step(StepInto: boolean; CallBacks: TList; Trace: TStringList): TGuuOp; (* * That method execute instruction. *) var Op: TGuuOp; CBSize: Cardinal; begin case OpType of opSub: begin Trace.Add('-> Sub "' + OpArgs[0] + '"'); Result := NextOp; end; opCall: begin if StepInto then begin if NextOp <> nil then CallBacks.Add(NextOp); Result := TGuuOp(OpReg); end else begin Op := TGuuOp(OpReg); CBSize := CallBacks.Count; while ((Op <> nil) or (CallBacks.Count > CBSize)) and (Trace.Count < STACK_SIZE) do begin if Op = nil then begin Op := TGuuOp(CallBacks[CallBacks.Count - 1]); CallBacks.Delete(CallBacks.Count - 1); Trace.Delete(Trace.Count - 1); end; Op := Op.Step(StepInto, CallBacks, Trace); end; Result := NextOp; end; end; opPrint: begin writeln(TGuuVar(OpReg).gvName, ' = ', TGuuVar(OpReg).gvVal); Result := NextOp; end; opSet: begin TGuuVar(OpReg).gvVal := OpArgs[1]; Result := NextOp; end; end; end; 

Pour éviter la violation d'accès en cas de boucle - il est préférable de limiter la pile, ce que j'ai fait.
La constante STACK_SIZE = 2048, déclarée ci-dessus est juste responsable de cela.

Il est maintenant temps d'écrire le code principal de notre débogueur:

 var code: TStringList; c: Cardinal; cmd: string; CallBacks: TList; Trace: TStringList; DebugMode: boolean = true; begin if ParamCount > 0 then begin // Initialisation if not FileExists(ParamStr(1)) then begin writeln('[Error]: Can''t open file "', ParamStr(1), '".'); halt; end; if ParamCount > 1 then if LowerCase(ParamStr(2)) = '/run' then DebugMode := false; code := TStringList.Create; code.LoadFromFile(ParamStr(1)); GuuOps := TList.Create; GuuVars := TList.Create; // Parsing and preparing LabelNames := TStringList.Create; c := 0; while c < code.Count do begin ParseNext(c + 1, Trim(code[c])); inc(c); end; FreeAndNil(LabelNames); CheckSemantic; if SubMain = nil then begin writeln('[Error]: Sub "main" doesn''t exist!'); halt; end; // Start code execution CurrentOp := SubMain; CallBacks := TList.Create; Trace := TStringList.Create; if DebugMode then begin //Out code and features ClrScr; writeln('Code for debugging:'); writeln('.....'); c := 0; while c < code.Count do begin writeln(FillSpaces(IntToStr(c + 1), 4), '| ', code[c]); inc(c); end; writeln('"""""'); FreeAndNil(code); writeln(sLineBreak, 'Features:', sLineBreak, '* i - step into.', sLineBreak, '* o - step over.', sLineBreak, '* trace - print stack trace.', sLineBreak, '* var - print variables list.', sLineBreak, '* x - exit.', sLineBreak); // Execution loop while ((CurrentOp <> nil) or (CallBacks.Count > 0)) and (Trace.Count < STACK_SIZE) do begin write('Line ', CurrentOp.OpLine, ' ~> '); readln(cmd); // Execute commands if cmd = 'i' then CurrentOp := CurrentOp.Step(true, CallBacks, Trace) else if cmd = 'o' then CurrentOp := CurrentOp.Step(false, CallBacks, Trace) else if cmd = 'trace' then begin writeln('| Trace:'); c := 0; while c < Trace.Count do begin writeln('| ', Trace[c]); inc(c); end; writeln('| -> Line ', CurrentOp.OpLine, ': "', CurrentOp.OpUnChangedLine, '".') end else if cmd = 'var' then begin writeln('| Variables list:'); c := 0; while c < GuuVars.Count do begin writeln('| ', TGuuVar(GuuVars[c]).gvName, ' = ', TGuuVar(GuuVars[c]).gvVal); inc(c); end; end else if cmd = 'x' then halt; // Check for method end & make callback if (CurrentOp = nil) and (CallBacks.Count > 0) then begin CurrentOp := TGuuOp(CallBacks[CallBacks.Count - 1]); CallBacks.Delete(CallBacks.Count - 1); Trace.Delete(Trace.Count - 1); end; end; end else begin // Only run mode (/run) FreeAndNil(code); while ((CurrentOp <> nil) or (CallBacks.Count > 0)) and (Trace.Count < STACK_SIZE) do begin CurrentOp := CurrentOp.Step(false, CallBacks, Trace); if (CurrentOp = nil) and (CallBacks.Count > 0) then begin CurrentOp := TGuuOp(CallBacks[CallBacks.Count - 1]); CallBacks.Delete(CallBacks.Count - 1); Trace.Delete(Trace.Count - 1); end; end; end; if Trace.Count >= STACK_SIZE then writeln('[Runtime error]: Stack overflow!'); FreeAndNil(CallBacks); FreeAndNil(Trace); end else writeln( 'Guu debugger v1.0.', sLineBreak, 'Author: Pavel Shiryaev (@RoPi0n).', sLineBreak, 'Run: svmc guu_debugger.vmc <guu source file> [arg]', sLineBreak, 'Args:', sLineBreak, ' /run - Run Guu code.' ); end. 

Selon l'état du travail, l'interface peut être implémentée comme vous le souhaitez.

Il serait possible d'implémenter une interface utilisateur à part entière, visser SynEdit au projet, mais à mon avis, c'est un travail vide qui ne reflétera pas la compétence, et en plus il ne sera pas payé :)

Je me suis donc limité à une petite interface utilisateur de console.

Le code ci-dessus n'est pas compliqué, vous pouvez donc le laisser sans commentaire. Dans ce document, nous prenons des TGuuOp prêts à l'emploi et les appelons Step.

Captures d'écran du problème résolu:





Sortie d'informations d'erreur:





Lien vers le référentiel de ma solution: cliquez sur

Résumé

Il n'y a pas de résultats particuliers. Je vais devoir consacrer la majeure partie de l’été à des vacances bien remplies et chercher une université (enfin, au cas où je réussirais bien l’examen, bien sûr), au lieu de deux mois de travail et de formation dans l’équipe JetBrains.

Peut-être que l'année prochaine un nouveau billet apparaîtra sur Habré, décrivant déjà le processus de stage chez JB ou dans une autre entreprise qui m'intéresse :)