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

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

მთარგმნელი.

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

არსებობს 3 ეტაპი:

კომპილაცია – ობიექტის ფაილის შექმნა *.obj

დაკავშირება USES-ის გამოყენებით

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

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

თაობები:

I 50x 1st ასამბლეის ენა, დამზადებულია 1 სტრიქონი 1 ინსტრუქციის პრინციპით. (არასიმბოლური)

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

III 60-იანი წლები გაჩნდა მაღალი დონის ენები Fortran, Basic, Pascal და ა.შ. მკვეთრად გაიზარდა პროგრამისტების პროდუქტიულობა.

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

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

პროგრამირების სისტემა:

შეიცავს ყველაფერს, რაც გჭირდებათ პროგრამების შესაქმნელად და გამართვისთვის

ტექსტის რედაქტორი

შემდგენელი (თარგმნა მაღალი კოდიდან მანქანის კოდზე) საერთო თავსებადი გაფართოება *.obj

საკომუნიკაციო რედაქტორი – ლინკერი (ლინკი).

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

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

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

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

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

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

Fortran არის წმინდა საინჟინრო ენა. პროგრამები ძალიან კომპაქტურია. ენა გამოიყენება მხოლოდ პროფესიონალურად

CABOL - ბუღალტრული აღრიცხვის ენა არის ინგლისური. რუს. ვერსიები

Algol (68) - გამიზნული იყო Fotran-ის ჩანაცვლება, მაგრამ სტრუქტურის სირთულის გამო მას არ მიუღია განაწილება

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

C - თავდაპირველად შემუშავებული როგორც მასობრივი პროდუქტი და დაგეგმილია ასმ-ის ჩანაცვლება, აქვს დამატებითი ფუნქციები

C++ - C-ის ობიექტზე ორიენტირებული გაფართოება

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

პროგრამირების ენები ინტერნეტისთვის – html, perl, vrml

ვიზუალური ჭურვები:

Basic - მსოფლიოში პოპულარობით პირველი ადგილი სწავლისთვის შეიქმნა Microsoft Visual Basic

Pascal – Delphi – პოპულარულია Borland Delphi მონაცემთა ბაზასთან მუშაობისთვის

Html, perl, php – ინტერნეტისთვის

C++ Borland C++ Builder

ჯავა Symantec კაფე (მობილური ტელეფონები, საყოფაცხოვრებო ტექნიკა)

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

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

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

არსებობს 3 ეტაპი:

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

კომპილაცია – ობიექტის ფაილის შექმნა *.obj, *.tpu

დაკავშირება – ქმნის შესრულებად *.exe ფაილს

შესრულება - ეტაპებით ჩამოყალიბებული შედეგი

Delphi-ში შედგენის შემდეგ ვიღებთ *.dcu გაფართოებას - სტატიკური ბიბლიოთეკა

დაკავშირება USES-ის გამოყენებით

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

ცოტა ისტორია

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

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

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

პირველი ალგორითმული პროგრამირების ენის, Algol-ის შექმნით, ალგორითმების განვითარება მნიშვნელოვნად დაჩქარდა.

რა არის ალგორითმი

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

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

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

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

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

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

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

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

განსხვავებები მანქანასა და ალგორითმულ ენებს შორის

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

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

საკვანძო სიტყვები

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

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

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

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

დამატებითი ფუნქციური სიტყვები

სიტყვების შემდეგი სია გამოიყენება განშტოების და მარყუჟის მექანიზმების ორგანიზებისთვის.

ამისთვის. გამოიყენება გარკვეული დიაპაზონის ყველა მნიშვნელობის გასამეორებლად. გამოიყენება ციკლებისთვის, ანუ მონაცემებით ნებისმიერი პროცედურის უწყვეტი შესრულებისთვის.
დან და. მიუთითებს მნიშვნელობების რომელი კონკრეტული დიაპაზონი უნდა განმეორდეს "for" მარყუჟში.
Ნახვამდის. ასევე გამოიყენება რამდენიმე მნიშვნელობის გამეორებისთვის. გამოიყენება გარკვეული პირობის დაკმაყოფილებამდე სამუშაოდ.
ნწ და ქც. "ნც" ალგორითმულ ენაზე ნიშნავს მარყუჟის სხეულის დასაწყისს, ხოლო "kts" ნიშნავს დასასრულს. ამ ორ საკვანძო სიტყვას შორის ჩაშენებულია გაანგარიშებისთვის საჭირო პროცედურები.
თუ.ეს სიტყვა ახორციელებს განშტოების სტრუქტურას. ამ გზით, პირობების გათვალისწინებით, შესაძლებელია განისაზღვროს პროგრამის მიმდინარეობა სასურველი მიმართულებით.
Ასეა თუ ისე. ორი სიტყვა, რომელიც მუშაობს "თუ". აგებულია განშტოების მექანიზმიც.
არჩევანი. მოსახერხებელი ინსტრუმენტი იმავე ტიპის რამდენიმე მნიშვნელობიდან განშტოებისთვის. მუშაობს საკვანძო სიტყვასთან ერთად "at" და "სხვაგვარად".
ყველა. მიუთითებს განშტოების მექანიზმის დასასრულს.
შედი. ეს საკვანძო სიტყვა საშუალებას აძლევს მომხმარებელს შეიყვანოს ცვლადი მნიშვნელობები პროგრამის მუშაობის დროს შემდგომი დამუშავებისთვის.
დასკვნა.აჩვენებს მონაცემებს ეკრანზე.

ძირითადი ენის სტრუქტურები

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

შემდეგი სტრუქტურა

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

alg ორი რიცხვის ჯამი (arg int a, b, res int in S)

გამომავალი "S =", S

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

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

განშტოების სტრუქტურა

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

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

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

წინააღმდეგ შემთხვევაში y = 0

ანუ, იმ შემთხვევაში, როდესაც x არ არის ნულის ტოლი, y ასევე გადაიტვირთება ნულზე, მიუხედავად იმისა, თუ რა მნიშვნელობა ჰქონდა ადრე.

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

x = 0-ზე: y = 0

x = 1-ზე: y = 1

x = 2-ზე: y = 2

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

ციკლები

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

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

nts ნახვამდის x<= 3

ამ მაგალითში, y გაიზრდება მანამ, სანამ x არ გახდება 3-ზე მეტი. იმისათვის, რომ მარყუჟი არ იყოს უსასრულო, x უნდა შეიცვალოს ზევით ყოველ გადასასვლელში, მაგალითად 1-ით, რასაც აკეთებს კოდის მეორე ხაზი.

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

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

nc x-ისთვის 1-დან 3-მდე

მომსახურების სიტყვები "-დან" და "მდე" აჩვენებს მნიშვნელობების დიაპაზონს, რომელიც უნდა განმეორდეს. ამრიგად, პირველ განმეორებაში x = 1, გავლის შედეგად, y ასევე შეიძენს მნიშვნელობას 1. შემდეგ კონტროლი კვლავ გადავა დასაწყისში და x ახლა იქნება 2-ის ტოლი, შესაბამისად, y გახდება 3.

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

სტანდარტული მახასიათებლები

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

აბსოლუტური მოდული - abs(x);
კვადრატული ფესვი - sqrt(x);
ბუნებრივი და ათობითი ლოგარითმები - ln(x) და log(x);
მინიმალური და მაქსიმალური ორი რიცხვი - min(x,y), max (x,y);
სინუსი, კოსინუსი, ტანგენსი, კოტანგენსი - sin(x), cos(x), tan(x), ctg(x).

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

ლოგიკური გამონათქვამები

ლოგიკური გამონათქვამები ასახავს თუ არა გარკვეული ოპერაცია პირობას. მაგალითად, x > 0 შეფასდება ჭეშმარიტად, როდესაც x არის 1, 2, 25 ან ნულზე მეტი ნებისმიერი სხვა რიცხვი. ალგორითმული ენა შეიცავს ლოგიკურ გამონათქვამებს, რომლებსაც სტანდარტული მათემატიკური ოპერაციების გარდა, შეუძლიათ გამოიყენონ შემდეგი საკვანძო სიტყვები და ოპერატორები:

და.ნიშნავს, რომ გამონათქვამები, რომელთა შორის მდებარეობს საკვანძო სიტყვა, უნდა აკმაყოფილებდეს გარკვეულ პირობას: (x>0) და (y>0);
ან. ერთ-ერთი გამონათქვამი შეიძლება არ აკმაყოფილებდეს პირობას, მაგალითად, (x>0) ან (y>0);
არა. "აბრუნებს" გამოხატვის ლოგიკურ მნიშვნელობას. მაგალითად, ეს დიზაინი არა(x>0), ნიშნავს, რომ x მაინც არ უნდა იყოს ნულზე მეტი.

ასევე არის შედარების ოპერატორები -<, >, =, რომელიც შეიძლება გაერთიანდეს ისეთი გამონათქვამების შესაქმნელად, როგორიცაა მეტი ან ტოლი.

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

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

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

ალგ კვადრატი რიცხვი ()

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

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

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

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

გამომავალი "S =", S

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

alg რიცხვის კვადრატი (არგ მთელი x, res მთელი რიცხვი S)

გამომავალი "S =", S

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

ალგ კვადრატში რიცხვი და გამოთვალეთ მათი ჯამი (არგ მთელი x, რეს მთელი რიცხვი S)

მოცემული | x > 0

საჭიროება | S = 1*1 + 2*2+ … + x*x

დაიწყეთ მთლიანად

შეყვანა x; S:=0

nc a-სთვის 1-დან x-მდე

გამომავალი "S =", S

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

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

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

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

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

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

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

გამოქვეყნებულია http://www.allbest.ru/

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

განათლების ფედერალური სააგენტო

OGIET

ᲐᲑᲡᲢᲠᲐᲥᲢᲣᲚᲘ

დისციპლინა: კომპიუტერული მეცნიერება

თემაზე: „პროგრამირების ენების შედარებითი ანალიზი“

შესავალი

პროცესორის მანქანის კოდი

ალგორითმი და პროგრამა

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

შემდგენელები და თარჯიმნები

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

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

მაღალი დონის პროგრამირების ენების მიმოხილვა

მონაცემთა ბაზის პროგრამირების ენები

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

მოდელირების ენები

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

დასკვნა

ბიბლიოგრაფია

შესავალი

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

პროცესორის მანქანის კოდი

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

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

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

ალგორითმი და პროგრამა

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

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

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

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

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

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

შემდგენელები და თარჯიმნები

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

მაღალი დონის პროგრამირების ენების მიმოხილვა

FORTRAN(ფორტრანი). ეს არის პირველი შედგენილი ენა, რომელიც შეიქმნა ჯიმ ბაკუს მიერ 50-იან წლებში. პროგრამისტები, რომლებიც ამუშავებდნენ პროგრამებს ექსკლუზიურად ასამბლეის ენაზე, გამოხატავდნენ სერიოზულ ეჭვებს მაღალი ხარისხის მაღალი დონის ენის შესაძლებლობის შესახებ, ამიტომ Fortran შემდგენლების შემუშავების მთავარი კრიტერიუმი იყო შესრულებადი კოდის ეფექტურობა. მიუხედავად იმისა, რომ Fortran იყო პიონერი პროგრამირების მრავალი მნიშვნელოვანი კონცეფციის შესახებ, პროგრამების წერის სიმარტივე შეეწირა ეფექტური მანქანის კოდის წარმოების უნარს. ამასთან, ამ ენისთვის შეიქმნა უამრავი ბიბლიოთეკა, დაწყებული სტატისტიკური კომპლექსებიდან დაწყებული სატელიტური მართვის პაკეტებით, ამიტომ Fortran აგრძელებს აქტიურად გამოყენებას ბევრ ორგანიზაციაში და ახლა მიმდინარეობს მუშაობა მომდევნო Fortran P2k სტანდარტზე, რომელიც გამოჩნდება 2000 წ. არსებობს Fortran-ის სტანდარტული ვერსია, სახელწოდებით HPF (High Performance Fortran) პარალელური სუპერკომპიუტერებისთვის მრავალი პროცესორით.

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

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

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

ძირითადი(ძირითადი). ამ ენის შემდგენელებიც და თარჯიმნებიც არსებობს და პოპულარობით ის მსოფლიოში პირველ ადგილზეა. იგი შეიქმნა 60-იან წლებში, როგორც საგანმანათლებლო ენა და ძალიან ადვილი შესასწავლია.

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

C მრავალი თვალსაზრისით ჰგავს პასკალს და აქვს დამატებითი საშუალებები უშუალოდ მეხსიერებასთან მუშაობისთვის (მაჩვენებლები). 70-იან წლებში ამ ენაზე დაიწერა მრავალი აპლიკაციისა და სისტემური პროგრამა და არაერთი ცნობილი ოპერაციული სისტემა (11pgx).

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

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

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

# ით(ზღვის მკვეთრი). 90-იანი წლების ბოლოს C# ენა შეიქმნა Microsoft-ში ანდერს ჰაილსბერგის ხელმძღვანელობით. ის განასახიერებს C და C++-ის საუკეთესო იდეებს, ასევე Java-ის უპირატესობებს. მართალია, C#, Microsoft-ის სხვა ტექნოლოგიების მსგავსად, ორიენტირებულია Windows პლატფორმაზე. თუმცა, ფორმალურად ის არ განსხვავდება სხვა უნივერსალური ენებისგან და კორპორაცია მის სტანდარტიზაციასაც კი გეგმავს. C# ენა შექმნილია სწრაფი განვითარებისთვის. NET აპლიკაციები და მისი დანერგვა Microsoft Visual Studio-ში. NET შეიცავს ბევრ ფუნქციას, რომლებიც აკავშირებს C#-ს Windows-ის შიდა არქიტექტურასა და .NET პლატფორმასთან.

მონაცემთა ბაზის პროგრამირების ენები

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

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

§ მონაცემთა ბაზაში თვისებების შექმნა/მოდიფიცირება/ცხრილების წაშლა;

§ ინფორმაციის მოძიება, შერჩევა, დახარისხება მომხმარებლის მოთხოვნის მიხედვით;

§ ახალი ჩანაწერების დამატება;

§ არსებული ჩანაწერების მოდიფიკაცია;

§ არსებული ჩანაწერების წაშლა.

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

DBMS (Database Management Systems) შემუშავებულია დიდი მონაცემთა ბაზების მართვისა და მათი ეფექტური დამუშავებისთვის. თითქმის ყველა DBMS, გარდა SQL ენის მხარდაჭერისა, ასევე აქვს თავისი უნიკალური ენა, რომელიც ორიენტირებულია ამ DBMS-ის მახასიათებლებზე და არ არის პორტატული სხვა სისტემებისთვის. დღეს მსოფლიოში სამი წამყვანი DBMS მწარმოებელია: Microsoft (SQL Server), IBM (DB2) და Office. მათი პროდუქტები მიზნად ისახავს ქსელში ათასობით მომხმარებლის ერთდროული მუშაობის მხარდაჭერას, ხოლო მონაცემთა ბაზები შეიძლება ინახებოდეს განაწილებული ფორმით რამდენიმე სერვერზე. თითოეული ეს DBMS ახორციელებს საკუთარ SQL დიალექტს, რომელიც ორიენტირებულია კონკრეტული სერვერის მახასიათებლებზე, ამიტომ სხვადასხვა DBMS-ისთვის მომზადებული SQL პროგრამები, როგორც წესი, შეუთავსებელია ერთმანეთთან.

პერსონალური კომპიუტერების მოსვლასთან ერთად შეიქმნა ე.წ. დესკტოპის DBMS. კომპიუტერებისთვის თანამედროვე მონაცემთა ბაზის პროგრამირების ენების წინაპარად ითვლება dBase II DBMS, რომლის ენაც იყო ინტერპრეტირებული. შემდეგ მისთვის შეიქმნა შემდგენელები და გამოჩნდა FoxPro და Clipper DBMS, რომლებიც მხარს უჭერდნენ ამ ენის დიალექტებს. დღეს ყველაზე გავრცელებული დესკტოპის DBMS არის Microsoft Access.

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

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

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

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

RNR. რასმუს ლერდორფმა, რომელიც აქტიურად იყენებდა Perl-ის სკრიპტებს, 1995 წელს გადაწყვიტა გაეუმჯობესებინა ეს ენა მისი გამარტივებით და მონაცემთა ბაზებზე წვდომისთვის ჩაშენებული ინსტრუმენტების დამატებით. შედეგი იყო პირადი შინაარსის გვერდის/ფორმების თარჯიმნის (PHP/FI) განვითარება. რამდენიმე წლის განმავლობაში მასზე დაფუძნებული პროგრამები 50 ათას საიტზე გამოიყენეს. 1997 წელს ის მნიშვნელოვნად გააუმჯობესეს ენდი გუტმანმა და ზივ სურასკიმ და სახელწოდებით PHP 3.0 ენამ სწრაფად მოიპოვა პოპულარობა დინამიური ვებსაიტების შემქმნელებს შორის მთელს მსოფლიოში.

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

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

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

მოდელირების ენები

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

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

პ.ლ./ მე(PL/I). 60-იანი წლების შუა ხანებში IBM-მა გადაწყვიტა ენებიდან საუკეთესო მიეღო Fortran, Cobol და Algol. შედეგად, 1964 წელს დაიბადა ახალი კომპილირებული პროგრამირების ენა, რომელსაც ეწოდა Programming Language One. ამ ენამ დანერგა მრავალი უნიკალური გადაწყვეტა, რომელთა სარგებლიანობა შეიძლება შეფასდეს მხოლოდ 33 წლის შემდეგ, დიდი პროგრამული სისტემების ეპოქაში. თავისი შესაძლებლობების თვალსაზრისით, PL/I ბევრად უფრო ძლიერია, ვიდრე ბევრი სხვა ენა (C, Pascal). მაგალითად, PL/I-ს აქვს გამოთვლების სიზუსტის დაზუსტების უნიკალური შესაძლებლობა - C++ და Java-საც კი არ აქვთ. ამ ენას დღემდე აგრძელებს IBM-ის მხარდაჭერა.

Მოკლე საუბარი(Smoltalk). ამ ენაზე მუშაობა 1970 წელს დაიწყო XEROX Corporation-ის კვლევით ლაბორატორიაში და დასრულდა 10 წლის შემდეგ, რომელიც განხორციელდა SMALLTALK-80 თარჯიმნის საბოლოო ვერსიაში. ეს ენა ორიგინალურია იმით, რომ მისი სინტაქსი ძალიან კომპაქტურია და ეფუძნება მხოლოდ ობიექტის კონცეფციას. ამ ენაზე არ არის ოპერატორები ან მონაცემები. ყველაფერი, რაც შედის Smalltalk-ში, არის ობიექტები და თავად ობიექტები ერთმანეთთან ურთიერთობენ ექსკლუზიურად შეტყობინებების გამოყენებით (მაგალითად, გამოთქმის 1 + 1 გამოჩენა იწვევს შეტყობინებას "+", ანუ "დამატება", გაგზავნას ობიექტი I, პარამეტრით 1, რომელიც ითვლება არა მუდმივ რიცხვად, არამედ ობიექტად). ენაში არ არსებობს სხვა საკონტროლო სტრუქტურები, გარდა ფილიალის „ოპერატორისა“ (ფაქტობრივად ფუნქცია, რომელიც ეკუთვნის სტანდარტულ ობიექტს), თუმცა მათი მოდელირება შეიძლება ძალიან მარტივად. დღეს VisualAge for Smalltalk აქტიურად ვითარდება IBM-ის მიერ.

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

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

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

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

დასკვნა

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

ბიბლიოგრაფია

1. Simonovich S.V. კომპიუტერული მეცნიერების საბაზისო კურსი მე-2 გამოცემა “Peter” M., სანქტ-პეტერბურგი, როსტოვ-დონ-2006 წ.

2. ა.ა. სტეპანოვის ინფორმატიკის მე-4 გამოცემა „პეტერ“ მ., სანკტ-პეტერბურგი, დონის როსტოვი, კიევი-2005 წ.

3. ბ.ვ. Sobol, A. B. Galin კომპიუტერული მეცნიერების სახელმძღვანელო დონის როსტოვზე, "ფენიქსი" 2005 წ.

4. ი.ი. სერგეევა, ა.რ. Muzalevskaya Informatics, M. Forum-Infa-Moscow, 2006 წ

5. ე.ლ. ჟუკოვა, ე.გ. Burda Informatics, M. 2007, Nauka-Press

გამოქვეყნებულია Allbest.ru-ზე

მსგავსი დოკუმენტები

სტრუქტურირებული პროგრამირებისა და პრობლემის გადაჭრის ალგორითმის ცნებები. პროგრამირების ენების განვითარების მოკლე ისტორია მანქანური ენებიდან ასამბლეის ენებამდე და მაღალი დონის ენებამდე. პროცედურული პროგრამირება C#-ში. მოდელირების მეთოდები და პროგრამები.

სახელმძღვანელო, დამატებულია 10/26/2010

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

პრეზენტაცია, დამატებულია 01/23/2013

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

პრეზენტაცია, დამატებულია 14/10/2013

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

კურსის სამუშაო, დამატებულია 13/11/2009

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

კურსის სამუშაო, დამატებულია 17/11/2014

ზოგადი ინფორმაციის მიმოხილვა და პროგრამირების ენების დონეები. პროგრამირების ენების განვითარებისა და გამოყენების ისტორიის გაცნობა. მიმოხილვა ენების უპირატესობებისა და უარყოფითი მხარეების შესახებ, როგორიცაა ასამბლეა, პასკალი, C, C++, Fortran, Cobol, BASIC, SQL, HTML, Java.

კურსის სამუშაო, დამატებულია 11/04/2014

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

ლექციების კურსი, დამატებულია 12/04/2013

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

კურსის სამუშაო, დამატებულია 03/15/2012

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

კურსის სამუშაო, დამატებულია 12/22/2010

თანამედროვე პროგრამირების ენების აღწერა (Pascal, Assembly, C++, BASIC, Logo, Fort, Prolog, Refal და Lex). პროგრამირების სისტემების კონცეფცია, მიზანი და კომპონენტები (მანქანაზე ორიენტირებული და მანქანაზე დამოუკიდებელი პროგრამირების სისტემები).

კომპიუტერული მეცნიერება, კიბერნეტიკა და პროგრამირება

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

15 ალგორითმული ენების კლასიფიკაცია

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

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

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

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

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

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

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

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

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

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

ისევე როგორც სხვა ნამუშევრები, რომლებიც შეიძლება დაგაინტერესოთ
39480.		ETS-ის წლიური საწარმოო პროგრამის გაანგარიშება	103.5 კბ
	ელექტროტექნიკის პარკი მუდმივად იზრდება. სოფლის მეურნეობის ელექტრიფიკაციის გამოცდილება აჩვენებს, რომ ელექტროტექნიკური ტექნიკური მომსახურების კარგი მუშაობის გარეშე, მხოლოდ ელექტრო დანადგარების რაოდენობის ზრდა არ იძლევა წარმოების ეფექტურობის მოსალოდნელ ზრდას და არ იძლევა ელექტრომოწყობილობის სრული პოტენციალის გამოყენების საშუალებას. ელექტრო მოწყობილობების ოპერაციული საიმედოობა ჯერ კიდევ არ აკმაყოფილებს სასოფლო-სამეურნეო წარმოების მოთხოვნებს. ფუნქციონირების გაუმჯობესება...
39481.		სიცოცხლის უსაფრთხოება. პროგრამისტის მუშაობის პირობების მახასიათებლები	1.09 მბ
	ამასთან დაკავშირებით შეიქმნა და ვითარდება მეცნიერება შრომის უსაფრთხოებისა და ადამიანის სიცოცხლის შესახებ. მუშაკთა ჯანმრთელობის დაცვა, უსაფრთხო სამუშაო პირობების უზრუნველყოფა, პროფესიული დაავადებებისა და საწარმოო დაზიანებების აღმოფხვრა ადამიანთა საზოგადოების ერთ-ერთი მთავარი საზრუნავია. ყურადღება გამახვილებულია შრომის მეცნიერული ორგანიზაციის პროგრესული ფორმების ფართო გამოყენების აუცილებლობაზე, რათა მინიმუმამდე დაიყვანოს ხელით არაკვალიფიციური შრომა, რათა შეიქმნას გარემო პროფესიული დაავადებების და სამრეწველო...
39483.		ნანომასალების გამოყენება სამშენებლო მასალების მეცნიერებაში	1.34 მბ
	"ნანო" (ბერძნული სიტყვიდან "ნანოს" - ჯუჯა) არის პრეფიქსი, რომელიც აღნიშნავს ორიგინალური ერთეულის მემილიარდედს. ვინაიდან SI სიგრძის ერთეული არის მეტრი, ნანომეტრი ნიშნავს მეტრის მემილიარდედ ან მილიმეტრის მემილიონედს.
39484.		მომხმარებლის საკრედიტო ისტორიის შესანარჩუნებლად საინფორმაციო სისტემის შემუშავება	3.89 მბ
	შეყვანისა და გამომავალი მონაცემების სტრუქტურისა და ფორმების ჩამოყალიბება. განათების გაანგარიშება კომპიუტერული ტექნოლოგიებისა და პროგრამული უზრუნველყოფის მუდმივი განვითარება და გაუმჯობესება იწვევს მონაცემთა დამუშავების უფრო და უფრო ახალი ტექნოლოგიების გაჩენას. ამიტომ, დამუშავების სისტემის ეფექტურობა დამოკიდებულია შეყვანისა და გამომავალი ინფორმაციის ნაკადების სწორ ორგანიზაციაზე. მიაწოდეთ გამომავალი ინფორმაცია ელექტრონული ფორმატით და მომხმარებლისთვის საჭირო ბეჭდური დოკუმენტებით.
39485.		სპორტული ორგანიზაცია "ვესნას" საქმიანობის მონიტორინგის ავტომატური სისტემის შემუშავება.	1.61 მბ
	ნაშრომის მიზანი და მთავარი მიზანია სპორტული ორგანიზაცია „ვესნას“ საქმიანობის ავტომატური მონიტორინგის სისტემის შემუშავება, რომლის საქმიანობა მოიცავს მოზარდების სათანადო ფიზიკურ განვითარებას და ჯანმრთელობის გაუმჯობესებას.
39487.		ვებსაიტის შექმნა MKDOU No. 17-ისთვის	3.14 მბ
	ვებ გვერდების შექმნის ზოგადი პრინციპები ვებ გვერდების ძირითადი ელემენტები. შესავალი ინტერნეტში ვებ გვერდების შემუშავებისა და შექმნის საქმეში დაგროვდა უამრავი სხვადასხვა მეთოდი და ტექნოლოგია, რომელთაგან ბევრი, სამწუხაროდ, ახლა პირობითად გამოიყენება. ამიტომ, როგორც ჩანს, აქტუალური და პრაქტიკულად მნიშვნელოვანია თანამედროვე პირობებში ვებ-გვერდის დიზაინის პრობლემის განხილვა ამ სფეროში დაგროვილი მიღწევების მთელი დიაპაზონის გამოყენებით.
39488.		სატრანსპორტო საწარმოში ტვირთის მიწოდების ხარჯების ოპტიმიზაციის ავტომატური სისტემის შექმნა	882.5 კბ
	პროდუქციის განაწილების ლოჯისტიკური ორგანიზაცია პრაქტიკაში ხორციელდება, როგორც რეგულარული, მიზანმიმართული პროცესი საქონლისა და მომსახურების ბრუნვის ყველა დონეზე და ყველა ეტაპზე ზემოქმედების ფაქტორებზე და პირობებზე, რომლებიც უზრუნველყოფენ ფიზიკური ეკონომიური და ეფექტური პროცესის მიღწევას და შენარჩუნებას. საქონლის პოპულარიზაცია ბაზარზე. ორგანიზაციული ძალისხმევა, რომელიც მიმართულია პროდუქტის განაწილების ეფექტურობის გაზრდაზე, შეიძლება დაიწიოს ორ ასპექტზე: ოპერაციულ და სტრატეგიულ.3] პროდუქტის განაწილების ოპტიმალური რეჟიმის ფორმირება მისი შემდგომი კორექტირებით...

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

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

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

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

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

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

ა) თავად ამოცანის ბუნება და ტექნიკური მოთხოვნები;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ცნობილი თეორეტიკოსის N. Wirth-ის მიერ შემუშავებული ALGOL −68-ის იდეებზე დაყრდნობით, პასკალი გამიზნული იყო ძირითადად პროგრამირების სწავლებისთვის. აგებულია "აუცილებელი და საკმარისი" პრინციპზე, მას აქვს მკაცრი ტიპის კონტროლი, კონსტრუქციები მონაცემთა თვითნებური სტრუქტურების აღწერისთვის და სტრუქტურირებული პროგრამირების ოპერატორების მცირე, მაგრამ საკმარისი ნაკრები. სამწუხაროდ, სიმარტივისა და სიმკაცრის მეორე მხარე არის ენობრივი კონსტრუქტების აღწერების უხერხულობა. ყველაზე ცნობილი იმპლემენტაცია, Turbo/Borland Pascal, მიუხედავად პასკალის სტანდარტისაგან მისი განსხვავებისა, არის გარემო და ბიბლიოთეკების ნაკრები, რომელმაც საგანმანათლებლო ენა აქცია MS-DOS გარემოში პროგრამების განვითარების ინდუსტრიულ სისტემად.

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

Windows-ის პროგრამული უზრუნველყოფის ფრონტზე ხანგრძლივი ბრძოლის შემდეგ, Borland გადავიდა საწარმოთა სისტემების ბაზარზე. დელფი არ არის Borland Pascal / Borland C-ის მემკვიდრე, მისი ნიშა არის ე.წ. აპლიკაციის სწრაფი შექმნა (Rapid Application Developing, RAD). ასეთი ხელსაწყოები საშუალებას გაძლევთ სწრაფად შექმნათ სამუშაო პროგრამა მზა კომპონენტებისგან, წვრილმანებზე დიდი ძალისხმევის დახარჯვის გარეშე. ასეთ სისტემებში განსაკუთრებული ადგილი უჭირავს მონაცემთა ბაზებთან მუშაობის უნარს.

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

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

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

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

Jarrod Holingworth, Bob Swart, Mark Cashman, Paul Gustavson Borland C++ Builder 6. Developer's Guide = Borland C++ Builder 6 Developer's Guide. - M.: "Williams", 2004. - გვ. 976.
ვიკ კურილოვიჩი Visual Basic. − გამომცემლობა „სოლონ-პრესი“, 2006 წ., −პ. 384.
Andreeva T. A. პროგრამირება პასკალში. − გამომცემელი: საინფორმაციო ტექნოლოგიების ინტერნეტ უნივერსიტეტი, Binom. ცოდნის ლაბორატორია, 2006 - გვ 240.
პილშჩიკოვი V.N. ასამბლერი. პროგრამირება IBM ასამბლეის ენაზე. − PC Publishing house: Dialog-MEPhI, 2005 − P. 288.
Zhelonkin A. პროგრამირების საფუძვლები ინტეგრირებულ გარემოში DELPHI. − გამომცემელი: Binom. ცოდნის ლაბორატორია, 2004 - გვ 240.
ჯოშუა ბლოხ ჯავა. ეფექტური პროგრამირება ეფექტური ჯავა. პროგრამირების ენის გზამკვლევი − სერია: Java გამომცემელი: Lori, 2002 − P. 224.
Lafore R. ობიექტზე ორიენტირებული პროგრამირება C++-ში ობიექტზე ორიენტირებული პროგრამირება C++-ში - გამომცემელი: Peter, 2011 წ.