1.1 Microsoft Visual Studio C++

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

Visual Studio მოიცავს ერთ ან მეტს შემდეგიდან:

Visual Basic .NET, ხოლო მის გამოჩენამდე - Visual Basic;

ვიზუალური C++;

ვიზუალური C#.

მიწოდების მრავალი ვარიანტი ასევე მოიცავს:

Microsoft SQL Server ან MSDE;

Visual Source Safe - ფაილ-სერვერის ვერსიის კონტროლის სისტემა;

წარსულში Visual Studio ასევე მოიცავდა შემდეგ პროდუქტებს:

ვიზუალური InterDev;

ვიზუალური J++;

ვიზუალური J#;

ვიზუალური FoxPro.

პაკეტის ყველაზე მნიშვნელოვანი ვერსიები:

Visual Studio 97 იყო Visual Studio-ს პირველი ვერსია, რომელიც გამოვიდა და იყო პირველი, რომელმაც გააერთიანა პროგრამული უზრუნველყოფის განვითარების სხვადასხვა ინსტრუმენტები. იგი გამოვიდა ორი ვერსიით: Professional და Enterprise. მასში შედიოდა Visual Basic 5.0, Visual C++ 5.0, Visual J++ 1.1, Visual FoxPro 5.0 და ASP განვითარების გარემო – Visual InterDev – პირველად გამოჩნდა. Visual Studio 97 იყო Microsoft-ის პირველი მცდელობა შეექმნა განვითარების ერთიანი გარემო სხვადასხვა პროგრამირების ენებისთვის: Visual C++, Visual J++, Visual InterDev და MSDN ყველა იზიარებდა ერთ გარემოს, სახელწოდებით Developer Studio. Visual Basic და Visual FoxPro იყენებდნენ განვითარების ცალკეულ გარემოს.

Visual Studio 6.0 - გამოვიდა 1998 წლის ივნისში - Visual Studio-ს უახლესი ვერსია, რომელიც მუშაობს Win9x პლატფორმაზე. ჯერ კიდევ პოპულარულია Visual Basic-ის გამოყენებით პროგრამისტებში. ეს ვერსია იყო Microsoft-ის Windows-ისთვის აპლიკაციების განვითარების მთავარი გარემო, .NET პლატფორმის მოსვლამდე.

Visual Studio .NET (კოდური სახელი Rainier; შიდა ვერსია 7.0) - გამოვიდა 2002 წლის თებერვალში (მოიცავს .NET Framework 1.0). Service Pack 1 Visual Studio .NET-ისთვის (2002) გამოვიდა 2005 წლის მარტში.

Visual Studio .NET 2003 (კოდური სახელი Everett; შიდა ვერსია 7.1) - გამოვიდა 2003 წლის აპრილში (მოიცავს .NET Framework 1.1). Service Pack 1 Visual Studio .NET 2003 გამოვიდა 2006 წლის 13 სექტემბერს.

Visual Studio 2005 (კოდური სახელი Whidbey; შიდა ვერსია 8.0) - გამოვიდა 2005 წლის ოქტომბრის ბოლოს (მოიცავს .NET Framework 2.0). 2005 წლის ნოემბრის დასაწყისში გამოვიდა Express ვერსიის პროდუქტების სერია: Visual C++ 2005 Express, Visual Basic 2005 Express, Visual C# 2005 Express და ა.შ. 2006 წლის 19 აპრილს Express გამოცემა უფასო გახდა. Service Pack 1 VS2005-ისთვის და ყველა Express გამოცემისთვის გამოვიდა 2006 წლის 14 დეკემბერს. SP1-ის დამატებითი პატჩი, რომელიც წყვეტს Windows Vista-სთან თავსებადობის პრობლემას, გამოვიდა 2007 წლის 3 ივნისს.

Visual Studio 2008 (კოდური სახელი Orcas) - გამოვიდა 2007 წლის 19 ნოემბერს .NET Framework 3.5-თან ერთად. მიზნად ისახავს აპლიკაციების შექმნას Windows Vista-სთვის (მაგრამ ასევე მხარს უჭერს XP), Office 2007 და ვებ აპლიკაციებს. მოყვება LINQ, C# და Visual Basic-ის ახალი ვერსიები. Visual J# არ შედიოდა სტუდიაში. 2008 წლის 28 ოქტომბრიდან რუსული ვერსია პირველად იყო ხელმისაწვდომი.

Visual Studio 2008-ის მემკვიდრე პროდუქტს აქვს კოდის სახელი Hawaii. 2008 წლის 29 სექტემბერს გაჩნდა განცხადება, რომელშიც წარმოდგენილია ზოგიერთი ინოვაცია, რომელიც გამოჩნდება Visual Studio 2010-ში და .NET Framework 4.0-ში.

აპლიკაციის შემქმნელს, რომელიც გადაწყვეტს გამოიყენოს Visual Studio.Net 7.0 სერვისები, მის განკარგულებაშია საკმაოდ ბევრი ახალი ტექნოლოგია და ინსტრუმენტი, რომელიც საშუალებას აძლევს სწრაფად და ეფექტურად შექმნას ჩვეულებრივი Windows აპლიკაციები, რომლებსაც ახლა ჩვეულებრივ უწოდებენ დესკტოპ აპლიკაციებს, ასევე. ვებ აპლიკაციები და ვებ სერვისები. მაიკროსოფტმა პროგრამისტების არსენალს დაამატა ახალი ენა C# (გამოითქმის „C sharp“), რომელსაც, როგორც ექსპერტები გვპირდებიან, შეუძლია რამდენჯერმე დააჩქაროს რთული პროექტების განვითარების ციკლი.

მთავარი სიახლე, რომელიც უნდა მიიპყრო თქვენი ყურადღება არის ის, რომ Visual C++, Visual Basic და C# იყენებენ ერთსა და იმავე IDE-ს (ინტეგრირებული განვითარების გარემო), რაც შესაძლებელს ხდის შექმნას რთული პროექტები სხვადასხვა ენების გამოყენებით (შერეული ენების გადაწყვეტილებები). .Net მრავალენოვანი განვითარების გარემო (.Net Framework) არის სამი კომპონენტის ჯამი:

საერთო გაშვების ბიბლიოთეკა განხილული ენების ნაკრებისთვის (Common Language Runtime);

დეველოპერის კლასების ერთიანი ბიბლიოთეკა (Unified Programming Classes);

ვებ აპლიკაციის განვითარების მოდელი (Active Server Pages.Net).

პირველი კომპონენტია Runtime ბიბლიოთეკა (Common Language Runtime, შემოკლებით CLR), რომელიც ფუნქციონირებს როგორც გაშვების დროს, ასევე განვითარების ეტაპზე. კოდის შესრულების დროს ის აკონტროლებს მრავალნაკადიანი აპლიკაციების დინამიკას, უზრუნველყოფს პროცესების ურთიერთდაკავშირებას, ინარჩუნებს მათ უსაფრთხოებას და ავტომატიზირებს მეხსიერების განაწილებისა და განთავისუფლების პროცედურებს. განვითარების ეტაპზე, CLR ავტომატიზირებს პროგრამისტის მიერ გადაწყვეტილ ტიპურ ამოცანებს, რაც მნიშვნელოვნად ამარტივებს ახალი ტექნოლოგიების გამოყენებას. განსაკუთრებით აღსანიშნავია COM სტანდარტის (Component Object Model, შემოკლებით COM - Multi-Component Object Model) კომპონენტების შექმნისას მიღებული უპირატესობები.

მეორე კომპონენტი (Unified Programming Classes) უზრუნველყოფს დეველოპერს ერთიანი, ობიექტზე ორიენტირებული, გაფართოებადი კლასის ბიბლიოთეკით, რომელიც სხვა რესურსებთან ერთად არის Application Programming Interface (API) ნაწილი. იგი აერთიანებს MFC-ის (Microsoft Foundation Classes), WFC (Windows Foundation Classes) და Visual Basic-ის მიერ გამოყენებული API-ის ნაწილს.

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

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

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

Common Runtime Library (CLR) ამარტივებს აპლიკაციებისა და მათი კომპონენტების შექმნას, რომლებიც შემუშავებულია სხვადასხვა ენაზე და მიზნად ისახავს CLR-ის გამოყენებას. ეს მოდულები შეიძლება იყოს ინტეგრირებული ერთ პროექტში და ურთიერთქმედება ერთმანეთთან, თითქოს ისინი შეიქმნა იმავე ენაზე. მაგალითად, შეგიძლიათ გამოაცხადოთ კლასი და შემდეგ შექმნათ მისგან მიღებული კლასი სხვა ენაზე. თქვენ უბრალოდ შეგიძლიათ გამოიყენოთ კლასის მეთოდები სხვა ენაზე დაწერილ მოდულში. ეს ინტეგრაცია შესაძლებელია, რადგან შემდგენელები და ინსტრუმენტები სხვადასხვა ენაზე იზიარებენ საერთო ტიპის სისტემას, რომელიც განსაზღვრულია CLR-ში, ისევე როგორც თამაშის ახალ წესებს, რომლებიც მიღებულია მისი განვითარების დროს.

1.2 C++ Builder

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

C++ Builder არის SDI აპლიკაცია, რომლის მთავარი ფანჯარა შეიცავს კონფიგურირებადი ხელსაწყოთა ზოლს (მარცხნივ) და კომპონენტის პალიტრას (მარჯვნივ). გარდა ამისა, ნაგულისხმევად, C++ Builder-ის გაშვებისას გამოჩნდება Object Inspector ფანჯარა (მარცხნივ) და ახალი განაცხადის ფორმა (მარჯვნივ). განაცხადის ფორმის ფანჯრის ქვემოთ არის კოდის რედაქტორის ფანჯარა.

ნახ.1. C++Builder განვითარების გარემო

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

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

ბრინჯი. 2. ხილული და უხილავი კომპონენტების გამოყენების მაგალითი

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

C++ Builder-ის თითოეულ კომპონენტს აქვს სამი სახის მახასიათებლები: თვისებები, მოვლენები და მეთოდები.

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

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

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

1.3 დელფი

Delphi არის განვითარების გარემო, რომელიც იყენებს Delphi პროგრამირების ენას (დაწყებული 7 ვერსიიდან, გარემოში არსებულ ენას ეწოდება Delphi, ადრე Object Pascal), შემუშავებული Borland-ის მიერ და თავდაპირველად დანერგილი Borland Delphi პაკეტში, საიდანაც მიიღო მისი ამჟამინდელი სახელი. 2003 წელს. Object Pascal არსებითად არის Pascal ენის მემკვიდრე ობიექტზე ორიენტირებული გაფართოებებით.

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

Delphi არის რამდენიმე მნიშვნელოვანი ტექნოლოგიის კომბინაცია:

მაღალი ხარისხის შემდგენელი მანქანის კოდში;


– კომპონენტების ობიექტზე ორიენტირებული მოდელი;


– პროგრამული პროტოტიპებიდან აპლიკაციების ვიზუალური (და, შესაბამისად, მაღალსიჩქარიანი) მშენებლობა;


– მასშტაბირებადი ინსტრუმენტები მონაცემთა ბაზების შესაქმნელად.


Borland Delphi 8 Studio გაძლევთ საშუალებას შექმნათ მრავალფეროვანი პროგრამები: უმარტივესი ერთფანჯრიანი აპლიკაციებიდან დაწყებული, განაწილებული მონაცემთა ბაზების მართვის პროგრამებამდე. პაკეტი მოიცავს მრავალფეროვან კომუნალურ პროგრამას, რომელიც საშუალებას გაძლევთ იმუშაოთ მონაცემთა ბაზებთან, XML დოკუმენტებთან, შექმნათ დახმარების სისტემა და გადაჭრათ სხვა პრობლემები. მეშვიდე ვერსიის გამორჩეული თვისებაა .NET ტექნოლოგიის მხარდაჭერა.


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


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


დელფის სრულფასოვანი განვითარების გარემოს პირველი ვერსია .NET-ისთვის იყო Delphi 8. ის საშუალებას გაძლევთ დაწეროთ აპლიკაციები მხოლოდ .NET-ისთვის. ამჟამად, Delphi 2006-ში შეგიძლიათ დაწეროთ .NET აპლიკაციები სტანდარტული .NET კლასის ბიბლიოთეკის გამოყენებით, VCL .NET-ისთვის. Framework ასევე საშუალებას გაძლევთ შექმნათ .NET აპლიკაციები C#-ში და Win32 აპლიკაციები C++-ში. Delphi 2006 შეიცავს ფუნქციებს საერთო აპლიკაციების დასაწერად VCL და CLX ბიბლიოთეკების გამოყენებით. Delphi 2006 მხარს უჭერს MDA ტექნოლოგიას ECO (Enterprise Core Objects) ვერსიის 3.0 გამოყენებით.


2006 წლის მარტში Borland-მა გადაწყვიტა შეეჩერებინა ინტეგრირებული განვითარების გარემოს შემდგომი გაუმჯობესება JBuilder, Delphi და C++ Builder ამ ტერიტორიის არამომგებიანობის გამო. 2006 წლის აგვისტოში Borland-მა გამოუშვა RAD Studio-ს მსუბუქი ვერსია სახელწოდებით Turbo: Turbo Delphi, Turbo Delphi for .NET, Turbo C#, Turbo C++. 2008 წლის მარტში გამოცხადდა, რომ ამ პროდუქტის ხაზის განვითარება შეწყვეტილი იქნებოდა.


2007 წლის მარტში CodeGear-მა მომხმარებლები გაახარა Delphi 2007-ის განახლებული ხაზით Win32 პროდუქტებისთვის და სრულიად ახალი პროდუქტის გამოშვებით, Delphi 2007 PHP-სთვის. 2007 წლის ივნისში CodeGear-მა წარმოადგინა თავისი სამომავლო გეგმები, ანუ გამოაქვეყნა ე.წ. საგზაო რუკა, რომელიც შეგიძლიათ ნახოთ აქ.


2008 წლის 25 აგვისტოს Embarcadero-მ, CodeGear-ის ახალმა მფლობელმა, გამოაქვეყნა პრესრელიზი Delphi-ზე Win32 2009-ისთვის. ვერსიამ მრავალი სიახლე შემოიტანა ენაში, როგორიცაა:


– სტანდარტულად უნიკოდის სრული მხარდაჭერა ენის ყველა ნაწილში, VCL და RTL;


- განზოგადებული ტიპები, ასევე ცნობილი როგორც გენერიკა.


- ანონიმური მეთოდები.


Delphi-ში დამზადებულ მრავალ გავრცელებულ პროგრამულ პროდუქტს შორის შეგიძლიათ იპოვოთ:


1. Borland-ის პროდუქტები: Borland Delphi, Borland C++ Builder, Borland JBuilder ვერსიები 1 და 2.


2. მონაცემთა ბაზის ადმინისტრირება/განვითარება: MySQL Tools (ადმინისტრატორი, შეკითხვის ბრაუზერი), IBExpert, TOAD


3.საინჟინრო პროგრამული უზრუნველყოფა: Altium Designer/Protel (ელექტრონული დიზაინი).


4.გრაფიკის მაყურებელი: FastStone Image Viewer, FuturixImager, Photofiltre.


5.ვიდეო და აუდიო პლეერი: KMPlayer (ვიდეო და აუდიო პლეერი), X-Player (აუდიო პლეერი).


6.ინფორმაციის მიწოდება ინტერნეტში: Skype (VoIP და IM), QIP, QIP Infium და R&Q, (IMs), The Bat! და si.Mail (ელფოსტის კლიენტები), PopTray (ფოსტის გამშვები), FeedDemon (RSS/Atom newsgroup viewer), XanaNews (newsgroup reader), Xnews (newsgroup reader).


7.მუსიკის შექმნა: FL Studio (ყოფილი FruityLoops).


8. პროგრამული უზრუნველყოფის შემუშავება: Dev-C++, Dev-PHP, Maguma Open Studio და Open Perl IDE (IDE), DUnit (ერთეულის ტესტირება), Jedi კოდის ფორმატი (კოდის ფორმატირება), Game Maker (თამაშის შექმნა) დახმარება და სახელმძღვანელო (დახმარება ავტორიზაციაში). სისტემა), Inno Setup (სამონტაჟო ძრავა).


9.ვებ განვითარება: Macromedia HomeSite (HTML რედაქტორი), TopStyle Pro (CSS რედაქტორი), Macromedia Captivate (ეკრანის გადაღება), Quick Page 2008 (ვებ საიტის განვითარების გარემო).


10. ვებ ბრაუზერები (ჭურვები MSIE-სთვის): Avant Browser, Netcaptor.


11. Utilities: Spybot - Search & Destroy, Ad-Aware (anti-spyware), jv16 PowerTools, FDK (მრავალფუნქციური სისტემის ოპტიმიზაციის პროგრამა), Total Commander და Frigate (ფაილის მენეჯერები), DarkCrypt TC/GUI (დაშიფვრის პროგრამული პაკეტი), ImageSpyer და StegoTC (სტეგანოგრაფიული პროგრამული პაკეტი), Copernic Desktop Search, PowerArchiver და PeaZip (არქივატორები), MCubix (მონაცემთა მოპოვება), Download Master [ჩამოტვირთვის მენეჯერი], ACProtect (პროგრამა EXE ფაილების შეფუთვისა და დაცვისთვის).


12.ტექსტური რედაქტორები: SynEdit, Bred2, KeyNote, cEdit Professional, Programmer's Notepad, UniRed, gleditor.


13.ორობითი ფაილის რედაქტორები (HEX editors): Hexapad


14. ბუღალტერია და გადასახადები: Intuit's Lacerte Professional Tax Software, ყველა ქვესისტემის ჩათვლით, როგორიცაა QuickBooks/EasyACCT Trial Balance Utility, Document Management System და Client Database Repair Utility.


15.ელექტრონული ტექსტის წაკითხვისა და კატალოგიზაციის პროგრამები: DarkLib (კატალოგი და მრავალფორმატიანი e-reader), IxReader (e-reader).


2 თანამედროვე ობიექტზე ორიენტირებული ენების შესაძლებლობების (უპირატესობების) უარყოფითი მხარეების შედარებითი ანალიზი და მათზე დაფუძნებული განვითარების ინსტრუმენტები


2.1 ობიექტი პასკალი


Object Pascal არის პასკალური ენის სრულად ობიექტზე ორიენტირებული დიალექტი, რომელიც შეიმუშავა Apple Computer-მა ნიკლაუს ვირტთან ერთად. 1986 წელს Borland-მა დაამატა მსგავსი Pascal გაფართოება Turbo Pascal for Macintosh პროდუქტს; Turbo Pascal 5.5-ის გამოშვებით, გაფართოება ხელმისაწვდომი გახდა DOS-ისთვის. Delphi 7-დან დაწყებული, Borland-მა ოფიციალურად დაიწყო თავის ენას Delphi-ის დარქმევა. თუმცა, Object Pascal შენარჩუნებულია და ვითარდება სხვა დეველოპერების მიერ. Object Pascal-ის ყველაზე სერიოზული დანერგვა (გარდა Delphi) არის TMT Pascal, Virtual Pascal და Free Pascal.


ნებისმიერი დელფის პროგრამა შედგება პროექტის ფაილისაგან (ფაილი dpr გაფართოებით) და ერთი ან მეტი მოდულისგან (ფაილები pas გაფართოებით). თითოეული ეს ფაილი აღწერს Object Pascal პროგრამის ერთეულს.


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


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


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


($R *.RES)


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


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


(ეს არის კომენტარი)


(*ესეც კომენტარია*)


//ამ ხაზის ბოლომდე ყველა სიმბოლო წარმოადგენს კომენტარს


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


იყენებს


Forms, Unit1 'Unitl.pas'-ში (fmExample);


მიუთითეთ, რომ პროექტის ფაილის გარდა, პროგრამამ უნდა გამოიყენოს Forms AND Unit1 მოდულები. Forms მოდული არის სტანდარტული (ანუ უკვე ცნობილია Delphi-სთვის), ხოლო Unit1 მოდული არის ახალი, ადრე უცნობი, და Delphi ამ შემთხვევაში ასევე აკონკრეტებს ფაილის სახელს მოდულის ტექსტით ("uniti.pas"-ში) და მოდულის ფორმებთან დაკავშირებული აღწერილობის ფაილის სახელი (fmExample).


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


განაცხადი.ინიციალიზაცია;


Application.CreateForm(TfmExample, fmExample);


აპლიკაცია.გაშვება;


თითოეული მათგანი ახორციელებს გამოძახებას Application ობიექტის ერთ-ერთ მეთოდზე


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


განაცხადი.ინიციალიზაცია;


ნიშნავს Application ობიექტის Initialize მეთოდის გამოძახებას. ამ სტრიქონის წაკითხვის შემდეგ შემდგენელი შექმნის კოდს, რომელიც აიძულებს პროცესორს დაიწყოს პროგრამის ზოგიერთი ფრაგმენტის შესრულება, რომელიც Delphi-ის დეველოპერებმა დაგვიწერეს. ამ ფრაგმენტის შესრულების შემდეგ (პროგრამისტები ამბობენ: ქვეპროგრამიდან გასვლის შემდეგ), პროცესორის კონტროლი გადავა პროგრამის შემდეგ ხაზში, რომელიც უწოდებს CreateForm მეთოდს და ა.შ.


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


ერთეული ერთეული 1;


ინტერფეისი


// ინტერფეისის დეკლარაციების განყოფილება


განხორციელება


// განხორციელების განყოფილება


დასასრული.


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


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


სტანდარტული TForm კლასი ახორციელებს ყველაფერს, რაც საჭიროა Windows ცარიელი ფანჯრის შესაქმნელად და მუშაობისთვის. კლასი TfmExamplel მომდინარეობს ამ კლასიდან, რასაც მოწმობს ხაზი


TfmExample = კლასი (TForm)


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


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


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


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


დაცული სიტყვები;


იდენტიფიკატორები;


ტიპები;


მუდმივები;


ცვლადები;


ტეგები;


ქვეპროგრამები;


კომენტარები.


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


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


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


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


კბაიტი = 1024;


Mbyte = Kbyte*Kbyte;


გბაიტი = 1024*მბაიტი;


ისე რომ გრძელი რიცხვების ნაცვლად


1048576 (1024*1024) და 1073741824


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


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


ვარ


inValue: მთელი რიცხვი;


byValue: ბაიტი;


აქ იდენტიფიკატორი inValue გამოცხადებულია როგორც მთელი რიცხვი ცვლადი, ხოლო byValue იდენტიფიკატორი გამოცხადებულია როგორც Byte ცვლადი. სტანდარტული (ანუ წინასწარ განსაზღვრული Object Pascal-ში) ტიპის მთელი რიცხვი განსაზღვრავს მეხსიერების ოთხბაიტიან ნაწილს, რომლის შინაარსი განიხილება როგორც მთელი რიცხვი -2,147,483,648-დან +2,147,483,647-მდე, ხოლო სტანდარტული ტიპის Byte განსაზღვრავს მეხსიერების 1-ბაიტიან ნაწილს. , რომელიც ფლობს ხელმოუწერელ რიცხვს 0-დან 255 4-მდე დიაპაზონში. სტანდარტული ტიპების შესაძლო მნიშვნელობებისა და მეხსიერების სიმძლავრის დიაპაზონის შესახებ მოცემული ყველა ინფორმაცია ვრცელდება Delphi 32-ზე. 16-ბიტიანი ვერსიისთვის, ამ მნიშვნელობებს განსხვავებული მნიშვნელობა აქვს, მაგალითად, 1 ვერსიაში მთელი ტიპი იღებს 2-ს. ქედს იხრის და აქვს მნიშვნელობის დიაპაზონი -32,768-დან +32 767-მდე.


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


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


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


ფუნქცია MyFunction: მთელი რიცხვი;


და ცვლადი ვარ


X: მთელი რიცხვი;


მაშინ შესაძლებელია შემდეგი მინიჭების ოპერატორი:


X:= 2*MyFunction-l;


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


პროცედურა MyProcedure;


:


X:= 2*MyProcedure-l; // შეცდომა!


2.2 C++


C++, C ენის გაფართოება, შეიმუშავა Bjarne Stroustrop-მა, AT&T Bell Laboratories კვლევითი ცენტრის (ნიუ ჯერსი, აშშ) თანამშრომელმა 1979 წელს. C++ შეიცავს ყველაფერს, რაც არის C-ში. მაგრამ, გარდა ამისა, იგი მხარს უჭერს ობიექტზე ორიენტირებულ პროგრამირებას (Object Oriented Programming, OOP). C++ თავდაპირველად შეიქმნა დიდი პროგრამების შემუშავების გასაადვილებლად. ობიექტზე ორიენტირებული პროგრამირება არის ახალი მიდგომა პროგრამების შესაქმნელად.


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


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


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


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


გარე ორმაგი sqrt (ორმაგი);


გარე შიგა ცინი;


წყარო ფაილებს შორის თანმიმდევრულობის უზრუნველსაყოფად ყველაზე გავრცელებული გზაა ასეთი დეკლარაციების განთავსება ცალკეულ ფაილებში, სახელწოდებით header (ან სათაური) ფაილებში და შემდეგ, ანუ კოპირება, ამ სათაურის ფაილების ყველა ფაილში, სადაც ეს დეკლარაციებია საჭირო. მაგალითად, თუ sqrt-ის აღწერა ინახება სათაურის ფაილში სტანდარტული მათემატიკის ფუნქციებისთვის math.h და გსურთ ამოიღოთ 4-ის კვადრატული ფესვი, შეგიძლიათ დაწეროთ:


#შეიცავს


//…


x = sqrt(4);


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


ჩათვლით ბრძანებაში, ფაილის სახელი, რომელიც ჩასმულია კუთხის ფრჩხილებში, მაგალითად, ეხება ამ სახელის ფაილს სტანდარტულ დირექტორიაში (ხშირად /usr/include/CC); სხვა ადგილებში მდებარე ფაილები მითითებულია ორმაგი ბრჭყალებში ჩასმული სახელების გამოყენებით.


მაგალითად:


#include "math1.h"


#include "/usr/bs/math2.h"


მოიცავს math1.h მომხმარებლის მიმდინარე დირექტორიადან და math2.h /usr/bs დირექტორიადან.


აქ მოცემულია პროგრამის ძალიან მცირე სრული მაგალითი, რომელშიც სტრიქონი განსაზღვრულია ერთ ფაილში და იბეჭდება მეორეში. header.h ფაილი განსაზღვრავს საჭირო ტიპებს:


// სათაური.თ


გარე ჩანაწერი* პროგრამის_სახელი;


გარე void f();


ფაილი main.c შეიცავს მთავარ პროგრამას:


// მთავარი.გ


#include "header.h"


char* prog_name = "კარგი, მაგრამ სრული";


მთავარი ()


{


f();


}


და f.c ფაილი ბეჭდავს ხაზს:


//f.c


#შეიცავს


#include "header.h"


void f()


{


კოუტ<< prog_name << «\n»;


}


მაგალითად, შეგიძლიათ შეადგინოთ და გაუშვათ პროგრამა ასე:


$ CC main.c f.c -o სულელური


$ სულელური


კარგი, მაგრამ სრული


$


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


დანერგილი იყოს ტრადიციულ კომპიუტერებზე;


გაშვება ტრადიციული ოპერაციული სისტემების გარემოში;


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


შესაფერისია ყველაზე შესაძლო აპლიკაციებისთვის.


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


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


ცხრილი 1 - ობიექტზე ორიენტირებული ენების უპირატესობები და უარყოფითი მხარეები


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

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


ობიექტების, როგორც ძირითადი მოდელების გამოყენება მომხმარებელს საშუალებას აძლევს მოახდინოს რეალურ სამყაროში რთული სისტემების სიმულაცია;


ობიექტზე ორიენტირებული ტექსტების მოქნილობა იწვევს მომხმარებლის მოთხოვნების ცვლილებებზე სწრაფ რეაგირებას;


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


პროგრამული უზრუნველყოფის სიმარტივე მას უფრო მოქნილს ხდის და ამცირებს საოპერაციო ხარჯებს.


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


ამჟამად, პროდუქტიულობის ზრდის რამდენიმე ობიექტური საზომია იმის გამო, რომ ობიექტზე ორიენტირებულ სისტემებთან დაკავშირებული პროექტების უმეტესობა ადრეულ ეტაპებზეა. ერთ-ერთმა კომპანიამ, STC Technology (დიდი ბრიტანეთი), რომელმაც შედარებითი შეფასებები გააკეთა, გამოთვალა, რომ ობიექტზე ორიენტირებული პროექტის განვითარების ეტაპს ნახევარი დრო სჭირდება, ვიდრე მსგავს ამოცანას ტრადიციულ სისტემაში და მოითხოვს კაც-საათის მეოთხედს.


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


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


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


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


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


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


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


ობიექტის ბიბლიოთეკების შეძენა ასევე შესაძლებელია დამოუკიდებელი გამყიდველებისგან. ამჟამად, ასეთი კლასის ბიბლიოთეკები ყველაზე აქტიურად არის შეძენილი ხატებით მომხმარებლის ინტერფეისის შესაქმნელად. ნულიდან ასეთი ინტერფეისების შექმნა და დაწერა ადვილი საქმე არ არის. კომპანიები, როგორიცაა Apple და Whitewater Group, უზრუნველყოფენ ინსტრუმენტებს ასეთი ინტერფეისების სწრაფად შესაქმნელად რამდენიმე საბაზისო კლასების საფუძველზე, როგორიცაა Window, Menu, ScrollBar და Icon. მომხმარებლებს შეუძლიათ გამოიყენონ როგორც ეს კლასები, ასევე მათი ქვეკლასები, რომლებიც ამატებენ, მაგალითად, სპეციალურ ხატებს ინტერფეისში.


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


ცნობილია, რომ ტექნიკური ხარჯები შეადგენს პროგრამირების სისტემის სასიცოცხლო ციკლის ღირებულების 80%-მდე. დიდი კომპლექსური სისტემების შემქმნელები, რომლებიც ხშირად განიცდიან მათი შეცვლის აუცილებლობას, მიდრეკილნი არიან გამოიყენონ OOS, როგორც შენარჩუნების ხარჯების შემცირების და მათი პროდუქციის საიმედოობის გაზრდის ერთ-ერთი გზა. მაგალითად, Wild Leitz-მა (ტორონტო, კანადა) გამოიყენა ობიექტზე ორიენტირებული ენა Objective-C გეოგრაფიული საინფორმაციო სისტემის შესაქმნელად. კომპანიამ აღმოაჩინა, რომ წყაროს კოდი ამ ენაზე უფრო ადვილი შესანარჩუნებელია, რადგან ის უფრო მოკლეა, დამოუკიდებელია და ამცირებს ერთი მოდულის შეცვლის გავლენას სისტემის დანარჩენ ნაწილზე.


სწორად შემუშავებული პროგრამები არა მხოლოდ უნდა აკმაყოფილებდეს მათ ფუნქციურ მოთხოვნებს, არამედ უნდა ჰქონდეს ისეთი თვისებები, როგორიცაა:


ხელახლა გამოყენებადობა;


გაფართოება;


არასწორი მონაცემების წინააღმდეგობა;


სისტემატურობა.


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


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


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


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


შეზღუდული წვდომა რიგ სტანდარტულ პლატფორმებზე;


არსებულ სისტემებთან და მონაცემთა ბაზებთან ინტეგრაციის საჭიროება;


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


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


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


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


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


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


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





ბრინჯი. 3. გეომეტრიულ ობიექტებთან მუშაობის მრავალმოდული სისტემის ორგანიზაციის გამარტივებული დიაგრამა


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


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


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


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


კონვეიერის წარმოების მეთოდის გამოყენების შესაძლებლობა, პროგრამული უზრუნველყოფის განვითარების პროცესის „პარალელიზაცია“.


არსებობს რამდენიმე მიზეზი, რის გამოც C++ არ შეიძლება ჩაითვალოს დინამიურ პროგრამირების ენად.


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


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


სტატიკური ტიპის შემოწმება.


p->f() გამოხატვის ანალიზისას შემდგენელი „უნდა იყოს დარწმუნებული“ რომ ობიექტი, რომელზეც მითითებულია p მაჩვენებელი, რეალურად შეიცავს მეთოდს f(). შაბლონებიც კი ყოველთვის არ უწყობს ხელს კოდის შექმნას, რომელიც ამუშავებს სხვადასხვა ტიპის ობიექტებს: კომპილაციისა და აწყობის ეტაპზე, თქვენ უნდა იცოდეთ რომელი მათგანის დაყენება გჭირდებათ, რომელი გამოიყენება თითოეულ კონკრეტულ შემთხვევაში. სცადეთ დავალება Listing 1-ში კლასების შეცვლის გარეშე ან if-then-else + dynamic_cast კონსტრუქციების გამოყენების გარეშე.


/*


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


*/


კლასი baseclass();


კლასი A: საჯარო საბაზისო კლასი


{


საჯარო:


A();


// კლასი A შეიცავს void f() მეთოდს


ვირტუალური void f();


};


კლასი B: საჯარო საბაზისო კლასი


{


საჯარო:


B();


// კლასი B არ შეიცავს void f() მეთოდს


};


კლასი C: საჯარო საბაზისო კლასი (...);


/*


დასაწერად აუცილებელია


(ზემოხსენებული კლასების შეცვლის გარეშე და if-then-else + dynamic_cast გამოყენების გარეშე):


*/


bool CallF (ბაზა კლასი *p)


{


/*


თუ p->f() არის განსაზღვრული, გამოიძახეთ ეს ფუნქცია და დააბრუნეთ true,


წინააღმდეგ შემთხვევაში დააბრუნეთ false


*/


}


C++ გთავაზობთ CallF ფუნქციის განხორციელების სამ გზას. პირველი (ყველაზე მეტად გამოყენებული) არის bool f() მეთოდის დამატება საბაზისო კლასში, იმ ქვეკლასებში, სადაც აზრი აქვს - შეასრულეთ საჭირო მოქმედებები და დააბრუნეთ true, დანარჩენში - return false. მეორე არის კლასის შექმნა baseclass_f:public baseclass, მისგან მემკვიდრეობითი ყველა კლასის შემცველი f() და გამოიყენოს dynamic_cast< baseclass_f *>. მესამე არის ცნობილი if-then-else + dynamic_cast CallF-ში. პირველი ვარიანტი იწვევს საბაზისო კლასის ჩაკეტვას და საბაზისო კლასი შეიძლება არ იყოს ხელმისაწვდომი (მაგალითად, შეიცავს "დახურულ" მოდულში). მეორე მოითხოვს ობიექტთა მთელი სისტემის გადამუშავებას. რა მოხდება, თუ მოგიწევთ დაწეროთ CallG, CallH? რა თქმა უნდა, C++ მხარს უჭერს მრავალჯერად მემკვიდრეობას, მაგრამ კლასის იერარქია ამ მიდგომით ბევრად უფრო გართულდება და აზრი არ აქვს მის შეცვლას „წინ და უკან“. მესამე მეთოდის უარყოფითი მხარეები არაერთხელ იქნა განხილული: CallF ფუნქცია უნდა გადაიწეროს, როდესაც შემოვა ახალი კლასი, რომელიც მხარს უჭერს f(-ს).


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


დასკვნა


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


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


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


ხშირად მოსახერხებელია ობიექტების კლასების სტრუქტურირება ისე, რომ ისინი ქმნიან იერარქიულ სტრუქტურას.


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


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


გამოყენებული ლიტერატურის სია

1. Arkhangelsky A. პროგრამირება დელფში Windows-ისთვის. ვერსიები 2006, 2007, Turbo Delphi + CD. –მ.: ბინომი. ცოდნის ლაბორატორია, 2006 წ.
   

   Arkhangelsky A. C++ ენა C++Builder-ში. ცნობარი და მეთოდოლოგიური სახელმძღვანელო. – მ.: ბინომი. ცოდნის ლაბორატორია, 2008 წ.
   

   Bucknell J. ფუნდამენტური ალგორითმები და მონაცემთა სტრუქტურები დელფში. პროგრამისტის ბიბლიოთეკა – სანკტ-პეტერბურგი: პეტრე, DiaSof, 2006 წ.
   

   გალისევი გ.ვ. კომპონენტები დელფიში 7. პროფესიული სამუშაო – მ.: უილიამსი, 2006 წ.
   

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

   2014-05-28

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

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

მაგრამ პროგრამირების რეალობა გაცილებით რთულია.

პროგრამირება დღეს

უცნაურია, მაგრამ კომპიუტერული პროგრამირების ჭეშმარიტად „გლობალური“ იდეების უმეტესობა ჯერ კიდევ 1950-იან და 60-იან წლებში განვითარდა. მას შემდეგ ბევრი ახალი ენა გამოჩნდა, მაგრამ არცერთი მათგანი არ ახორციელებს ჭეშმარიტად ახალ მიდგომას ლოგიკასა და გამოთვლებში.

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

ზოგიერთი ენა შექმნილია პროგრამირების კონკრეტული პრობლემების გადასაჭრელად (როგორიცაა PHP და SASS), გარკვეული ტიპის სისტემების სამართავად () ან კონკრეტულ გარემოში ან პლატფორმაში მუშაობისთვის (Java და JavaScript). ზოგიერთი ენა შეიქმნა სპეციალურად იმისთვის, რომ დამწყებთათვის დაეხმარონ პროგრამირების სწავლაში (BASIC და Scratch კლასიკური მაგალითებია).

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

შედარებით უახლესი განვითარება მოიცავს SOA-ს (სერვისზე ორიენტირებული არქიტექტურა) კონცეფციას. სერვისზე ორიენტირებული არქიტექტურა) და MVC (Model-View-Controller), ისევე როგორც ჩარჩოები, როგორიცაა , რომელიც საშუალებას აძლევს პროგრამისტებს მარტივად იმუშაონ ამ პარადიგმებში.

პროგრამირების ენების სია

პოპულარული პროგრამირების ენების, მარკირებისა და პროტოკოლების მზარდი სია. თითოეული მათგანის აღწერილობის ბმულები:

ASCII კოდირება

• სიმბოლოების კოდირება კომპიუტერისა და ინტერნეტის ერთ-ერთი ფუნდამენტური ასპექტია. ASCII არის პირველი ფართოდ გამოყენებული სიმბოლოების კოდირების სისტემა. ის ჩაანაცვლა UTF-8-მა, მაგრამ ASCII დღესაც არის ინტერნეტში არსებული პერსონაჟების დიდი უმრავლესობის საფუძველი. ამის გაგება ძალიან მნიშვნელოვანია პროგრამისტებისთვის. წაიკითხეთ მეტი აქ (ინგლისური):

ASP/ASP.NET

• ASP არის Active Server Pages-ის აბრევიატურა. ეს არის პირველი სერვერის სკრიპტირების ენა Microsoft IIS ვებ სერვერისთვის. ASP შეიცვალა ღია კოდის სერვერის მხარის ჩარჩოთი - ASP.NET. დამატებითი დეტალები (ინგლისური):

AutoLISP

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

ავკ

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

BASH

• Bash არის ყველაზე ხშირად გამოყენებული ბრძანების ხაზი Unix-ის სამყაროში. ეს არის ტექსტზე დაფუძნებული ნაგულისხმევი ინტერფეისი როგორც Linux-ისთვის, ასევე Mac OS X-ისთვის. წაიკითხეთ მეტი:

Common Lisp

• Lisp არის საკმაოდ უნიკალური პროგრამირების ენა, ალბათ უძველესი ენა და დღემდე გამოიყენება. ეს განსაკუთრებით მნიშვნელოვანია ხელოვნური ინტელექტის სფეროში. დამატებითი დეტალები (ინგლისური):

C

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

C++

• თავდაპირველად სახელწოდებით „C კლასებით“, C++ მრავალი თვალსაზრისით უბრალოდ C-ის უფრო მოწინავე მემკვიდრეა (თუმცა საერთო სიტუაცია უფრო რთულია). C++ შეიქმნა იმისათვის, რომ დაემატებინა მაღალი დონე C პროგრამირების პარადიგმაში და შენარჩუნებულიყო დაბალი დონის ტექნიკის მანიპულირების შესაძლებლობები. ამ დამატებიდან ბევრი დაემატა C-ს წლების განმავლობაში და ენები უფრო ჰგავს იმავე ენის ორ დიალექტს. დამატებითი დეტალები (ინგლისური):

C#

• გამოიყენება როგორც ძირითადი ენა .NET პროგრამირებისთვის, C++-ის მსგავსად, ის არის C პროგრამირების ენის გაფართოება, მაგრამ ობიექტზე ორიენტირებული შესაძლებლობების მნიშვნელოვანი დამატებით. დამატებითი დეტალები (ინგლისური):

CSS/CSS3

• CSS, ან Cascading Style Sheets, ასევე არ არის პროგრამირების ენა, არამედ გვერდის სტილის ენა - ენა, რომელიც უზრუნველყოფს დოკუმენტებისა და აპლიკაციების სტილისა და განლაგების წესებს. ეს არის მთავარი სტილის ენა, რომელიც გამოიყენება ინტერნეტში. დამატებითი დეტალები:

Emacs Lisp

• Emacs დიდი ხანია ცნობილია, როგორც პოპულარული და ძლიერი ტექსტური რედაქტორი. მაგრამ Emacs Lisp-ის დამატება მას აქცევს ინტეგრირებულ განვითარების გარემოდ თითქმის ნებისმიერი პროგრამირების ენისთვის. დამატებითი დეტალები (ინგლისური): .

F#

• F# არის ზოგადი დანიშნულების პროგრამირების ენა. შექმნილია უკიდურესად ეფექტური. თავდაპირველად მხოლოდ Microsoft-ის ენა იყო, ახლა ის არის ღია კოდის ენა და გამოიყენება ყველა პლატფორმაზე. დამატებითი დეტალები (ინგლისური): .

FORTAN

• Fortran პირველად 1957 წელს გამოჩნდა და დღემდე გამოიყენება თანამედროვე მეცნიერებისა და ტექნოლოგიების ზოგიერთი ყველაზე რთული პრობლემის გადასაჭრელად. დამატებითი დეტალები (ინგლისური):

მეოთხე

• Forth-ზე მუშაობა 1968 წელს დაიწყო და ენა ჩვეულებრივ გამოიყენება აპარატურაზე, რომელსაც არ გააჩნია ტრადიციული ოპერაციული სისტემა. იგი ასევე ფართოდ გამოიყენება ჩარხების სამართავად. დამატებითი დეტალები (ინგლისური):

ჰასკელი

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

HTML

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

IDL

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

INTERCAL

• INTERCAL არის პაროდიული კომპიუტერული ენა, რომელიც შეიქმნა 1970-იანი წლების დასაწყისში. იგი ხუმრობით შეიქმნა იმის საჩვენებლად, თუ რამდენად რთულია ენები ტექნიკურად და რთულად წასაკითხი. ეს არის ნამდვილი ენა, რომელიც შეგიძლიათ ჩამოტვირთოთ და რომლითაც შეგიძლიათ რაღაცის გაკეთებაც კი. ვარაუდობენ, რომ ამის გასაკეთებლად ძალიან კარგად უნდა იცოდეთ - მაგრამ, კიდევ ერთხელ, არც ისე კარგად, რადგან თავად INTERCAL-საც არ მოეწონება. დამატებითი დეტალები (ინგლისური):

ჯავა

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

Javascript

• JavaScript (არსებითად არ არის დაკავშირებული Java-სთან) არის სკრიპტირების ენა, რომელიც თავდაპირველად შეიქმნა ვებ ბრაუზერებში გამოსაყენებლად. აქედან გამომდინარე, მას აქვს ჩაშენებული შესაძლებლობა იმუშაოს Document Object Model-თან (DOM), ვებ გვერდის შინაარსის მეხსიერებაში წარმოდგენით. ეს არის მთავარი პროგრამირების ენა ვებ-გვერდის განვითარებისთვის. ის ძირითადად მოვლენებზეა ორიენტირებული და, Node.JS-ის წყალობით, ახლახან მოიპოვა აღიარება, როგორც სერვერის მხარის ენა. დამატებითი დეტალები (ინგლისური): და. და აქ:

ქშ

• Korn Shell (ksh) არის ბრძანების ხაზის ინტერფეისი, რომელიც გამოიყენება Unix-ზე. ეს იყო ადრეული გარსი, თავსებადი Bourne-ის სტანდარტულ გარსთან, მაგრამ C ჭურვის ყველა მაგარი ინტერაქტიული მახასიათებლით.

Linux პროგრამირება

• Linux-ის პროგრამირება მოიცავს ყველაფერს, დაწყებული ჭურვის სკრიპტირებიდან აპლიკაციის შემუშავებამდე და ბირთვის განვითარებამდე. დამატებითი დეტალები (ინგლისური):

ლოგო

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

მ.ლ.

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

MPI

• Message Passing Interface არის სტანდარტული პროტოკოლი შეტყობინებების გაგზავნისთვის პროცესებსა და პროგრამებს შორის. ის დანერგილია პროგრამირების უამრავ ენაზე, მათ შორის C, C++, Java და Python. MPI-ის წყალობით, პარალელური გამოთვლა შესაძლებელი გახდა. დამატებითი დეტალები (ინგლისური):

ქსელური პროგრამირება ინტერნეტ სოკეტებით

მიზანი-C

• C-ის კიდევ ერთი ვერსია, რომელიც შეიქმნა 1980-იან წლებში C-ის სრულად ობიექტზე ორიენტირებული იმპლემენტაციის უზრუნველსაყოფად. ენის ძირითადი გამოყენება დღეს არის Mac OSX და iOS ოპერაციულ სისტემებზე. ბოლო დრომდე iOS აპლიკაციები Objective-C-ში უნდა დაწერილიყო, მაგრამ ახლა Swift-შიც შეგიძლიათ დაწეროთ. დამატებითი დეტალები (ინგლისური):

OCaml

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

ოპერაციული სისტემის განვითარება

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

პერლ

• ძალიან სასარგებლო ინსტრუმენტი თითქმის ნებისმიერი პროგრამისტისთვის. როგორც ინტერპრეტირებული ენა, მას არ სჭირდება შედგენა, ზოგჯერ მოიხსენიება როგორც დამწერლობის ენების „შვეიცარიის არმიის დანა“. დამატებითი დეტალები (ინგლისური):

PROLOG

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

სუფთა მონაცემები

• Pure Data არის უნიკალური ვიზუალური პროგრამირების ენა. ის სპეციალურად შეიქმნა იმისათვის, რომ მომხმარებლებს საშუალება მისცენ შექმნან ვიდეო, აუდიო და გრაფიკული ნამუშევრები. დამატებითი დეტალები (ინგლისური): .

პითონი

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

Ruby on Rails

• Ruby on Rails არის ვებ განვითარების ჩარჩო Ruby პროგრამირების ენისთვის. ის უზრუნველყოფს MVC (Model View Controller) არქიტექტურას, მონაცემთა ბაზის აბსტრაქციის ფენას და ბევრ ინსტრუმენტს ვებ აპლიკაციების პროგრამირების პროცესის დასაჩქარებლად. ძალიან პოპულარულია ვებ აპლიკაციების სწრაფი განვითარებისთვის. დამატებითი დეტალები (ინგლისური):

SAS

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

სკალა

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

სქემა

• Scheme ძველი ენაა, მაგრამ მაინც გამოიყენება პროგრამირებისა და უფრო მოწინავე კომპიუტერული მეცნიერების საგნების სწავლებისთვის. ძირითადად დაფუძნებულია Lisp-ზე და ნაწილობრივ ALGOL-ზე. დამატებითი დეტალები (ინგლისური): .

ნაკაწრი

• Scratch პროგრამირების ენა შეიქმნა სპეციალურად 8-დან 16 წლამდე ბავშვებისთვის პროგრამირების სწავლებისთვის. Scratch მარტივია და ის საშუალებას აძლევს ბავშვებს სახალისო გზით ისწავლონ პროგრამირების ლოგიკის საფუძვლები. დამატებითი დეტალები (ინგლისური):

სიმულა

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

SMIL

• SMIL (Synchronized Multimedia Integration Language) არის ინსტრუმენტი იმ ადამიანებისთვის, ვისაც სურს შექმნას და გაავრცელოს პრეზენტაციები. განსაკუთრებით სასარგებლოა, თუ გსურთ შექმნათ პრეზენტაციები, რომლებიც დროდადრო უნდა განახლდეს. დამატებითი დეტალები (ინგლისური):

SQL

• SQL (Structured Query Language) არის ენა, რომელიც გამოიყენება ურთიერთობის მონაცემთა ბაზის მართვის სისტემებთან (RDBMS) კომუნიკაციისთვის. SQL საშუალებას აძლევს პროგრამისტს შექმნას მონაცემთა სტრუქტურები, ჩასვას და შეცვალოს მონაცემები და გამოიკითხოს ისინი. დამატებითი დეტალები (ინგლისური):

სტატა

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

სვიფტი

• Swift არის ახალი პროგრამირების ენა, რომელიც შემუშავებულია Apple-ის მიერ iOS, OS X, watchOS, tvOS და Linux-ისთვის. ეს არის მომავლის ენა Apple მოწყობილობების პროგრამებისა და აპლიკაციების შემქმნელებისთვის. დამატებითი დეტალები (ინგლისური):

S-PLUS

• S-PLUS არის ძლიერი S პროგრამირების ენის კომერციული ვერსია, რომელიც შექმნილია სტატისტიკური ანალიზის შესასრულებლად. GNU პროექტს აქვს S-ის საკუთარი ვერსია, სახელად R. ყველა საჭირო რესურსი S-ის შესახებ S-PLUS-ზე აქცენტით:

UNIX პროგრამირება

• Unix-ზე პროგრამირების სიგანე დიდია. ის მოიცავს დიაპაზონს ადმინისტრაციული სკრიპტებიდან ტექსტზე დაფუძნებულ კოდამდე X ფანჯრის განვითარებამდე. დამატებითი დეტალები (ინგლისური):

XML

• XML არის კარგად სტრუქტურირებული მარკირების ენა, რომელიც შექმნილია როგორც ადამიანის, ასევე მანქანით წაკითხვადი. დამატებითი დეტალები (ინგლისური):

გაკვეთილი მოამზადა: აკულოვ ივანე

თუ შეცდომას აღმოაჩენთ, მონიშნეთ და დააჭირეთ Ctrl + Enter! ჩვენთან დასაკავშირებლად შეგიძლიათ გამოიყენოთ.

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

კიდევ ერთი მაგალითია mpC ენა, რომელიც შემუშავებულია რუსეთის მეცნიერებათა აკადემიის სისტემური პროგრამირების ინსტიტუტში, როგორც ANSI C-ის გაფართოება. mpC-ის მთავარი მიზანია ჰეტეროგენული გამოთვლითი სისტემებისთვის ეფექტური პარალელური პროგრამების შექმნა. მომხმარებელს შეუძლია მიუთითოს ქსელის ტოპოლოგია, მონაცემთა და გამოთვლითი განაწილება და მონაცემთა საჭირო გადაცემა. შეტყობინების გაგზავნა ორგანიზებულია MPI ინტერფეისის გამოყენებით.

DVM სისტემა შექმნილია პორტატული და ეფექტური გამოთვლითი აპლიკაციების შესაქმნელად C-DVM და Fortran-DVM ენებზე სხვადასხვა არქიტექტურის პარალელური კომპიუტერებისთვის. აბრევიატურა DVM შეესაბამება ორ ცნებას: განაწილებული ვირტუალური მეხსიერება და განაწილებული ვირტუალური მანქანა. პირველი ასახავს ერთი მისამართის სივრცის არსებობას. მეორე ასახავს ვირტუალური მანქანების გამოყენებას ორეტაპიანი სქემისთვის მონაცემების რუკების და გამოთვლების რეალურ პარალელურ მანქანაზე. პროგრამირების მოდელი გულისხმობს DVM ინსტრუქციების დაზუსტებას სპეციალური კომენტარების გამოყენებით, რაც გულისხმობს პროგრამის ერთ ვერსიას თანმიმდევრული და პარალელური შესრულებისთვის. მხარდაჭერილია დირექტივების სამი ჯგუფი: მონაცემთა განაწილების დირექტივები, გამოთვლითი განაწილების დირექტივები და დისტანციური მონაცემების სპეციფიკაციები. შემდგენელი თარგმნის პროგრამას Fortran ან C ენაზე, იყენებს ერთ-ერთ არსებულ პარალელური პროგრამირების ტექნოლოგიას (MPI, PVM, Router) ინტერპროცესორული ურთიერთქმედების ორგანიზებისთვის. DVM სისტემა ასევე მოიცავს LIB-DVM მხარდაჭერის ბიბლიოთეკას, DVM გამართვას, DVM პროგრამის შესრულების პროგნოზს და DVM პროგრამის შესრულების ანალიზატორს. სისტემა შეიქმნა გამოყენებითი მათემატიკის ინსტიტუტში. M.V.Keldysh RAS.

სპეციალური პროგრამირების ენები

თუ საჭიროა უფრო ზუსტად აისახოს პარალელური სისტემების არქიტექტურის სპეციფიკა, ან გარკვეული კლასის პრობლემების თვისებები გარკვეულ საგნობრივ სფეროში, მაშინ გამოიყენება სპეციალური პარალელური პროგრამირების ენები. Occam ენა შეიქმნა ტრანსპუტერული სისტემების პროგრამირებისთვის, ხოლო ერთი დავალებითი ენა Sisal განკუთვნილი იყო ნაკადის მანქანების პროგრამირებისთვის. ძალიან საინტერესო და ორიგინალური განვითარებაა დეკლარაციული ენა NORM, რომელიც შეიქმნა I.B. Zadykhailo-ს ხელმძღვანელობით, გამოყენებითი მათემატიკის ინსტიტუტში. M.V.Keldysh RAS აღწერს გამოთვლითი პრობლემების გადაწყვეტას ბადის მეთოდების გამოყენებით. ენის აბსტრაქციის მაღალი დონე საშუალებას გაძლევთ აღწეროთ პრობლემები მათემატიკოსის მიერ პრობლემის თავდაპირველ ფორმულირებასთან ახლოს ნოტაციით, რომელსაც ენის ავტორები პირობითად უწოდებენ პროგრამირებას პროგრამისტის გარეშე. ერთი დავალების ენა არ შეიცავს პროგრამირების ენების ტრადიციულ კონსტრუქტებს, რომლებიც აფიქსირებს გამოთვლის თანმიმდევრობას და ამით მალავს ალგორითმის ბუნებრივ პარალელიზმს.

ბიბლიოთეკები და ინტერფეისები, რომლებიც მხარს უჭერენ ურთიერთქმედებას პარალელურ პროცესებს შორის

მასიურად პარალელური კომპიუტერების მოსვლასთან ერთად ფართოდ გავრცელდა ბიბლიოთეკები და ინტერფეისები, რომლებიც მხარს უჭერენ პარალელური პროცესების ურთიერთქმედებას. ამ მიმართულების ტიპიური წარმომადგენელია Message Passing Interface (MPI), რომლის დანერგვა ხელმისაწვდომია თითქმის ყველა პარალელურ პლატფორმაზე, დაწყებული ვექტორული მილსადენის სუპერკომპიუტერებიდან დაწყებული პერსონალური კომპიუტერების კლასტერებამდე და ქსელებამდე. თავად პროგრამისტი ცალსახად განსაზღვრავს რომელი პარალელური აპლიკაციის პროცესები პროგრამის რომელ ადგილას და რომელ პროცესებთან უნდა გაცვალოს მონაცემები ან მოახდინოს მათი მუშაობის სინქრონიზაცია. ჩვეულებრივ, პარალელური პროცესების მისამართის სივრცეები განსხვავებულია. კერძოდ, MPI და PVM ამ იდეოლოგიას მისდევენ. სხვა ტექნოლოგიები, როგორიცაა Shmem, საშუალებას იძლევა გამოიყენონ როგორც ლოკალური (პირადი) ცვლადები, ასევე გაზიარებული (გაზიარებული) ცვლადები, რომლებიც ხელმისაწვდომია აპლიკაციის ყველა პროცესისთვის, და ახორციელებს საზიარო მეხსიერებასთან მუშაობის სქემას Put/Get ოპერაციების გამოყენებით.

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

პარალელური საგნობრივი ბიბლიოთეკები

ხშირად პრაქტიკაში, აპლიკაციის პროგრამისტები საერთოდ არ იყენებენ რაიმე გამოკვეთილ პარალელურ კონსტრუქტებს, მიმართავენ პარალელური საგნების ბიბლიოთეკების ქვეპროგრამებსა და ფუნქციებს დროის კრიტიკულ ფრაგმენტებში. ყველა პარალელიზმი და ყველა ოპტიმიზაცია იმალება ზარებში და მომხმარებელს შეუძლია დაწეროს მხოლოდ მისი პროგრამის გარე ნაწილი და კომპეტენტურად გამოიყენოს სტანდარტული ბლოკები. ასეთი ბიბლიოთეკების მაგალითებია Lapack, ScaLapack, Cray Scientific Library, HP Mathematical Library, PETSc და მრავალი სხვა.

რამდენიმე პარალელური საგნობრივი ბიბლიოთეკა

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

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

FFTW, DFFTPack - სწრაფი ფურიეს ტრანსფორმაცია.

PETSc არის პროცედურებისა და მონაცემთა სტრუქტურების ერთობლიობა მეცნიერული პრობლემების პარალელურად გადასაჭრელად მოდელებით, რომლებიც აღწერილია ნაწილობრივი დიფერენციალური განტოლებების სახით.

სპეციალიზებული პაკეტები და პროგრამული სისტემები

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

GPU-ები ახლა სულ უფრო ხშირად გამოიყენება გამოთვლითი პრობლემების გადასაჭრელად, მაგრამ კითხვა ჯერ კიდევ ღიაა: როგორ დავწეროთ ეფექტური პროგრამები შესაბამისი კონფიგურაციისთვის?

06/15/2011 ანდრეი ადინეც

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

სულ რაღაც სამი წლის წინ, გრაფიკული დამუშავების ერთეულები (Graphical Processing Unit, GPU) განიხილებოდა მხოლოდ კომპიუტერების ვიდეო ბარათად, მაგრამ ახლა მათ მიმართ დამოკიდებულება შეიცვალა - გამოჩნდა სპეციალური სერვერის GPU მოდელები, რომლებიც ორიენტირებულია გამოთვლითი პრობლემების გადაჭრაზე, გაიზარდა პროდუქტიულობა. ორმაგი სიზუსტის გამოთვლებით, სისტემებმა მიაღწიეს რეკორდულ მაჩვენებელს, დაიკავა Top500-ის სათავეში. როგორ დავწეროთ ეფექტური პროგრამები ასეთი მანქანებისთვის? სტანდარტული პასუხი არის CUDA ან OpenCL-ის კომბინაცია კლასტერულ დონეზე GPU-სა და MPI-ის პროგრამირებისთვის. ეს ხელსაწყოები ხელმისაწვდომია, მათ აქტიურად უჭერენ მხარს აღჭურვილობის მწარმოებლები და ბევრი პროგრამა უკვე დაწერილია მათთვის, მაგრამ ასევე არის უარყოფითი მხარეები.

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

ასეთი ხელსაწყოების შექმნა შესაძლებელია სხვადასხვა გზით: ახალი პროგრამირების ენის დანერგვა; დაამატეთ დირექტივები არსებულ ენაზე, როგორც ეს კეთდება PGI Accelerator-ში ან CAPS HMPP მოდელში; ისარგებლეთ გაფართოებადი ენებით. გაფართოებადი ენები- პროგრამირების ენები, რომელთა სინტაქსი და სემანტიკა არ არის დაფიქსირებული, მაგრამ შეიძლება შეიცვალოს პროგრამისტის საჭიროებიდან გამომდინარე. ტრადიციულ ენებთან შედარებით, გაფართოებულ ენებს აქვთ მრავალი უპირატესობა: უფრო ადვილია მათში ახალი ფუნქციების დამატება; ისინი ღიაა; ასეთ ენებზე დაფუძნებული პროგრამირების ახალი მოდელების სწავლა უფრო ადვილია, რადგან მხოლოდ შედარებით მცირე გაფართოებების სწავლაა საჭირო; ასეთი ენების დახმარებით უფრო ადვილია პროგრამების დაზუსტება და ოპტიმიზაცია.

გაფართოებადი ენები

იმისათვის, რომ ენა იყოს გაფართოებული, ის უნდა შეიცავდეს:

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

გამოდის, რომ შედარებით ცოტა ენაა, რომელიც აკმაყოფილებს ამ მოთხოვნებს: Lisp, Nemerle, Seed7, xoc და Stratego. ამავდროულად, xoc, რომელიც გამიზნულია C ენის გასავრცელებლად, იყენებს ცალკე ენას Zeta გაფართოებების დასაწერად, ხოლო Stratego არის დომენის ენა წყარო კოდის გადამყვანების შესაქმნელად. Nemerle არის გაფართოებადი ენა, რომელიც იყენებს ჩარჩოს. წმინდა.

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

ნემერლის ენა ამისთვის იყენებს კონსტრუქციას, მაგალითად ქმნის ხეს, რომელიც შედგება i ცვლადის დეკლარაციისგან, საწყისი მნიშვნელობით 0. კვაზი-კოტირება მსგავსია სიმებიანი ობიექტების შექმნისას სიმებიანი მუდმივებით. ნახ. 1 გვიჩვენებს კვაზიციტირების მაგალითს. ინტერპოლაციის კონსტრუქცია საშუალებას აძლევს ცვლადი მნიშვნელობების ჩანაცვლებას ფიქსირებულ შაბლონში კვაზი ციტატის ფარგლებში. Nemerle-ში ამისთვის გამოიყენება $(...) კონსტრუქციები, თუ საჭიროა სიის ჩანაცვლება, მაგალითად. გაფართოებადი ენები ასევე შეიცავს პროგრამის ხის ანალიზების კონსტრუქციებს. ნემერლის ენაში ამისათვის გამოიყენება match(...) ( ... ) ოპერატორი, C ენიდან გადართვის ანალოგი, რომლის ტოტები კვაზი-კოტირების კონსტრუქტებია. ამ შემთხვევაში, ინტერპოლაცია განიმარტება, როგორც ახალი ცვლადების დეკლარაცია, რომლებიც, თუ შედარება წარმატებულია, იღებენ შესაბამისი ქვეხეების მნიშვნელობებს. მაგალითად, შესატყვისი ოპერატორის match(e) (| => ... ), თუ e შეიცავს ხეს, ის გადავა a ცვლადში და b ცვლადში.

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

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

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

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

როგორ გამოვიყენოთ ენები?

გაფართოებადი პროგრამირების ენისთვის შეგიძლიათ დაწეროთ კონსტრუქციები, რომლებიც საშუალებას მოგცემთ დააპროგრამოთ GPU ყველაზე მოსახერხებელი გზით, რაც გაკეთდა NUDA (Nemerle Unified Device Architecture) პროექტის ფარგლებში, რომლის მიზანია Nemerle ენის გაფართოებების შექმნა. GPU პროგრამირებისთვის. OpenCL გამოიყენება როგორც ინტერფეისი GPU-სთან ურთიერთობისთვის და პროგრამის წარდგენის სამიზნე ენად.

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

ყველაზე ხშირად, მარყუჟის სხეული გამოიყენება როგორც ბირთვი GPU-სთვის, ამიტომ მსურს დაუყოვნებლივ გადავიტანო ციკლი GPU-ზე. ეს შეიძლება განხორციელდეს Nemerle-ში - NUDA-ში შესაბამის მაკროს ეწოდება nuwork. ის იღებს ძაფის ბლოკის ზომას, როგორც საჭირო პარამეტრებს და, ამჟამინდელი კონტექსტისა და მარყუჟის სხეულის კოდის ანალიზის საფუძველზე, განსაზღვრავს ცვლადების ერთობლიობას, რომელიც უნდა გადაეცეს ბირთვს, როგორც პარამეტრები. ბირთვის სხეული იქმნება მარყუჟის სხეულისგან, მარყუჟის ინდექსების გაანგარიშებით გლობალური ძაფის ნომრის მეშვეობით, ისევე როგორც პირობა, რომელიც საშუალებას აძლევს მარყუჟს სწორად შესრულდეს მაშინაც კი, როდესაც გლობალური ბადის ზომა არ იყოფა ზომაზე. ძაფების ჯგუფიდან. მარყუჟი შეიცვალა ზარით nucall მაკროზე, რომელიც იძახებს გენერირებულ ბირთვს.

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

ნახ. მარცხნივ 4 არის ჩვეულებრივი მასივის დამატების პროგრამა, ხოლო მარჯვნივ არის მსგავსი პროგრამა, მაგრამ ახორციელებს გამოთვლებს GPU-ზე. GPU პროგრამების მიღება ჩვეულებრივიდან საკმაოდ მარტივია - საჭიროა მხოლოდ მაკროების გამოყენება მარყუჟებზე და მეხსიერების განაწილების ოპერაციებზე, ხოლო კოდის რაოდენობა პრაქტიკულად უცვლელი რჩება. NUDA-ს გამოყენებით დაწერილი პროგრამა იღებს 20 სტრიქონზე ნაკლებ კოდს. მსგავსი პროგრამა, მაგრამ სუფთა C-ში და OpenCL-ში იღებს 100-ზე მეტ ხაზს.

გარდა მაკროებისა, რომლებიც აადვილებენ GPU-სთან მუშაობას, NUDA გაფართოების სისტემა ასევე შეიცავს ანოტაციებს მარყუჟის კონვერტაციისთვის. ანოტაციები არსებითად სპეციალური მაკროებია. მაგალითად, inline ანოტაცია გამოიყენება მარყუჟზე ფიქსირებული რაოდენობის გამეორებებით და მთლიანად ხსნის მას. dmine ანოტაცია ასრულებს ღრმა მარყუჟის გაშლას. „ღრმა გადახვევა“ ნიშნავს, რომ მარყუჟის სხეულის მრავალი ასლის შექმნა და გადარევა ხორციელდება არა მხოლოდ გარდაქმნილი მარყუჟისთვის, არამედ წყობილი მარყუჟებისთვისაც, თუ ისინი დამოუკიდებელია.

ეფექტი

რატომ სჭირდება პროგრამისტს ახალი ენის სწავლა და გაფართოებადი ენების ახალი ბიბლიოთეკების დაუფლება? მთავარი პასუხი პროდუქტიულობაა. მასივებით მომუშავე პარალელური მარყუჟების ალგორითმი და ნემერლის ენაზე დაწერილი, საკმარისია დაამატოთ რამდენიმე ანოტაცია GPU-სთვის პროგრამის მისაღებად. ამ შემთხვევაში, პროგრამა იმუშავებს ნებისმიერ მოწყობილობაზე, რომელსაც აქვს OpenCL-ის მხარდაჭერა, მათ შორის nVidia და AMD GPU, ასევე x86 პროცესორები. იმავეს მისაღწევად მხოლოდ OpenCL ან CUDA ტექნოლოგიების გამოყენებით, თქვენ მოგიწევთ მნიშვნელოვნად მეტი რესურსის დახარჯვა, რომელიც დაიხარჯება არა მხოლოდ კოდის ჩაწერაზე, არამედ ჰოსტსა და GPU-ს შორის ურთიერთქმედების გამართვაზე.

კიდევ ერთი მიზეზი არის გენერირებული კოდის შესრულება. CUDA-ზე ან OpenCL-ზე, მარყუჟის კონვერტაცია უნდა განხორციელდეს ხელით და ცალ-ცალკე თითოეული არქიტექტურისთვის. ეს ხანგრძლივი და შეცდომისკენ მიდრეკილი პროცესია და შედეგად მიღებული კოდი ძნელად იკითხება და შეუძლებელი. NUDA-სთან ერთად, ეს სამუშაო შეიძლება შესრულდეს ანოტაციების გამოყენებით. მაგალითად, რამდენიმე ბირთვისთვის, შეგიძლიათ ოპტიმიზაცია გაუკეთოთ გამოსახულების კონვოლუციის ან მატრიცის გამრავლების ფუნქციონირებას inline და dmine ანოტაციების გამოყენებით. წყაროს კოდის ზომის გაზრდის გარეშე, თქვენ შეგიძლიათ მიაღწიოთ შესრულების ორჯერ ხუთჯერ. უფრო მეტიც, თუ იგივე გარდაქმნები შესრულდა ხელით, ეს გამოიწვევს კოდის რამდენჯერმე გაზრდას, ზოგჯერ კი სიდიდის ბრძანებით, რომ აღარაფერი ვთქვათ გამართვისა და ოპტიმალური სკანირების პარამეტრების არჩევაზე დახარჯულ დროს. მაგალითად, ზოგადი შვიდსტრიქონიანი ანოტაციური პროგრამა NUDA-ში ორმაგი სიზუსტით ტრანსპონირებული მატრიცა-მატრიცის გამრავლებისთვის მუშაობს nVidia Tesla C2050-ზე მხოლოდ 40%-ით ნელა, ვიდრე ამჟამად ყველაზე სწრაფი განხორციელება (CUBLAS 3.2). ხელით დაწერილი მსგავსი პროგრამა მიიღებს 70 ხაზს კოდს. ბუნებრივია, სტანდარტული ამოცანებისთვის, თქვენ შეგიძლიათ ხელით დაწეროთ კოდი ერთხელ პროდუქტიულობის გაზრდის მიზნით, მაგრამ კონკრეტული ამოცანებისთვის, შრომის ხარჯების შემცირება და პროდუქტიულობის გაზრდა ძალიან სასარგებლო იქნება. დაბოლოს, პროდუქტიულობის ზრდა ასევე ეხება თავად გაფართოებების შექმნას: მათი შექმნა უფრო ადვილია გაფართოებადი ენების გამოყენებით, ვიდრე ტრადიციული ინსტრუმენტების გამოყენებით. მთელი NUDA სისტემა, მიუხედავად მისი ფუნქციონალურისა, იღებს მხოლოდ 12 ათას ხაზს კოდს, ტესტებს არ ითვლიან. ეს შედარებით ცოტაა, მაგალითად, Nemerle ენის შემდგენელი (build 9025) იღებს დაახლოებით 130 ათას სტრიქონს.

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

ანდრეი ადინეცი([ელფოსტა დაცულია]) - უმცროსი მეცნიერ-თანამშრომელი მოსკოვის სახელმწიფო უნივერსიტეტის კვლევითი კომპიუტერული ცენტრი (მოსკოვი).

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

რა გაფართოება აქვს C plus plus-ს?

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

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

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

მაინც რა არის ფაილის სახელის გაფართოება?

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

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

გაფართოებაში მოცემული ინფორმაციის სიზუსტე

ზოგჯერ გაფართოება ზუსტად არ მიუთითებს ფაილის ტიპზე და არ წყვეტს ყველა შესაძლო პრობლემას, რომელიც შეიძლება წარმოიშვას სხვადასხვა პროგრამის გამოყენებისას. ამრიგად, ბევრისთვის ნაცნობი .txt გაფართოება არ აწვდის ინფორმაციას კომპიუტერს იმის შესახებ, თუ რაშია ფაილი კოდირებული. ამიტომ, ხშირად ტექსტური ფაილების გახსნისას შეგიძლიათ იხილოთ გაუგებარი სიმბოლოების ფურცლები. განსაკუთრებით სამწუხაროა დოკუმენტის ასეთი მდგომარეობის ნახვა, თუ იგი გამოიყენებოდა პროგრამის კოდის დასაწერად. ასეთ შემთხვევებში, ფაილის კოდირება უნდა შეიცვალოს მანამ, სანამ კომპიუტერი არ უზრუნველყოფს ადეკვატურ ტექსტს. თქვენ შეგიძლიათ სცადოთ გამოთვალოთ საჭირო კოდირება არასწორი სიმბოლოების საფუძველზე, მაგრამ თქვენ უნდა იცოდეთ რომელი კოდირება იწვევს რასთან მიმართებაში. Word ფაილებისთვისაც გამოიყენება იგივე გაფართოება, რომელიც არ ასახავს, ​​რომელ ფაილთან აქვს საქმე: ჩვეულებრივ ტიპს თუ ფორმატირებულს. გაფართოება ასევე არ მიუთითებს იმაზე, თუ რომელი ვერსია გამოიყენება, რაც სასარგებლოა, როდესაც ცდილობთ ადრინდელი დოკუმენტების ვერსიების გახსნას მოგვიანებით დამუშავების გარემოში, როგორც ეს არის Microsoft Office-ის შემთხვევაში.

ფორმატის მითითების სხვა გზები და ვარიანტები

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

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