გადადით შინაარსზე

პრინციპები

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

კონვენციებზე გადასვლა#

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

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

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

მანიფესტები ჭეშმარიტების წყაროა#

კონფიგურაციების მრავალი შრე და მათ შორის არსებული შეთანხმებები იწვევს პროექტის ისეთ მოწყობას, რომლის გააზრება და შენარჩუნება რთულია. დაფიქრდით საშუალო პროექტზე. პროექტის განსაზღვრა .xcodeproj დირექტორიებშია, CLI სკრიპტებში (მაგ., Fastfiles), ხოლო CI-ის ლოგიკა პაიპლაინებში. ეს სამი შრეა, რომელთა შორის არსებული შეთანხმებებიც უნდა შევინარჩუნოთ. რამდენჯერ აღმოჩენილხართ სიტუაციაში, როდესაც პროექტში რაღაც შეცვალეთ და კვირის შემდეგ მიხვდით, რომ რელიზის სკრიპტები გაფუჭდა?

ამის გამარტივება შესაძლებელია ერთი ჭეშმარიტების წყაროს, მანიფესტის ფაილების გამოყენებით. ეს ფაილები Tuist-ს აწვდიან ინფორმაციას, რომელიც მას სჭირდება Xcode-ის პროექტების გენერირებისთვის, რათა შემსრულებლებმა შეძლონ ფაილების რედაქტირება. გარდა ამისა, ეს საშუალებას იძლევა არსებობდეს სტანდარტული ბრძანებები პროექტების ასაგებად ადგილობრივი ან CI გარემოდან.

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

არაპირდაპირის ცხადყოფა#

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

Tuist-მა უნდა წარმოადგინოს ცხადი API-ები Xcode-ის არაპირდაპირი ქცევებისთვის. მან ასევე უნდა მხარი დაუჭიროს Xcode-ის არაპირდაპირულობის განსაზღვრას, მაგრამ ისე, რომ შემსრულებლებს წაახალისოს ცხადი მიდგომის არჩევა. Xcode-ის არაპირდაპირულობისა და სირთულეების მხარდაჭერა აადვილებს Tuist-ის ათვისებას, რის შემდეგაც გუნდებს შეუძლიათ დრო დაუთმონ არაპირდაპირულობისგან თავის დაღწევას.

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

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

Tip

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

შეინარჩუნეთ სიმარტივე#

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

Xcode შესანიშნავი ინსტრუმენტია, მაგრამ გაუმჯობესების, ახალი პლატფორმებისა და პროგრამირების ენების მრავალწლიანი ისტორია მის ზედაპირზე აისახა, რასაც სიმარტივის შენარჩუნება უჭირდა.

Tuist-მა უნდა გამოიყენოს შესაძლებლობა, რათა რამე მარტივი დარჩეს, რადგან მარტივ რამეებზე მუშაობა სახალისოა და გვაძლევს მოტივაციას. არავის უნდა დახარჯოს დრო კომპილაციის პროცესის ბოლოს წარმოქმნილი შეცდომის დებაგინგზე ან იმაზე ფიქრზე, თუ რატომ ვერ ახერხებს აპლიკაციის გაშვებას მოწყობილობებზე. Xcode ამოცანებს თავის ქვედა ბილდის სისტემას ანდობს და ზოგიერთ შემთხვევაში შეცდომების მოქმედებად ნაბიჯებად თარგმნას ძალიან ცუდად აკეთებს. ოდესმე მიგიღიათ „framework X not found“ შეცდომა და არ იცოდით, რა გაგეკეთებინათ? წარმოიდგინეთ, თუ მივიღებდით ბაგის პოტენციური საფუძვლების სიას.

დაიწყეთ შემსრულებლის გამოცდილებიდან#

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

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

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

შეცდომები შეიძლება და აუცილებლად მოხდება#

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

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

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

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

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