ბიბლიოთეკა
00/07 · ~36 წთ
GUIDEDECK · სახელოსნო კოდის გარშემო

დეველოპერული
ინსტრუმენტები — ხელობა
ხელობის გარშემო.

36-წუთიანი სამუშაო სესია იმ ინსტრუმენტებზე, რომლებსაც სწრაფი გუნდები თავისთავად აღიქვამენ: Git-ის მოდელი და ვორქფლოუები, CI/CD პაიპლაინები, ბილდისა & დამოკიდებულებების მართვა და დებაგინგის/პროფილირების ნაკრები, რომელიც გამოცნობას გაზომვად აქცევს.

~36 წთშერეული გუნდიენისგან დამოუკიდებელი
გადაახვიეთ
01 · რატომ არის საჭირო 3 წთ

სწრაფი გუნდები უფრო სწრაფად კი არ კრეფენ ტექსტს —
მათ უფრო მოკლე ციკლი აქვთ.

ნელ და სწრაფ გუნდებს შორის სხვაობა იშვიათად არის ნიჭი. ეს არის უკუკავშირის შეყოვნება: რამდენი გადის „რაღაც შევცვალე“-დან „ვიცი, იმუშავა თუ არა“-მდე. ყველა ინსტრუმენტი, რომელიც წინ გელოდებათ, არსებობს იმისთვის, რომ ეს ციკლი შემცირდეს და გახდეს ავტომატური, გამეორებადი და საერთო.

100×

მაგიდასთან დაჭერილი ბაგის გამოსწორება პროდაქშენში დაჭერილთან შედარებით ორი რიგით იაფი შეიძლება იყოს.

∞

"ჩემს მანქანაზე მუშაობს" — გაუმართაობა, რომლის აღმოსაფხვრელადაც შექმნილია აქ ჩამოთვლილი ყველა ინსტრუმენტი.

1

ბრძანება, რომ დაკლონოთ, ააგოთ, გატესტოთ და გაუშვათ. რიცხვი, რომელსაც ჯანსაღი რეპოზიტორია ესწრაფვის.

<10წთ

მწვანე პაიპლაინს, რომელიც წუთებში სრულდება, ხალხი მართლა ელოდება. ნელ CI-ს კი გვერდს უვლიან.

რაღაცას ცვლით, აგებთ, ტესტავთ და იგებთ, იმუშავა თუ არა — მერე ისევ თავიდან. ყველა ინსტრუმენტი, რომელიც წინ გელოდებათ, არსებობს იმისთვის, რომ ამ ციკლის ერთმა შემობრუნებამ დღეების ნაცვლად წუთები წაიღოს.

რას ნიშნავს "უკუკავშირის შეყოვნება"

ეს არის ლოდინი „კოდი შევცვალე“-სა და „ვიცი, რამე გავაფუჭე თუ არა“-ს შორის. ნელი გუნდი ამ პასუხს შეიძლება მთელი დღე ელოდოს; სწრაფი გუნდი მას რამდენიმე წუთში იღებს.

  • მოკლე ციკლი — შეცდომას მაშინ იჭერთ, როცა ის ჯერ კიდევ ახალია თქვენს თავში და იაფად სწორდება.
  • გრძელი ციკლი — უკვე სხვა საქმეზე გადახვედით, დეტალები დაგავიწყდათ და ბაგს გავრცელების დრო ჰქონდა.

ორი კითხვა, რომელსაც ყველა ინსტრუმენტი პასუხობს

ეს ორი აითვისეთ და დანარჩენი ინჟინერიის კარგად კეთება მკვეთრად იაფი გახდება.

02 · Git-ის მოდელი 7 წთ

კომიტი არის სნეპშოტი;
ბრენჩი კი უბრალოდ მაჩვენებელი.

Git-თან დაკავშირებული დაბნეულობის უმეტესობა ქრება იმ წამს, როცა მონაცემთა მოდელს დაინახავთ. Git დიფებს კი არ ინახავს — ის ინახავს უცვლელ სნეპშოტებს, გრაფად დაკავშირებულს. ბრენჩები და თეგები ამ გრაფზე მიწებებულ ფურცლებზე მეტი არაფერია. ისწავლეთ მოდელი და ბრძანებები ჯადოქრობას აღარ დაემსგავსება.

Git — ინსტრუმენტი, რომელსაც ახსოვს თქვენი პროექტის ყველა ვერსია. ყოველი კომიტი არის თქვენი ყველა ფაილის სრული ფოტო ერთ მომენტში, პლუს ჩანაწერი (ვინ, როდის, რატომ). მისი სახელია ჰეში — შიგთავსიდან გამოთვლილი მოკლე ანაბეჭდი, მაგალითად a1c9f2. შექმნის შემდეგ კომიტი აღარასდროს იცვლება. თითოეული უკან, წინა კომიტზე მიუთითებს, ამიტომ თქვენი ისტორია ჯაჭვია (რომელიც შეიძლება განშტოვდეს, მაგრამ არასდროს იკვრება წრედ). ბრენჩი უბრალოდ მიწებებული ფურცელია, რომელიც ერთ კომიტზე მიუთითებს; HEAD კი ფურცელია იმისთვის, თუ "სად ხართ ახლა".

წაიკითხეთ გრაფი

  • თითოეული კვანძი არის კომიტი, სახელად მისი ჰეში. ისრები მშობელზე მიუთითებს — ისტორია დროში უკან მიედინება.
  • main და feature არის ბრენჩები — კომიტზე მიწებებული იარლიყები. კომიტის გაკეთება უბრალოდ იარლიყს წინ წაწევს.
  • HEAD აღნიშნავს თქვენს მიმდინარე ბრენჩს. განშტოება იაფია, რადგან ის ერთ მაჩვენებელს ქმნის და არა ასლს.

კომიტები მშობლებზეა მიბმული; ბრენჩები (main, feature) და HEAD უბრალოდ მაჩვენებლებია გრაფში.

სიტყვები, რომლებსაც ტერმინალში ნახავთ

სამუშაო ხე

თქვენი ფაილები, ახლა

ნამდვილი ფაილები დისკზე. სადაც არედაქტირებთ. არაფერი აღირიცხება, სანამ სტეიჯინგში არ დაამატებთ და არ დააკომიტებთ.

სტეიჯინგი

შემდეგი კომიტი, მონახაზად

აშკარა შუალედური შრე. git add ზუსტად არჩევს, რომელი ცვლილებები მოხვდება შემდეგ სნეპშოტში — ასე კომიტები ფოკუსირებული რჩება.

კომიტი

შენახული სნეპშოტი

უცვლელი. იდენტიფიცირდება ჰეშით. ატარებს მშობლის ბმულს, შეტყობინებას, ავტორსა და დროის ნიშნულს. ისტორიის ერთეული.

რიმოუთი

საერთო ასლი

სხვა რეპოზიტორია (მაგ. origin). push და fetch კომიტებს თქვენსა და მას შორის ასინქრონებს.

კომიტი სნეპშოტია — ისე იმუშავეთ

ერთი გიგანტური „შენახვა“
# a week of work, one commit git add . git commit -m "wip stuff" # later: a bug is in here, somewhere. # bisect is useless, revert is all-or-nothing, # review is impossible.
პატარა, ატომური, შექცევადი
# each commit = one coherent change git add src/auth.ts git commit -m "fix: reject expired tokens" git add src/login.tsx git commit -m "feat: remember-me checkbox" # now: bisect finds the bad commit, # revert is surgical, review reads like a story.
03 · Git ვორქფლოუ 7 წთ

ხანმოკლე ბრენჩები,
პატარა pull request-ები, სუფთა ისტორია.

მოდელი მარტივია; დისციპლინა კი ვორქფლოუა. მიზანია ინტეგრაცია ხშირად და პატარა ნაწილებად, რომ მერჯები ტრივიალური დარჩეს და რევიუ — ადამიანის ზომის. შემდეგ შეგნებული არჩევანი — რებეისი თუ მერჯი — წყვეტს, როგორ გამოიყურება თქვენი ისტორია.

Pull request (ან merge request) — წინადადება, რომ ერთი ბრენჩი მეორეში ჩაიმერჯოს, შეფუთული რევიუში, ავტომატურ შემოწმებებსა და დისკუსიაში. ეს ის კარიბჭეა, სადაც ცვლილება საერთო ბრენჩში მოხვედრას იმსახურებს: CI უნდა გაიაროს, ადამიანმა უნდა დაამტკიცოს, ხოლო საუბარი სამუდამოდ კომიტზე მიბმული რჩება.

B-ზე ფორკავთ, იზოლირებულად აკეთებთ ფოკუსირებულ სამუშაოს (f1, f2), შემდეგ უკან მერჯავთ M-ზე — main მთელი ამ დროის განმავლობაში გასაშვებად მზადაა.

ბრენჩის სასიცოცხლო ციკლი ოთხ ნაბიჯად

  • ბრენჩი — git switch -c feature main-იდან პირად ხაზს გამოჰყოფს; რასაც არ უნდა აკეთებდეთ, ჯერ ვერაფერს გატეხავთ.
  • კომიტი — პატარა, ფოკუსირებული კომიტები ბრენჩზე, სანამ main დამოუკიდებლად აგრძელებს მოძრაობას.
  • ინტეგრაცია — ხშირად გააკეთეთ git rebase main (ან ჩაამერჯეთ), რომ კონფლიქტები თითო-ოროლად იპოვოთ და არა ერთბაშად.
  • მერჯი — გახსენით PR; როგორც კი მწვანეა და რევიუც აქვს გავლილი, ის უკან იმერჯება და ბრენჩი იშლება. მოკლე ციკლი, სუფთა ტოტი.
ხანგრძლივი ბრენჩი — მერჯ-ჯოჯოხეთი
# branch lives for 3 weeks, 60 commits git checkout -b big-refactor # ...meanwhile main moves 200 commits ahead... git merge main # 47 conflicts. nobody remembers why. # review is a 4,000-line wall. rubber-stamped.
ხანმოკლე ბრენჩი — ტრივიალური მერჯი
# branch lives ~1 day, one focused change git checkout -b fix/expired-tokens # open a PR early, keep it < ~400 lines git push -u origin HEAD # CI green + 1 review → merge same day. # integrate often → conflicts stay tiny.
მერჯი — ინახავს რაც მოხდა

მერჯ-კომიტს M ორი მშობელი ჰყავს — ბრენჩები ხილული რჩება. ისტორიის ერთგულია, მაგრამ გრაფი განშტოვდება.

რებეისი — ხელახლა უშვებს სწორ ხაზად

რებეისი f1, f2-ს გადაწერს როგორც f1', f2'-ს main-ის თავზე — ხაზოვანი ისტორია, მაგრამ ახალი ჰეშები.

  • გამოეყავით main-ს, შეინარჩუნეთ ხანმოკლედ, ადრევე გახსენით PR.
  • git rebase main (ან pull --rebase), რომ ბრენჩი აქტუალური და მოწესრიგებული იყოს, სანამ ის ჯერ კიდევ თქვენია.
  • დაამერჯეთ main-ში PR-ის გავლით — squash თუ merge-commit, აირჩიეთ ერთი და თანმიმდევრული იყავით.
  • დაიცავით main: სავალდებულო შემოწმებები და რევიუ, პირდაპირი push-ის გარეშე. ბრენჩი, რომელზეც ყველა დამოკიდებულია, არასდროსაა გატეხილი.
04 · CI/CD პაიპლაინები 6 წთ

ყოველი push ერთსა და იმავე
შემოწმებებს უშვებს, ერთნაირად, ავტომატურად.

პაიპლაინი არის გუნდის განმარტება იმისა, თუ რას ნიშნავს "მუშაობს" — კოდად დაწერილი და ყოველ ცვლილებაზე იძულებით შესრულებული. ის შლის პროგრამირების ორ ყველაზე ცუდ სიტყვას — "უნდა მუშაობდეს" — და მათ მწვანე ნიშნით ან წითელი X-ით ცვლის.

CI — Continuous Integration: ყველა ხშირად მერჯავს პატარა ცვლილებებს საერთო ბრენჩში, ხოლო ავტომატური ბილდი და ტესტების ნაკრები თითოეულს ამოწმებს. CD — Continuous Delivery / Deployment: იგივე მწვანე ბილდი ავტომატურად იფუთება და გამოდის — ღილაკამდე (delivery) ან პირდაპირ მომხმარებლებამდე (deployment).

ერთი ცვლილება იდენტურ ეტაპებში გაივლის. დეპლოი კარიბჭესთანაა — ერთი წითელი ეტაპიც კი აჩერებს ხაზს.

პაიპლაინი კოდის სახით

on: [push, pull_request] jobs: verify: steps: - checkout - run: install --frozen-lockfile - run: lint - run: test --coverage - run: build deploy: needs: verify # მხოლოდ თუ მწვანეა if: branch == "main" steps: [ deploy ]

როგორც  საკონვეიერო ხაზი ხარისხის კარიბჭით — არაფერი გადადის შემდეგ სადგურზე, სანამ მიმდინარე არ გაივლის.

რატომ უნდა ავტომატიზდეს

ხელით და ზეპირად
# the deploy runbook lives in someone's head scp -r ./dist prod:/var/www # from a laptop ssh prod "restart && pray" # tests? "I ran them locally." # the one person who knows is on holiday.
კოდში და გამეორებადი
# merge to main → pipeline does the rest git push origin main # → lint, test, build, scan, deploy # → identical on every run, fully logged # → rollback = redeploy the last green tag

ძრავები: GitHub Actions · GitLab CI · Jenkins

SaaS · YAML

GitHub Actions

GitHub-ში ჩაშენებული CI. ნულოვანი ინფრასტრუქტურა, მრავალჯერადი გამოყენების ექშენების უზარმაზარი მარკეტპლეისი და კონფიგურაცია, რომელიც კოდის გვერდით ცხოვრობს (.github/workflows).

  • საუკეთესოა, როცა  თქვენი რეპოზიტორია GitHub-ზეა და გინდათ მწვანე შემოწმებები წუთებში, ისე რომ არაფერი გქონდეთ საოპერაციო.
SaaS / self-host

GitLab CI

ერთი აპლიკაცია რეპოზიტორიისთვის, CI-სთვის, რეესტრისა და ისუებისთვის. ძლიერი პაიპლაინები (ეტაპები, needs, გარემოები) და რანერები, რომლებსაც თავად ჰოსტავთ, რომ აკონტროლოთ, სად სრულდება ბილდები.

  • საუკეთესოა, როცა  გინდათ ერთიანი DevOps პლატფორმა ან მთელი ეს სისტემა საკუთარ სერვერებზე უნდა განათავსოთ.
self-host · პლაგინები

Jenkins

ვეტერანი — ღია კოდი, ეშვება ყველგან, ~1,800 პლაგინი, უსასრულოდ კონფიგურირებადი. მეორე მხარე: თქვენ ოპერირებთ — სერვერები, აგენტები, პლაგინების განახლებები და ყველაფერი.

  • საუკეთესოა, როცა  გაქვთ რთული, მემკვიდრეობითი ან ქსელისგან იზოლირებული პაიპლაინები, რომლებსაც სრული კონტროლი და საკუთარი ინტეგრაციები სჭირდება.

მარტივი წესი: უკვე GitHub/GitLab-ზე ხართ? გამოიყენეთ მათი მშობლიური CI — ის ყველაზე ნაკლებ სამართავს ითხოვს. Jenkins-ს მიმართეთ მაშინ, როცა გჭირდებათ თვითჰოსტინგის მოქნილობა, რომელსაც SaaS რანერი ვერ მოგცემთ.

05 · ბილდი და დამოკიდებულებები 6 წთ

გამეორებადი ბილდები:
იგივე შემავალი, იგივე ბაიტები, ყველა მანქანაზე.

ბილდის ინსტრუმენტი წყაროს გაშვებად არტეფაქტად აქცევს; პაკეტების მენეჯერი კი იმ ბიბლიოთეკებს აგვარებს, რომლებზეც დამოკიდებული ხართ. მთელი თამაში გამეორებადობაზეა — თქვენმა მანქანამ, თანაგუნდელისამ და CI-მ ერთი და იგივე შედეგი უნდა მოგცეთ, თორემ „ჩემს მანქანაზე მუშაობს“ კვლავ დაგიბრუნდებათ.

პაკეტების მენეჯერი — ინსტრუმენტი, რომელიც ჩამოტვირთავს გარე ბიბლიოთეკებს, რომლებზეც თქვენი კოდი ეყრდნობა, და თვალს ადევნებს მათ (და იმ ბიბლიოთეკებსაც, რომლებზეც ისინი ეყრდნობიან, და ასე შემდეგ). სასურველს ჩამოთვლით მანიფესტში (მაგ. package.json); ის კი წერს lockfile-ს, რომელიც ზუსტად აღრიცხავს, რა მიიღეთ — ყოველი ბიბლიოთეკის ზუსტ ვერსიას და ჩექსუმს (ანაბეჭდს, რომელიც ადასტურებს, რომ ჩამოტვირთული ფაილი არ შეცვლილა და არ დაზიანებულა).

აყენებთ A-სა და B-ს; ამასთან იღებთ C-საც — ტრანზიტულ დამოკიდებულებას. lockfile კი წყვეტს, ზუსტად რომელი C.

სემანტიკური ვერსიონირება, მოკლედ

major

მრღვევი ცვლილება

minor

ახალი ფუნქციონალი

patch

შესწორება

  • ^1.4.2 ნიშნავს „1.x, ნებისმიერი ≥ 1.4.2“ — თანხმდებით მომავალ minor და patch ვერსიებზე.
  • მანიფესტი აცხადებს განზრახვას (^1.4.2); lockfile აღრიცხავს რეალობას (1.6.0 + ჩექსუმი).
  • დააკომიტეთ lockfile. სწორედ ის ხდის დღევანდელ ინსტალაციას ექვსი თვის შემდგომის იდენტურს.

დააფიქსირეთ, თორემ დაცურდება

მცურავი — არაგანსაზღვრული
# no lockfile committed install # grabs newest matching ^1.x # CI installs 1.6.0 — passes. # a week later: 1.7.0 ships a regression. # nothing in your repo changed, build breaks. 👻
ჩაკეტილი — განსაზღვრული
# lockfile committed & respected install --frozen-lockfile # every machine + CI: exactly 1.6.0 # upgrades are an explicit, reviewable commit: update lib-c # diff shows the change

რას გაძლევთ თანამედროვე ბილდის ინსტრუმენტები

ქეშირება

ნუ გაიმეორებთ სამუშაოს

დაჰეშეთ შემავალი მონაცემები; თუ არაფერი შეცვლილა, ხელახლა გამოიყენეთ შედეგი. სხვაობა 20-წამიან და 20-წუთიან ბილდს შორის.

ინკრემენტული

ხელახლა ააგეთ მხოლოდ შეცვლილი

აკონტროლეთ დავალებების დამოკიდებულებების გრაფი და ხელახლა გამოთვალეთ მხოლოდ ის ნაწილი, რომელსაც ცვლილება შეეხო — სწრაფი ლოკალური ციკლების გული.

ჰერმეტული

დამალული შემავალის გარეშე

„დალუქული“ ბილდი, რომელიც მხოლოდ იმ შემავალ მონაცემებს იყენებს, რაც ცხადად ჩამოთვალეთ — და არა შემთხვევით ინსტრუმენტს, რომელიც უბრალოდ თქვენს ლეპტოპზეა დაყენებული. სწორედ ეს ხდის, რომ შედეგი ყველგან ერთნაირი გამოვიდეს.

ბანდლინგი

გაუშვით ერთი არტეფაქტი

გააერთიანეთ თქვენი კოდი და მისი ბიბლიოთეკები ერთ გასაშვებ ფაილში და გადააგდეთ ის კოდი, რომელსაც სინამდვილეში არავინ იყენებს (ამას tree-shaking ჰქვია). ერთი შედეგი, გაშვებადი ყველგან.

პაკეტების მენეჯერები: npm · pnpm · yarn

სამივე ერთსა და იმავე ძირითად საქმეს აკეთებს JavaScript-ის სამყაროსთვის — აყენებს თქვენს ბიბლიოთეკებს და წერს lockfile-ს. ისინი ძირითადად სიჩქარითა და დისკის მოხმარებით განსხვავდებიან.

ნაგულისხმევი

npm

მოყვება Node.js-ს, ამიტომ უკვე ყველა მანქანაზეა.

  • დადებითი  ნულოვანი დაყენება და უნივერსალურობა — ყოველი გაკვეთილი და ინსტრუმენტი მას გულისხმობს.
  • უარყოფითი  ინსტალაცია უფრო ნელია და ყოველ პროექტში თითოეულ ბიბლიოთეკას თავიდან აკოპირებს, რითაც დისკს ჭამს.
სწრაფი · მცირე

pnpm

თითოეული ბიბლიოთეკის ერთ საერთო ასლს ინახავს და პროექტებს მასზე აბამს დუბლირების ნაცვლად.

  • დადებითი  სწრაფი ინსტალაცია და დისკის დიდი დაზოგვა — განსაკუთრებით ბრწყინავს დიდ, მრავალპაკეტიან რეპოზიტორიებში.
  • უარყოფითი  მისი უფრო მკაცრი დირექტორიების განლაგება ხანდახან აბრკოლებს ძველ პაკეტებს, რომლებიც npm-ისას ეყრდნობოდნენ.
მდიდარი

yarn

ინსტრუმენტი, რომელმაც lockfile-ები და workspace-ები გაავრცელა; თანამედროვე ვერსიები სწრაფი და კონფიგურირებადია.

  • დადებითი  ძლიერი მონორეპოს ფუნქციონალი და მომწიფებული, კარგად ცნობილი ვორქფლოუ.
  • უარყოფითი  მისი უფრო ახალი „Plug'n'Play“ რეჟიმი დამატებით კონფიგურაციას საჭიროებს და ზოგ ინსტრუმენტს ეჯახება.

როგორ ავირჩიოთ: ნაგულისხმევად აიღეთ npm — ის უკვე იქაა და პროექტების უმეტესობისთვის სავსებით საკმარისი. გადადით pnpm-ზე, როცა დიდ რეპოზიტორიაში ინსტალაციის სიჩქარე და დისკი დაგტკივდებათ. yarn გამოიყენეთ, თუ თქვენი გუნდი უკვე მას იყენებს.

ბილდის რანერები: Make vs Bazel

ბილდის რანერი არის ინსტრუმენტი, რომელიც რეალურად ასრულებს ბილდის ნაბიჯებს თანმიმდევრობით (კომპილაცია, ტესტი, შეფუთვა). სპექტრის ორი ბოლო:

მარტივი · ყველგან

Make

ათწლეულების წინანდელი ინსტრუმენტი, რომელიც თქვენ მიერ ჩაწერილ ბრძანებათა სიას ასრულებს და გამოტოვებს იმ ნაბიჯებს, რომელთა შემავალი მონაცემებიც არ შეცვლილა.

  • დადებითი  უკიდურესად მარტივი, თითქმის ყველგან დაყენებული, იდეალური ერთბრძანებიანი დავალებების რანერად.
  • უარყოფითი  არ აქვს ნამდვილი ქეშირება ან შემავალი მონაცემების ანაბეჭდები — დიდ, მრავალენოვან ბილდებზე არ მასშტაბირდება.
მასშტაბური · მკაცრი

Bazel

Google-ის ბილდის სისტემა: დალუქული, ქეშირებული, ინკრემენტული ბილდები, შექმნილი უზარმაზარი, მრავალენოვანი კოდის ბაზებისთვის.

  • დადებითი  თავისი აგებულებით გამეორებადი და ძალიან სწრაფი უზარმაზარ რეპოზიტორიებზე საერთო ქეშირების წყალობით.
  • უარყოფითი  ციცაბო სასწავლი მრუდი და მძიმე დაყენება — მცირე ან ერთენოვანი პროექტისთვის ნამდვილი გადაჭარბებაა.

როგორ ავირჩიოთ: მცირე პროექტებისთვის მიმართეთ Make-ს (ან თქვენი ენის ჩაშენებულ ინსტრუმენტს); Bazel-ს კი მხოლოდ მაშინ, როცა გიგანტური, მრავალენოვანი მონორეპო მის სირთულეს ამართლებს.

06 · დებაგინგი და პროფილირება 5 წთ

შეწყვიტეთ გამოცნობა.
დააკვირდით, მერე გაზომეთ.

დებაგინგი სისწორეზეა — რატომ არის არასწორი? პროფილირება წარმადობაზეა — რატომ არის ნელი? ორივე მოსაზრებას მტკიცებულებით ცვლის. სენიორის ნაბიჯი პასუხის ცოდნა კი არაა; ის იმის ცოდნაა, როგორ იპოვო პასუხი სწრაფად.

დებაგერი — ინსტრუმენტი, რომელიც აჩერებს გაშვებულ პროგრამას, რომ ის შიგნიდან დაათვალიეროთ: დასვათ ბრეიკპოინტები, გაიაროთ სტრიქონ-სტრიქონ, წაიკითხოთ ხედვის არეში არსებული ყოველი ცვლადი და ჩამოიაროთ გამოძახებების სტეკი, რომელმაც აქამდე მოგიყვანათ. ის პასუხობს კითხვას „რა არის სინამდვილეში ახლა?“ — და არა იმას, რაც ივარაუდეთ.
print-დებაგინგი — ნელი ციკლი
function total(items: Item[]) {
  let sum = 0
  console.log("here 1")       // edit, rerun,
  for (const i of items) {
    console.log("i =", i)    // edit, rerun,
    sum += i.price            // edit, rerun...
  }
  console.log("sum =", sum)   // one variable at a time
  return sum
}
ბრეიკპოინტი — მთელი მდგომარეობა
function total(items: Item[]) {
  let sum = 0
  for (const i of items) {
    sum += i.price            // ⏸ breakpoint here
  }
  return sum
}
// pause → inspect items, i, sum, the call
// stack & every scope. step / continue. no rerun.
handleRequest (100%)
parse (33%)
render (61%) ← ცხელი გზა
fmt
serialize (48%)
deepClone (45%) ← გაასწორეთ
სიგანე = დახარჯული დრო · სტეკი = ვინ ვის იძახებს

flame graph: ყველაზე განიერი ზოლები იქაა, სადაც დრო მიდის. deepClone 45%-ს ჭამს — სწორედ ეს არის თქვენი ერთი ცვლილება.

დააპროფილირეთ ოპტიმიზაციამდე

  • ჯერ გაზომეთ. ინტუიცია ცხელი წერტილების შესახებ ბევრად უფრო ხშირად ცდება, ვიდრე ხვდება. მიეცით პროფაილერს მითითების საშუალება.
  • CPU თუ მეხსიერება. CPU-ს პროფილი აჩვენებს, სად მიდის დრო; heap-ის პროფილი კი — რა იკავებს მეხსიერებას (და სად ჟონავს).
  • გაასწორეთ ყველაზე განიერი ზოლი. 45%-იანი ფუნქციის გასწორება სჯობს ათ 1%-იან მიკროოპტიმიზაციას — და გეცოდინებათ, რომ იმუშავა, რადგან ხელახლა გაზომავთ.

როგორც  ექიმი, რომელიც ოპერაციამდე სკანირებას ნიშნავს — არ ჭრით იქ, სადაც არ სტკივა.

ყოველდღიური ნაკრები

დებაგერი

ბრეიკპოინტები & ნაბიჯებით სვლა

გააჩერეთ, დაათვალიერეთ, გადადგით ნაბიჯი, დააკვირდით. პირობითი და logpoint ბრეიკპოინტები იშვიათ შემთხვევას იჭერენ გამონატანის დატბორვის გარეშე.

git bisect

იპოვეთ ცუდი კომიტი

ორობითი ძებნა ისტორიაში: მონიშნეთ კარგი და ცუდი კომიტი და Git ზუსტად იმასთან მიგიყვანთ, რომელმაც გატეხა — log₂(n) ნაბიჯში.

დაკვირვებადობა

ლოგები, მეტრიკები, ტრეისები

პროდაქშენში პროგრამას დებაგერით ვერ გააჩერებთ. ამის ნაცვლად ეყრდნობით ლოგებს (რა მოხდა), მეტრიკებს (რიცხვები დროში) და ტრეისებს (გზა, რომელიც ერთმა მოთხოვნამ გაიარა), რომ გაარკვიოთ, რა წავიდა ცუდად.

სადაც მთელ დღეს ატარებთ: VS Code · JetBrains · Neovim

თქვენი რედაქტორი (ან IDE — Integrated Development Environment, რედაქტორი ჩაშენებული დებაგერით, ძებნითა და ინსტრუმენტებით) არის ადგილი, სადაც ამ საქმის უმეტესობა ხდება. სამი, რომელსაც ყველაზე ხშირად შეხვდებით:

უფასო · პოპულარული

VS Code

უფასო, მსუბუქი რედაქტორი Microsoft-ისგან, დანამატების უზარმაზარი ბიბლიოთეკით თითქმის ყველა ენისთვის.

  • დადებითი  ადვილი ასათვისებელია, კარგად მუშაობს თითქმის ყველაფერზე, ხოლო გაფართოებების მარკეტპლეისი უზარმაზარია.
  • უარყოფითი  ბევრი გაფართოების ჩატვირთვამ შეიძლება შეანელოს, ხოლო კოდის ღრმა გაგებაში ხანდახან სრულ IDE-ს ჩამორჩება.
ძლიერი · ფასიანი

JetBrains

სრულფასოვანი IDE-ების ოჯახი (IntelliJ, PyCharm, WebStorm…) ჩაშენებული, ღრმა ენობრივი გაგებით.

  • დადებითი  კლასის საუკეთესო რეფაქტორინგი, ნავიგაცია და შესანიშნავი დებაგერი ყუთიდანვე — დაყენების გარეშე.
  • უარყოფითი  ძირითადად ფასიანია და შესამჩნევად მძიმეა მეხსიერებასა და გაშვების დროზე.
სწრაფი · ტერმინალი

Neovim

კლავიატურაზე აგებული რედაქტორი, რომელიც პირდაპირ ტერმინალში მუშაობს და მთლიანად თქვენ მიერ კონფიგურირდება.

  • დადებითი  უკიდურესად სწრაფი და მსუბუქი, ეშვება ყველგან — SSH-ით დაშორებულ სერვერზეც კი.
  • უარყოფითი  ციცაბო სასწავლი მრუდი და საკუთარ კონფიგურაციას პლაგინებისგან თავად აწყობთ.

როგორ ავირჩიოთ: VS Code უსაფრთხო ნაგულისხმევია ხალხის უმეტესობისთვის. JetBrains აირჩიეთ, როცა ერთი ძირითადი ენისთვის მაქსიმალური ჩაშენებული სიმძლავრე გინდათ, ხოლო Neovim — თუ ტერმინალში ცხოვრობთ და სუფთა სიჩქარეს აფასებთ.

07 · ჯანსაღი ვორქფლოუ და შეჯამება 2 წთ

ერთი ცვლილება, იდეიდან პროდაქშენამდე —
რთული გზა თუ გლუვი გზა.

ნელი გუნდი
1. edit straight on main 2. one giant "fixes" commit 3. "ran it locally, looks fine" 4. scp to prod from a laptop 5. it breaks; no idea which change 6. revert everything, lose a day
სწრაფი გუნდი
1. short branch, atomic commits 2. PR early; CI runs on push 3. green checks + one review 4. merge → pipeline deploys 5. a regression? bisect finds it fast 6. redeploy last green tag, move on
1შეამცირეთ უკუკავშირის ციკლი. აქ ყოველი ინსტრუმენტი იმისთვის არსებობს, რომ უფრო ადრე გითხრათ „ისევ მუშაობს?“.
2იცოდეთ Git-ის მოდელი. სნეპშოტები DAG-ში, ბრენჩები კი მაჩვენებლები — და ბრძანებები აღარ იქნება საშიში.
3პატარა ბრენჩები, პატარა PR-ები. ხშირად ინტეგრირდით; არასდროს გააკეთოთ რებეისი საჯარო ისტორიაზე; დაიცავით main.
4მოსაწყენი ავტომატიზირეთ, ცვალებადი ჩაკეტეთ. CI/CD ყოველ push-ზე; დააკომიტეთ lockfile; გამეორებადი ბილდები.
5გაზომეთ, ნუ გამოიცნობთ. ბრეიკპოინტები print-ების ნაცვლად, პროფაილერები ინტუიციის ნაცვლად, bisect კი blame-ის ნაცვლად.

გააგრძელეთ

  • Pro Git — Chacon & Straub (უფასოა ონლაინ; თავები 2–3 & 10 არის მოდელი)
  • Accelerate — Forsgren, Humble & Kim (მონაცემები სწრაფი გუნდების უკან)
  • The Pragmatic Programmer — Hunt & Thomas (ინსტრუმენტები როგორც ხელობა)
  • git-scm.com & თქვენი დებაგერის დოკუმენტაცია — წაიკითხეთ ინსტრუმენტი, რომელსაც ყოველდღე იყენებთ

ერთი წინადადება დასამახსოვრებლად

„გახადეთ ციკლი მოკლე და ბილდი მოსაწყენი — მაშინ სიჩქარე უბრალოდ ნაგულისხმევი გახდება.“

— მთელი მოხსენება, შეკუმშული

ცოდნის შემოწმება

დაგამახსოვრდათ?

ხუთი სწრაფი კითხვა Git-ის მოდელზე, ვორქფლოუებზე, CI/CD-ზე, ბილდებსა და დებაგინგზე — მყისიერი უკუკავშირი, ავტორიზაციის გარეშე.

შეაფასეთ ეს დასტა
იყავით პირველი

ნავიგაცია ← → ღილაკებით ან სქროლით · უკან ბიბლიოთეკაში