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

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

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

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

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

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

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

 ისტორია 

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

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

 1960-იანი და 1970-იანი წლები 
მინი|ორი ადამიანი იყენებს IBM 704 მეინფრეიმი — პირველი მოწყობილობა მცურავი წერტილის არითმეტიკის მხარდაჭერით — 1957 წელს. Fortran შეიქმნა ამ მოწყობილობისთვის.
დაახლოებით 1960 წლისთვის, შეიქმნა პირველი მეინფრეიმები — ზოგადი დანიშნულების კომპიუტერები, თუმცა მისი ოპერირება მხოლოდ პროფესიონალების მიერ იყო შესაძლებლი და ფასიც ძალიან მაღალი ჰქონდა. მონაცემები და ინსტრუქციები შეიტანებოდა ბეჭდური ბარათებით, პროგრამის მუშაობის დროს შეტანა ვერ ხერხდებოდა. შესაბამისად, იმ პერიოდში შექმნილი ენები დაპროექტებული იყო მინიმალური ურთიერთქმედებისთვის. მიკროპროცესორის გამოგონების შემდეგ, 1970-იან წლებში კომპიუტერები მკვეთრად გაიაფდა. ახალი კომპიუტერები ასევე უფრო მეტ მომხმარებლის ურთიერთქმედების საშუალებას იძლეოდა, რაც უფრო და უფრო მეტი ახალი პროგრამირების ენების შექმას მხარსუჭერდა.

Lisp, რომელიც შეიქმნა 1958 წელს, იყო პირველი ფუნქციური პროგრამირების ენა. Fortran-სგან განსხვავებით, ის მხარს უჭერდა რეკურსიისა და პირობით გამოხატვას, ასევე დინამიური მეხსიერების მენეჯმენტი Heap_ით და ავტომატური მენეჯმეტი Garbage Collection_ით. შემდეგი ათწლეულების განმავლობაში, Lisp დომინირებდა ხელოვნურ ინტელექტში. 1978 წელს, სხვა ფუნქციურმა ენამ, ML_მა, შემოიღო დასკვნითი ტიპები და პოლიმორფული პარამეტრები.

ALGOL (ALGOrithmic Language) გამოშვებული იქნა 1958 და 1960 წლებში, რამაც ის გახადა სტანდარტი კომპიუტერულ ლიტერატურაში ალგორითმების აღსაწერად. მიუხედავად იმისა, რომ მისი კომერციული წარმატება შეზღუდული იყო, პოპულარული იმპერატიული ენები — მათ შორის C, Pascal, Ada, C++, Java და C# - პირდაპირად ან არაპირდაპირად მომდინარეობდა ALGOL 60-დან. იმ ინოვაციებს შორის, რომლებიც მიღებული იქნა შემდგომი პროგრამირების ენების მიერ, იყო უფრო პორტატული და კონტექსტ-თავისუფალ, BNF გრამატიკის მხარდაჭერა. Simula, პირველი ენა, რომელმაც მხარი დაუჭირა ობიექტ-ორიენტირებულ პროგრამირებას (მათ შორისაა ქვეტიპები, დინამიური დისპეჩერიზაცია და მემკვიდრეობა), ასევე მომდინარეობს ALGOL-დან და მიაღწია კომერციულ წარმატებას. C, ALGOL-ის სხვა შთამომავალი, ინარჩუნებს პოპულარობას ოცდამეერთე საუკუნეშიც, უფრო მეტ წვდომას იძლევა დაბალი დონის მანქანურ ოპერაციებზე, ვიდრე სხვა ნებისმიერი თანამედროვე ენა. მისი სიძლიერე და ეფექტურობა, რომელიც ნაწილობრივ მოდის მოქნილი პოინტერის ოპერაციებისგან, ხდება კოდის დაწერის გართულების ხარჯზე.

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

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

1990-იან წლებში ინტერნეტისა და Word Wide Web-ის სწრაფი განვითარების გამო, შემოვიდა ახალი პროგრამირების ენები ვებ-გვერდებისა და ქსელური კავშირების მხარდასაჭერად. Java, რომელიც დაფუძნებულია C++-ზე და დაპროექტებულია პორტატულობისა და უსაფრთხოების ზრდისთვის, დიდი წარმატება მოიპოვა, რადგან ეს თვისებები არსებითია მრავალი ვებ-აპლიკაციისთვის. სხვა განვითარება წარმოიშვა დინამიურად დაწერილსკრიპტულ ენებში — Python, JavaScript, PHP და Ruby — რომლებიც დაპროექტებული იყვნენ მცირე პროგრამების სწრაფად შესაქმნელად, რომლებიც კოორდინირებას უწევენ არსებულ აპლიკაციებს. HTML-თან ინტეგრაციის შედეგად, ისინი ასევე გამოიყენება ვებ-გვერდების შესაქმნელად.

 2000-იანი წლებიდან დღემდე 
2000-იან წლებში შეინიშნებოდა ახალი პროგრამირების ენების განვითარების შეფერხება; რომლებმაც ფართო პოპულარობა მოიპოვეს. ერთ-ერთი ინოვაციური იყო სერვის-ორიენტირებული პროგრამირება, რომელიც შექმნილი იყო დისტრიბუციულ სისტემებთან სამუშაოდ, რომელთა კომპონენტები დაკავშირებული იყო ქსელთან. სერვისები ჰგავდნენ ობიექტებს ობიექტ-ორიენტირებულ პროგრამირებიდან, მაგრამ მუშაობდნენ ცალკეულ პროცესებზე. C# და F# იმპერატიულ და ფუნქციურ პროგრამირებას შორის იყვნენ. 2010 წლის შემდეგ, რამდენიმე ახალი ენა — Rust, Go, Swift, Zig და Carbon — იბრძოდნენ იმ კრიტიკული პროგრამული უზრუნველყოფისთვის მისაღწევად, რომლისთვისაც ისტორიულად C გამოიყენებოდა. ახალი პროგრამირების ენათა უმეტესობა იყენებს სტატიკურ ტიპიზაციას, ხოლო ზოგიერთი ახალი ენა იყენებს დინამიურ ტიპიზაციას, როგორიცაა Ring და Julia.

ახალი პროგრამირების ენების ნაწილი კლასიფიცირებულია, მაგ. ვიზუალური პროგრამირების ენები, როგორიცაა Scratch, LabVIEW და PWCT. ასევე, ზოგიერთი ენა ერთვის ტექსტურ და ვიზუალურ პროგრამირებას, როგორიცაა Ballerina. ამ ტენდენციამ ასევე გამოიწვია ახალი VPL_ების შემუშავება, როგორიცაა Google_ის Blockly. მრავალი თამაშის ძრავა, როგორიცაა Unreal და Unity, ასევე ვიზუალური სკრიპტირების მხარდაჭერა.

 სინტაქსი 
ენების უმრავლესობას აქვს ტექსტური სინტაქსი. იგი პროგრამირების ენის ელემენტების სწორად ჩაწერას განსაზღვრავს. (იხ. ასევე C-ის მსგავსი სინტაქსი)

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

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

*