🤛 🌯 🏛️ JetBrains में इंटर्नशिप और मैं इस पर पाने में लगभग कैसे कामयाब रहा 🐖 ☃️ 🧑🏿‍🤝‍🧑🏼

कई युवा डेवलपर्स की तरह, जब नौकरी / इंटर्नशिप खोजने की इच्छा होती है, तो मैं शांत आईटी कंपनियों की दिशा में देखता हूं।

हाल ही में मैंने JetBrains के रैंक में जाने की कोशिश की और कट के तहत मैं अपना अनुभव साझा करने के लिए तैयार हूं।

"लगभग" सफल क्यों हुआ?

निश्चित रूप से आपके पास तुरंत ऐसा प्रश्न है।

मेरी राय में, मेरे पास उपलब्धियों के एक समूह और एक अच्छे कौशल के साथ एक अच्छा फिर से शुरू है, जिसे मैं पिछले 8-9 वर्षों से दिन-प्रतिदिन सुधार रहा हूं।

मैंने परीक्षण कार्य पूरा किया (और यह मुझे अच्छा लगता है), पहले जेबी के कार्यालय का दौरा किया, जो मेरे शहर में स्थित है, एचएच और कंपनी के कुछ डेवलपर्स से बात की, और परिणामस्वरूप किसी भी टिप्पणी के बिना इंटर्नशिप से इनकार कर दिया गया था।

सबसे अधिक संभावना है, कारण इस तथ्य में निहित है कि JetBrains विशेष रूप से इंटर्नशिप के लिए छात्रों का चयन करता है, और फिलहाल मैंने सिर्फ 11 वीं से स्नातक किया है और एक के बाद एक परीक्षाएं पास करता है।

खैर, यह एक और पूरे वर्ष के लिए खुद को खींचने और अगले वर्ष के लिए आवेदन करने का एक अवसर है।

परीक्षण कार्य का विश्लेषण

इंटर्नशिप और परीक्षण परीक्षण असाइनमेंट के लिए आवेदन जमा करने की समय सीमा समाप्त हो गई है, जिसका अर्थ है कि हर कोई, जिन्होंने मुझे भी हल किया है, इन असाइनमेंट का विश्लेषण पोस्ट कर सकते हैं ताकि अगले वर्ष कोई भी इच्छुक छात्र जेबी इंटर्नशिप शुरू करने से पहले असाइनमेंट के अनुमानित स्तर के साथ खुद को परिचित कर सके। जिसका सामना उसे करना होगा और किस मामले में अपना ज्ञान बढ़ाना होगा।

मैंने कोटलिन के लिए कोरोटिन डिबगर विकास टीम के साथ इंटर्नशिप के लिए आवेदन किया।

इस साल इसे मारने वालों के लिए एक इंटर्नशिप के दौरान इस टीम का कार्य डिबगर के इस हिस्से और आईडीई के साथ इसके एकीकरण को अंतिम रूप देना होगा।

यह कार्य थोड़ा अपेक्षित था - एक छोटे पीएल के लिए डिबगर लिखने के लिए।

मैं यह नहीं कहूंगा कि यह जटिल है, बल्कि विपरीत है। अनुवादक और एक शांत कौशल के सिद्धांत के किसी भी गहन ज्ञान की आवश्यकता नहीं है। लेकिन फिर भी, जो लोग इस क्षेत्र में इंटर्नशिप के लिए आवेदन करते हैं, उन्हें कम से कम ये मूल बातें होनी चाहिए और बिना किसी समस्या के इस कार्य का सामना करना चाहिए। मुझे आश्चर्य हुआ जब मैंने अपने "प्रतियोगियों" के समाधान के कीवर्ड के लिए जीथब पर खोज करने का फैसला किया और लगभग 6-7 खाली रिपॉजिटरी के खिलाफ या कोड के कुछ टुकड़ों के साथ 1-2 से अधिक काम करने वाले समाधान ढूंढे, जिसके बाद लोगों ने हार मान ली। शायद मैं बुरी तरह से देख रहा था, लेकिन फिर भी, परिणाम मुझे खुश नहीं करते थे। यदि इस पोस्ट को उन लोगों द्वारा पढ़ा जाएगा जिन्होंने इस कार्य को छोड़ दिया है - भविष्य में ऐसा करने की कोई आवश्यकता नहीं है। एक चरम मामले में, कुछ दिनों के लिए कार्य पर बैठना पर्याप्त था और मुझे यकीन है कि आप इससे निपटेंगे।

स्वयं खोज का पाठ

उद्देश्य: तुच्छ प्रोग्रामिंग भाषा गुओ के लिए चरण-दर-चरण कोड क्रियान्वयन लागू करें।

ध्यान दें: नीचे दिए गए विवरण में, कुछ महत्वपूर्ण बिंदुओं को जानबूझकर छोड़ा गया है। एक नियम के रूप में, वे आपके विवेक पर बने रहते हैं। यदि यह पूरी तरह से समझ से बाहर है, तो (यहां वह मेल लिखें जिसे मैंने हटाने का फैसला किया है)।

एक गुओ कार्यक्रम में प्रक्रियाओं का एक सेट होता है। प्रत्येक प्रक्रिया लाइन सब (सबनाम) के साथ शुरू होती है और किसी अन्य प्रक्रिया की घोषणा के साथ समाप्त होती है (या फ़ाइल का अंतिम यदि प्रक्रिया अंतिम है)। निष्पादन उप मुख्य के साथ शुरू होता है।

एक प्रक्रिया का शरीर निर्देशों का एक सेट है, जिनमें से प्रत्येक एक अलग लाइन पर है। एक पंक्ति की शुरुआत में महत्वहीन टैब या स्थान हो सकते हैं। खाली लाइनों की अनदेखी की जाती है। Guu पर कोई टिप्पणी नहीं है।

गुओ के केवल तीन ऑपरेटर हैं: - सेट (varname) (नया मूल्य) - चर के लिए एक नया पूर्णांक मान सेट करना। - कॉल (सबनाम) - प्रक्रिया को बुलाओ। कॉल पुनरावर्ती हो सकते हैं। - प्रिंट (varname) - स्क्रीन पर वैरिएबल के मान को प्रिंट करें।

गुओ में चर के लिए एक वैश्विक गुंजाइश है। नीचे दिया गया प्रोग्राम लाइन a = 2 प्रदर्शित करेगा।

उप मुख्य
सेट 1
फू को बुलाओ
प्रिंट करें

उप फू
2 सेट करें

और यहाँ अनंत पुनरावृत्ति के साथ सबसे सरल कार्यक्रम है:

उप मुख्य
मुख्य बुलाओ

आपको गुओ के लिए चरण-दर-चरण दुभाषिया लिखने की आवश्यकता है। जब यह शुरू होता है, तो डिबगर को उप मुख्य निर्देश में पहले निर्देश के साथ लाइन पर रुकना चाहिए और उपयोगकर्ता से कमांड का इंतजार करना चाहिए। डीबगर कमांड का न्यूनतम आवश्यक सेट:

i - चरण में, डिबगर कॉल (सबनाम) के अंदर जाता है।
ओ - स्टेप ओवर, डिबगर कॉल के अंदर नहीं जाता है।
ट्रेस - प्रिंट स्टैक ट्रेस का निष्पादन मुख्य से शुरू होने वाली लाइन नंबरों के साथ ...
var - सभी घोषित चर के प्रिंट मूल्य।

डिबगर के साथ उपयोगकर्ता का संचार प्रारूप ऊपर के विवेक पर छोड़ दिया जाता है। आप या तो एक न्यूनतर GDB- जैसा इंटरफ़ेस या एक कंसोल या ग्राफ़िकल UI चुन सकते हैं। यदि वांछित हो तो डिबगर कमांड के नाम बदले जा सकते हैं।

इस समस्या को हल करने के लिए, आप TIOBE TOP 50 और ओपन-सोर्स कंपाइलर / दुभाषिया से किसी भी प्रोग्रामिंग भाषा का उपयोग कर सकते हैं।

काम का मूल्यांकन करते समय मूल्यांकन किया जाएगा:

कार्यक्रम का समग्र प्रदर्शन;
स्रोत कोड की गुणवत्ता और परीक्षणों की उपलब्धता;
कार्यक्षमता का विस्तार करना आसान है (उदाहरण के लिए, नए भाषा बयान या डिबगर निर्देशों के लिए समर्थन)।
इसे बनाने के निर्देशों के साथ एक समाधान गिट रिपॉजिटरी (उदाहरण के लिए, गिटहब या बिटबकेट) पर प्रकाशित किया जाना चाहिए। प्रतिक्रिया में आपको रिपॉजिटरी का लिंक निर्दिष्ट करना होगा। एक निजी GitHub रिपॉजिटरी का लिंक भी उपयुक्त है, केवल आपको मुझे इसमें जोड़ना होगा।

मैं सी ++, जावा और ऑब्जेक्ट पास्कल में लिखता हूं।

सबसे पहले मेरे उसी एमपीएस में सब कुछ लिखने के लिए विचार थे, लेकिन मुझे लगा कि जेबी कर्मचारी के लिए जांच करना बहुत सुविधाजनक नहीं होगा, और मैंने सबमिशन के समापन से 2 दिन पहले आवेदन जमा किया (परीक्षा सभी एक ही ...), और यह खिड़की के बाहर पहले से ही शाम थी - मैंने जल्दी से अधिक प्रसिद्ध भाषाओं में सब कुछ लिखने का फैसला किया।

मेरी राय में, पास्कल समस्या को हल करने के लिए सबसे उपयुक्त है, कम से कम स्ट्रिंग्स के सबसे सुविधाजनक कार्यान्वयन के कारण ...

कम से कम मेरे लिए। इसके अलावा, यह TIOBE TOP 50 में है, इसलिए मैंने साहसपूर्वक IDE, अर्थात् लाजर को लॉन्च किया, क्योंकि वह वाणिज्यिक नहीं है :) और समस्या को हल करने के बारे में निर्धारित किया है।

इस तथ्य के बावजूद कि वे जेबी को 7 दिन देते हैं, इस परियोजना को पूरा करने में मुझे लगभग एक घंटे का समय लगा, और यह परियोजना लगभग 500 लाइनों का कोड थी।

कहाँ से शुरू करें?

सबसे पहले, आपको यह कल्पना करने की आवश्यकता है कि अंत में कोड डीबगिंग कैसे काम करेगा।

हमें चरण-दर-चरण कोड निष्पादन को लागू करने की आवश्यकता है - इसका मतलब है कि प्रत्येक निर्देश को एक संरचना / वर्ग के रूप में प्रस्तुत किया जाना चाहिए और सामान्य तौर पर, निर्देशों को इन वर्गों की सूची की तरह दिखना चाहिए या, जैसा कि मेरे कार्यान्वयन में, एक अनुक्रम बनाने के लिए एक दूसरे को देखें (मैं लिखूंगा कि मैंने इसे बाद में क्यों किया था)।

इस अनुक्रम को प्राप्त करने के लिए, हमारे डिबगर को प्रस्तावित भाषा में कोड को संसाधित करने की आवश्यकता होती है, जिसका अर्थ है कि हमें एक छोटे पार्सर को लागू करने की आवश्यकता है, साथ ही साथ कोड के वाक्यविन्यास और अर्थ विश्लेषण भी करने की आवश्यकता है।

चलो पार्सर के कार्यान्वयन के साथ शुरू करते हैं। क्योंकि चूंकि गुओ भाषा में टोकन का एक सेट होता है, जिसे एक स्थान से अलग किया जाता है, यह एक छोटा और सरल टोकन धारक लिखने के लिए तर्कसंगत है:

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;

अगला, टोकन से एनम घोषित करें:

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

और अनुदेश वर्ग ही, जिसमें हम कोड की पंक्तियों को लिखेंगे:

 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;

OpType में निर्देश संग्रहीत किया जाएगा, OpArgs में - शेष निर्माण।
OpLine, OpUnChangedLine - डिबगर के लिए जानकारी।

NextOp अगले कथन का सूचक है। यदि यह नील (पास्कल में शून्य) के बराबर है, तो आगे कोई निर्देश नहीं हैं और आपको कोड पूरा करने या कॉलबैक स्टैक के माध्यम से वापस जाने की आवश्यकता है।

OpReg एक छोटा पॉइंटर-रजिस्टर है, जिसे बाद में कोड निष्पादन के एक छोटे अनुकूलन के लिए उपयोग किया जाएगा।

कक्षा की घोषणा के बाद लिखा गया था - मैंने तय किया कि पार्सर और इसके निर्माणकर्ता में थोड़ा पार्सिंग जोड़ना सबसे अच्छा और सुंदर समाधान होगा, जो मैंने आगे किया:

 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;

यहां हम अनिवार्य रूप से निर्माण की शुरुआत (यानी पहला शब्द) की जांच करते हैं, और फिर शेष टोकन और उनकी संख्या को देखते हैं। यदि कोड के साथ कुछ स्पष्ट रूप से गलत है, तो हम एक त्रुटि प्रदर्शित करते हैं।

कोड के मुख्य टुकड़े में, हम बस फ़ाइल से TStringList में कोड को पढ़ते हैं, TGuuOp कंस्ट्रक्टर्स लाइन को लाइन से कॉल करते हैं, और पॉइंटर्स को GuuOps: TList में क्लास इंस्टेंसेस में स्टोर करते हैं।

वर्गीकृत:

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

कोड पार्सिंग के साथ, कुछ और क्रियाएं करना अच्छा होगा:

 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;

इस स्तर पर, आप पुनर्वित्त के समय प्रवेश बिंदुओं की जांच कर सकते हैं और OpReg के बारे में सोच सकते हैं - मैंने इसका इस्तेमाल एक गुए चर के लिए एक पॉइंटर को स्टोर करने के लिए किया था।

चरों की बात करते हुए, मैंने इस छोटे से कोड को एक अलग इकाई में लिया:

 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.

अब हमारे पास पार्स कोड है जो वाक्य रचना में सही प्रतीत होता है। यह इसका विश्लेषण करने के लिए बना हुआ है और आप सबसे महत्वपूर्ण चीज - डिबगिंग करना शुरू कर सकते हैं।

अगला, आपको थोड़ा अर्थ विश्लेषण लागू करने की आवश्यकता है और साथ ही कोड निष्पादन और डिबगिंग के लिए सब कुछ तैयार करना है:

 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;

प्रत्येक टोकन के TGuuOp.NextOp में, अगले टोकन के लिए एक सूचक लिखें।
कॉल ओपकोड के लिए, हम इसे मुश्किल और सरल कर रहे हैं - नेक्स्ट ओप में हम एक पॉइंटर को एंट्री पॉइंट कहते हैं।

हम प्रिंट स्टेटमेंट के जरिए आउटपुट वेरिएबल्स की भी जांच करते हैं ...

शायद निष्कर्ष से पहले उन्हें घोषित नहीं किया गया था?

अब आपको कोड निष्पादन लागू करने की आवश्यकता है। TGuuOp वर्ग पर वापस जाएं और चरण विधि लागू करें:

 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;

लूप की स्थिति में पहुंच उल्लंघन से बचने के लिए - स्टैक को सीमित करना बेहतर है, जो मैंने किया था।
लगातार घोषित STACK_SIZE = 2048, इसके लिए केवल जिम्मेदार है।

अब हमारे डिबगर का मुख्य कोड लिखने का अंतिम समय है:

 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.

नौकरी की स्थिति से, जैसा आप चाहते हैं, इंटरफ़ेस लागू किया जा सकता है।

एक पूर्ण यूआई को लागू करना संभव होगा, प्रोजेक्ट के लिए SynEdit को पेंच करें, लेकिन मेरी राय में यह एक खाली काम है जो कौशल को प्रतिबिंबित नहीं करेगा, और इसके अलावा इसके लिए भुगतान नहीं किया जाएगा :)

इसलिए मैंने खुद को एक छोटे कंसोल यूआई तक सीमित कर लिया।

उपरोक्त कोड जटिल नहीं है, इसलिए आप इसे बिना टिप्पणी के छोड़ सकते हैं। इसमें, हम तैयार किए गए टीगूओप को लेते हैं और उन्हें चरण कहते हैं।

हल की गई समस्या का स्क्रीनशॉट:

त्रुटि सूचना आउटपुट:

मेरे समाधान के भंडार से लिंक करें : क्लिक करें

परिणाम

कोई विशेष परिणाम नहीं हैं। मुझे जेटब्रेन्स टीम में दो महीने के काम और प्रशिक्षण के बजाय, ज्यादातर गर्मियों में व्यस्त छुट्टी पर जाना होगा और एक विश्वविद्यालय (अच्छी तरह से, मैं अच्छी तरह से परीक्षा पास कर सकता हूं) के लिए खोज करना होगा।

शायद अगले साल एक नई पोस्ट हैबे पर दिखाई देगी, जो पहले से ही जेबी में इंटर्नशिप प्रक्रिया का वर्णन कर रही है या किसी अन्य कंपनी में मेरे लिए दिलचस्प है :)

JetBrains में इंटर्नशिप और मैं इस पर पाने में लगभग कैसे कामयाब रहा

"लगभग" सफल क्यों हुआ?

परीक्षण कार्य का विश्लेषण

कहाँ से शुरू करें?

परिणाम

More articles: