Praktikum bei JetBrains und wie ich es fast geschafft hätte

Wie viele junge Entwickler schaue ich, wenn der Wunsch besteht, einen Job / ein Praktikum zu finden, in Richtung cooler IT-Unternehmen.

Kürzlich habe ich versucht, in die Reihen der JetBrains einzusteigen, und unter dem Schnitt bin ich bereit, meine Erfahrungen zu teilen.

Warum war es „fast“ erfolgreich?

Sicher haben Sie sofort eine solche Frage.

Meiner Meinung nach habe ich einen guten Lebenslauf mit einer Reihe von Erfolgen und guten Fähigkeiten, die ich in den letzten 8-9 Jahren Tag für Tag verbessert habe.

Ich habe die Testaufgabe abgeschlossen (und es scheint mir gut zu sein), zuvor das Büro von JB in meiner Stadt besucht, mit HH und einigen Entwicklern des Unternehmens gesprochen und als Ergebnis ein Praktikum ohne Kommentare verweigert.

Der Grund liegt höchstwahrscheinlich in der Tatsache, dass JetBrains Studenten ausschließlich für das Praktikum auswählt, und im Moment habe ich gerade den 11. abgeschlossen und die Prüfungen nacheinander bestanden.

Nun, dies ist eine Gelegenheit für ein weiteres ganzes Jahr, sich hochzuziehen und sich für das nächste Jahr zu bewerben.

Analyse der Testaufgabe

Die Fristen für die Einreichung von Bewerbungen für Praktika und das Testen von Testaufgaben sind abgelaufen. Dies bedeutet, dass jeder, der sie gelöst hat, einschließlich mir, eine Analyse dieser Aufgaben veröffentlichen kann, damit sich jeder interessierte Student im nächsten Jahr mit dem ungefähren Auftragsniveau vertraut machen kann, bevor er mit JB-Praktika beginnt dem er sich stellen muss und in welchem ​​Fall um sein Wissen zu sammeln.

Ich habe mich für ein Praktikum beim Corotin Debugger-Entwicklungsteam für Kotlin beworben.

Die Aufgabe dieses Teams während eines Praktikums für diejenigen, die es in diesem Jahr absolviert haben, wird es sein, diesen Teil des Debuggers und seine Integration in die IDE abzuschließen.

Die Aufgabe wurde ein wenig erwartet - einen Debugger für einen kleinen PL zu schreiben.

Ich würde nicht sagen, dass es komplex ist, eher das Gegenteil. Es erfordert keine gründlichen Kenntnisse der Theorie des Konstruierens von Übersetzern und eine coole Fähigkeit. Wer sich jedoch für ein Praktikum in diesem Bereich bewirbt, sollte zumindest über diese Grundlagen verfügen und diese Aufgabe problemlos bewältigen können. Ich war überrascht, als ich mich entschied, auf github nach Schlüsselwörtern für die Lösungen meiner "Konkurrenten" zu suchen und 1-2 mehr oder weniger funktionierende Lösungen gegen etwa 6-7 leere Repositories oder mit ein paar Codeteilen zu finden, nach denen die Leute aufgaben. Vielleicht sah ich schlecht aus, aber die Ergebnisse gefielen mir trotzdem nicht. Wenn dieser Beitrag von Personen gelesen wird, die diese Aufgabe aufgegeben haben, müssen Sie dies in Zukunft nicht mehr tun. Im Extremfall hat es gereicht, ein paar Tage auf der Aufgabe zu sitzen, und ich bin sicher, dass Sie sich damit befassen würden.


Ich schreibe in C ++, Java und Object Pascal.

Anfangs gab es Gedanken, alles in mein MPS zu schreiben, aber ich dachte, es wäre nicht sehr bequem, nach einem JB-Mitarbeiter zu suchen, und ich reichte den Antrag 2 Tage vor Abschluss der Einreichung ein (Prüfungen trotzdem ...), und Es war schon Abend vor dem Fenster - ich beschloss, schnell alles in bekannteren Sprachen zu schreiben.

Meiner Meinung nach eignet sich Pascal am besten zur Lösung des Problems, zumindest aufgrund der bequemsten Implementierung von Zeichenfolgen ...

Zumindest für mich. Außerdem ist es in TIOBE TOP 50, also habe ich mutig die IDE gestartet, nämlich Lazarus, weil Er ist nicht kommerziell :) und machte sich daran, das Problem zu lösen.

Trotz der Tatsache, dass sie JB bis zu 7 Tage Zeit geben, habe ich ungefähr eine Stunde gebraucht, um das Projekt abzuschließen, und es stellte sich heraus, dass das Projekt ungefähr 500 Codezeilen umfasste.

Wo soll ich anfangen?

Zunächst müssen Sie sich vorstellen, wie das Debuggen von Code letztendlich funktioniert.

Wir müssen die schrittweise Codeausführung implementieren - das heißt, jede Anweisung sollte in Form einer Struktur / Klasse dargestellt werden, und im Allgemeinen sollten die Anweisungen wie eine Liste dieser Klassen aussehen oder sich wie in meiner Implementierung aufeinander beziehen und eine Sequenz bilden (ich werde aufschreiben, warum ich es später getan habe).

Um diese Sequenz zu erhalten, muss unser Debugger den Code in der vorgeschlagenen Sprache verarbeiten. Dies bedeutet, dass wir auch einen kleinen Parser sowie eine syntaktische und semantische Analyse des Codes implementieren müssen.

Beginnen wir mit der Implementierung des Parsers. Weil Da die Guu-Sprache aus einer Reihe von Token besteht, die durch ein Leerzeichen getrennt sind, ist es logisch, zuerst einen kleinen und einfachen Tokenizer zu schreiben:

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; 

Als nächstes deklarieren Sie die Aufzählung der Token:

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

Und die Anweisungsklasse selbst, in die wir die Codezeilen analysieren werden:

 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; 

In OpType wird die Anweisung in OpArgs gespeichert - der Rest der Konstruktion.
OpLine, OpUnChangedLine - Informationen für den Debugger.

NextOp ist ein Zeiger auf die nächste Anweisung. Wenn es gleich nil ist (null in Pascal), gibt es keine weiteren Anweisungen und Sie müssen den Code vervollständigen oder über den Rückrufstapel zurückkehren.

OpReg ist ein kleines Zeigerregister, das später für eine kleine Optimierung der Codeausführung verwendet wird.

Nachdem die Klassendeklaration geschrieben wurde, entschied ich, dass die kompakteste und schönste Lösung darin bestehen würde, den Parser und ein wenig Analyse in seinem Konstruktor hinzuzufügen, was ich als nächstes tat:

 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; 

Hier überprüfen wir im Wesentlichen den Beginn der Konstruktion (d. H. Das erste Wort) und betrachten dann die verbleibenden Token und ihre Anzahl. Wenn etwas mit dem Code eindeutig nicht stimmt, wird ein Fehler angezeigt.

Im Hauptcode lesen wir einfach den Code in der TStringList aus der Datei, rufen die TGuuOp-Konstruktoren zeilenweise auf und speichern die Zeiger auf die Klasseninstanzen in GuuOps: TList.

Ankündigungen:

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

Zusammen mit der Code-Analyse wäre es schön, noch ein paar Aktionen auszuführen:

 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; 

Zu diesem Zeitpunkt können Sie die Einstiegspunkte zum Zeitpunkt der Neudefinition überprüfen und an OpReg denken. Ich habe damit einen Zeiger auf eine Guu-Variable gespeichert.

Apropos Variablen, ich habe diesen kleinen Code in eine separate Einheit gebracht:

 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. 

Jetzt haben wir Code analysiert, der in der Syntax korrekt zu sein scheint. Es bleibt zu analysieren, und Sie können beginnen, das Wichtigste auszuführen - das Debuggen.

Als nächstes müssen Sie eine kleine semantische Analyse implementieren und gleichzeitig alles für die Ausführung und das Debuggen von Code vorbereiten:

 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; 

Schreiben Sie in TGuuOp.NextOp jedes Tokens einen Zeiger auf das nächste Token.
Für den Anruf-Opcode machen wir es schwierig und einfach - in NextOp schreiben wir einen Zeiger auf den aufgerufenen Einstiegspunkt.

Wir überprüfen die Ausgabevariablen auch über die print-Anweisung ...

Vielleicht wurden sie nicht vor dem Abschluss angekündigt?

Jetzt müssen Sie die Codeausführung implementieren. Kehren Sie zur TGuuOp-Klasse zurück und implementieren Sie die Step-Methode:

 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; 

Um eine Zugriffsverletzung im Falle einer Schleife zu vermeiden, ist es besser, den Stapel zu begrenzen, was ich getan habe.
Die oben deklarierte Konstante STACK_SIZE = 2048 ist nur dafür verantwortlich.

Jetzt ist es endlich Zeit, den Hauptcode unseres Debuggers zu schreiben:

 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. 

Je nach Auftragsbedingung kann die Schnittstelle nach Ihren Wünschen implementiert werden.

Es wäre möglich, eine vollwertige Benutzeroberfläche zu implementieren und SynEdit mit dem Projekt zu verbinden, aber meiner Meinung nach ist es eine leere Arbeit, die die Fähigkeiten nicht widerspiegelt und außerdem nicht bezahlt wird :)

Also habe ich mich auf eine kleine Konsolen-Benutzeroberfläche beschränkt.

Der obige Code ist nicht kompliziert, daher können Sie ihn kommentarlos hinterlassen. Darin nehmen wir fertige TGuuOps und nennen sie Step.

Screenshots des gelösten Problems:





Ausgabe von Fehlerinformationen:





Link zum Repository meiner Lösung: Klicken Sie auf

Zusammenfassung

Es gibt keine besonderen Ergebnisse. Ich muss den größten Teil des Sommers einem geschäftigen Urlaub widmen und nach einer Universität suchen (na ja, falls ich die Prüfung natürlich gut bestehe), anstatt zwei Monate im JetBrains-Team zu arbeiten und zu trainieren.

Vielleicht erscheint nächstes Jahr ein neuer Beitrag bei Habré, der bereits den Praktikumsprozess bei JB oder in einem anderen für mich interessanten Unternehmen beschreibt :)