როგორ რთავს დადა შიდა მითითებებს

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

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

რა არის შიდა მითითებები და რატომ არის ისინი მნიშვნელოვანი?

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

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

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

როგორ ჩამორჩება ტრადიციული მფლობელობის მოდელები

Rust's borow checker არის ერთ-ერთი ყველაზე ცნობილი ინოვაცია თანამედროვე ენების დიზაინში, რომელიც გამორიცხავს მეხსიერების შეცდომების მთელ კატეგორიას კომპილაციის დროს. მიუხედავად ამისა, მისი მკაცრი ერთი მფლობელის, სესხება-ან-გადაადგილების სემანტიკა შიდა ცნობებს ჭეშმარიტად მტკივნეულს ხდის. სტრუქტურის მეხსიერებაში გადატანის მომენტში, ნებისმიერი შიდა მაჩვენებელი არასწორი ხდება. Rust-ის პასუხი — Pin API, რომელიც წარმოდგენილია 1.33 ვერსიაში — უზრუნველყოფს მექანიზმს იმის გარანტიით, რომ მნიშვნელობა არ გადაადგილდება, მაგრამ ის ასახავს სირთულეს, რაც უნდა იყოს მარტივი მოდელირების ამოცანა.

დეველოპერები ხშირად აცხადებენ, რომ დროის 30-40%-ს ხარჯავენ სესხის შემმოწმებელთან ბრძოლაში იმ შაბლონებზე, რომლებიც მოიცავს თვითმიმართვას. არენის განაწილების ბიბლიოთეკები, როგორიცაა typed-arena და ინდექსზე დაფუძნებული მიდგომები (სადაც ინდექსებს ინახავთ Vec-ში და არა რეალურ ცნობარებში) არის პრაგმატული, მაგრამ არასრულყოფილი გადაწყვეტილებები. ისინი ცვლიან პირდაპირი მითითებების ექსპრესიულობას არამიმართულთან, რომლის გადამოწმებაც შემდგენელს შეუძლია, მაგრამ ასევე ცვლის სიცხადეს ქვაბის ფირფიტაზე.

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

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

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

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

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

პრაქტიკული ნიმუშები, რომლებიც დადაში ტრივიალური ხდება

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

• თვითრეფერენციული იტერატორები — იტერატორი, რომელიც ფლობს მითითებას იმ კოლექციაზე, რომელსაც ის გადის, ინახება როგორც ერთი სტრუქტურის სახით, უწყვეტი ტანვარჯიშის გარეშე
• დამკვირვებლის შაბლონები — მოვლენის ემიტერი, რომელიც ინახავს გამოხმაურებების ჩამონათვალს საკუთარ მდგომარეობაზე მითითებით, რაც საშუალებას აძლევს რეაქტიულ პროგრამირებას Rc/RefCell შეფუთვის გარეშე
• დოკუმენტის მოდელები კურსორებით — ტექსტური რედაქტორის დოკუმენტის სტრუქტურა, რომელიც შეიცავს როგორც ბუფერს, ასევე მასში მიმავალ კურსორის ერთ ან მეტ პოზიციას
• მშობლისა და ბავშვის იერარქია — ხის სტრუქტურები, სადაც ბავშვები ატარებენ მითითებებს თავიანთ მშობლის კვანძზე, მოდელირებული პირდაპირ და არა სუსტი მაჩვენებლების ან ინდექსების მეშვეობით
• სამუშაო ნაკადის ძრავები სახელმწიფო მანქანებით — მილსადენის სტრუქტურა, რომელიც მიუთითებს მის ამჟამინდელ ეტაპზე, წინა შედეგებსა და მომლოდინე მოქმედებებზე, ყველაფერი ერთი შეკრული მონაცემთა მოდელის ფარგლებში

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

უფრო ფართო გავლენა პროგრამული უზრუნველყოფის არქიტექტურაზე

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

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

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

რას უნდა უყურონ დეველოპერებმა

დადა რჩება ექსპერიმენტულად და მისი იდეები ჯერ კიდევ იხვეწება საზოგადოების განვითარებისა და საზოგადოების გამოხმაურების გზით. თუმცა, მისი რამდენიმე ინოვაცია უკვე ახდენს გავლენას ძირითადი ენის დიზაინზე. Rust-ის მიმდინარე სამუშაოები ხედის ტიპებზე და polonius (მომავალი თაობის სესხის შემმოწმებელი) სესხულობს კონცეფციებს იმავე კვლევის სივრციდან. Swift-ის საკუთრების მოდელი, რომელიც დაინერგა Swift 5.9-ში, ანალოგიურად იკვლევს უფრო გრანულურ ნებართვის სისტემებს. TypeScript-ის ტიპის სისტემაც კი აგრძელებს განვითარებას მონაცემთა ურთიერთობების უფრო ზუსტი მოდელირებისკენ.

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

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

ენის თეორიიდან ბიზნეს რეალობამდე

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

138,000+ ბიზნესისთვის, რომლებიც იყენებენ Mewayz-ის მსგავსი პლატფორმებს თავიანთი ოპერაციების სამართავად, ეს პროგრესი ნიშნავს პროგრამულ უზრუნველყოფას, რომელიც უფრო საიმედოა, უფრო მდიდარია და უფრო სწრაფად ვითარდება. ყოველი გაუმჯობესება, თუ როგორ ამუშავებენ პროგრამირების ენები სირთულეს, საბოლოოდ ითარგმნება უკეთეს გამოცდილებად საბოლოო მომხმარებლისთვის - მცირე ბიზნესის მფლობელს, რომელსაც უბრალოდ სურს, რომ მათმა CRM, ინვოისის დაჯავშნის სისტემამ შეუფერხებლად იმუშაოს. ეს შეუფერხებლობა ათასობით კარგად მოდელირებული შიდა მითითების შედეგია და ენები, როგორიცაა Dada, მათ უფრო უსაფრთხოს და უფრო მარტივს ხდის, ვიდრე ოდესმე.