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

საპროცესო პროგრამირების ენები მოიცავს: Ada, Basic (ვერსიები Quick Basic– დან Visual Basic– მდე), C, COBOL, Fortran, მოდულა- 2, პასკალი, PL / 1, რაპიერი, REXX.

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

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

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

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

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

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

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

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

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

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

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

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

თვითმმართველობის ტესტის კითხვები

1. რა არის პროგრამა? რას ნიშნავს შემსრულებელი?

2. რა არის მანქანის კოდი?

3. რა არის მთარგმნელი? ჩამოთვალეთ მთარგმნელების ტიპები.

4. როგორ მუშაობს თარჯიმანი? რა არის მისი უპირატესობა?

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

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

7. რას ნიშნავს მონაცემთა სტრუქტურა, როგორია მონაცემთა სტრუქტურის კლასიფიკაცია?

8. რას ნიშნავს მონაცემთა მასივები და რა ოპერაციების შესრულება შეიძლება მათთან ერთად?

9. როგორია მასივების დახარისხების ალგორითმები?

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

11. რისთვის არის რუტინული ბიბლიოთეკა?

12. რა სახის პროგრამირება არსებობს?

ლიტერატურა

1. სტავროვსკი ა.ბ., კარნაუხ თ.ა. პირველი ნაბიჯები პროგრამირებისთვის. თვითნასწავლის წიგნი. - მ .: უილიამსი, 2006 წ.- 400 გვ.

2. Okulov S. პროგრამირების საფუძვლები გამომცემელი: Binom. ცოდნის ლაბორატორია, 2008 .-- 383 გვ.

3. კანცედალი ს.ა. ალგორითმიზაციისა და პროგრამირების საფუძვლები. - მ .: ფორუმი, 2008 .-- 351 გვ.

4.httn // www myfreesoft ru / default-windows-nroprams html-სტანდარტული Windows პროგრამები

5.httn // khni -iin mink kharkiv edu / lihrary / datastr / hook / nrt01 html # lb11 - მოდელები და მონაცემთა სტრუქტურები

6.httn: //www.intuit.ru/denartment/se/nhmsu/11/3.html#sect5 - მოდელები და მონაცემთა სტრუქტურები

7.http: //inf.1sentemher.ru/2007/15/00.htm - კომპიუტერული მეცნიერების ენციკლოპედია

8.http: //www.delnhi.int.ru/articles/119/ - ქვეჯგუფები.

9.httn // inroc ru / narallel-nroPramminP / lection-5 /-გროვის დახარისხება.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4. რისთვის არის პროგრამირების ენები?

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

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

ყველა მრავალი პროგრამირების ენა შეიძლება დაიყოს ორ ჯგუფად: დაბალი დონის ენებიდა მაღალი დონის ენები.

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

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

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

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

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

1.1 ფორტრანი

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

1.2 ალგოლი

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

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

1.3 კობოლი

1959 - 1960 წლებში შეიქმნა კობოლის ენა (ინგლისური COBOL COMMOM Business Oriented Language). ეს არის მესამე თაობის პროგრამირების ენა, რომელიც შექმნილია ძირითადად ბიზნეს პროგრამების შემუშავებისთვის. ასევე, კობოლი განკუთვნილი იყო ეკონომიკური პრობლემების გადასაჭრელად, მონაცემთა დამუშავებისთვის ბანკებისთვის, სადაზღვევო კომპანიებისთვის და ამ ტიპის სხვა ინსტიტუტებისთვის. გრეის ჰოპერი ( ბებია კობოლა).

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

1.4 ლისპი

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

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

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

1.5 ძირითადი

60-იანი წლების შუა ხანებში (1963), ძირითადი ენა (BASIC საწყისი დამწყებთათვის Allpurpose Instruction Code) შეიქმნა დარტმუთის კოლეჯში (აშშ). დროთა განმავლობაში, როდესაც სხვა დიალექტები გამოჩნდნენ, ეს "ორიგინალური" დიალექტი ცნობილი გახდა როგორც დარტმუთის ძირითადი. ენა ნაწილობრივ დაფუძნებულია ფორტრან II- ზე და ნაწილობრივ ალგოლ -60-ზე, დამატებებით, რაც მოსახერხებელია დროის გაზიარებისთვის და, მოგვიანებით, ტექსტის დამუშავებისა და მატრიცული არითმეტიკისთვის. BASIC თავდაპირველად განხორციელდა GE-265 მეინფრეიმზე მრავალი ტერმინალის მხარდაჭერით. პოპულარული რწმენის საწინააღმდეგოდ, მისი წარმოშობის დროს, ეს იყო შედგენილი ენა.

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

1.6 ციხე

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

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

1.7 პასკალი

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

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

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

1.8 ჯოჯოხეთი

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

ადას უშუალო წინამორბედები არიან პასკალი და მისი წარმოებულები, მათ შორის ევკლიდი, ლის, მესა, მოდულა და სუ. გამოყენებულია რამდენიმე კონცეფცია ALGOL-68, Simula, CLU და Alphard.

ადას დეველოპერების მთავარი საზრუნავი იყო:

· პროგრამების სანდოობა და შესრულება;

· პროგრამირება, როგორც ადამიანის ერთგვარი საქმიანობა;

· ეფექტურობა.

მაგიდა 1 გვიჩვენებს ადა ენის ძირითად მახასიათებლებს ობიექტის მიდგომის თვალსაზრისით.

ცხრილი 1. ადა.

1.9 სი

ამჟამად, C არის პოპულარული ენა პროგრამისტებს შორის (C არის ინგლისური ანბანის ასო). C ენა წარმოიშობა ორი ენიდან- BCPL და B. 1967 წელს მარტინ რიჩარდსმა შეიმუშავა BCPL, როგორც ენა სისტემის პროგრამული უზრუნველყოფისა და შემდგენლებისათვის. 1970 წელს კენ ტომპსონმა გამოიყენა B, რათა შექმნას UNIX ოპერაციული სისტემის ადრეული ვერსიები DEC PDP-7 კომპიუტერზე. BCPL- სა და B- ში ცვლადები არ იყოფა ტიპებად - მონაცემების თითოეულმა ღირებულებამ დაიკავა ერთი სიტყვა მეხსიერებაში და პასუხისმგებლობა განასხვავოს, მაგალითად, მთელი რიცხვები და რეალური რიცხვები მთლიანად დაეცა პროგრამისტის მხრებზე. C ენა შემუშავდა ( დაფუძნებულია B) დენის რიჩის მიერ Bell Laboratories– დან და პირველად განხორციელდა 1972 წელს DEC PDP-11 კომპიუტერზე. C– მ მოიპოვა პოპულარობა, როგორც UNIX OS– ის ენა. დღეს თითქმის ყველა ძირითადი ოპერაციული სისტემა დაწერილია C ან C ++. ორი ათწლეულის შემდეგ, C ხელმისაწვდომია უმეტეს კომპიუტერებზე. ის დამოუკიდებელია ტექნიკისაგან. 70 -იანი წლების ბოლოს C გახდა ის, რასაც ჩვენ "ტრადიციულ C" -ს ვუწოდებთ. 1983 წელს კომპიუტერის და ინფორმაციის დამუშავების ეროვნული სტანდარტების ამერიკული კომიტეტის მიერ დადგენილია ამ ენის ერთი სტანდარტი. ამ ენას აქვს მდიდარი საშუალებები, გაძლევთ საშუალებას დაწეროთ მოქნილი პროგრამები, რომლებიც იყენებენ თანამედროვე პერსონალური კომპიუტერების ყველა შესაძლებლობას.

1.10 პროლოგი

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

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

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

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

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

1.11 ჯავა

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

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

ობიექტი პასკალი შეიქმნა Apple კომპიუტერის თანამშრომლების მიერ (რომელთაგან ზოგიერთი იყო Smalltalk– ის ავტორები) ნიკლაუს ვირტთან ერთად, პასკალის ენის შემქმნელი. ობიექტი პასკალი არსებობდა 1986 წლიდან და არის პირველი ობიექტზე ორიენტირებული პროგრამირების ენა, რომელიც შეტანილია მაკინტოშის პროგრამისტის სემინარში (MPW), Apple– ის Macintosh კომპიუტერების განვითარების გარემო.

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

მაგიდა 2 გვიჩვენებს პასკალ ობიექტის ზოგად მახასიათებლებს.

ცხრილი 2. ობიექტი პასკალი.

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

1.13 ვიზუალური ობიექტზე ორიენტირებული დიზაინის სისტემა დელფი.

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

დელფის სისტემა საშუალებას გაძლევთ გადაჭრას მრავალი პრობლემა, კერძოდ:

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

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

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

· შექმენით დამხმარე სისტემები (.hlp ფაილები) თქვენი აპლიკაციებისთვის და სხვა. დოქტორი

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

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

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

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

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

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

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

ეკრანის სტრუქტურა დელფის გარემოში.

დელფისთან დარეკვის შემდეგ Windows- ზე გამოჩნდება რამდენიმე ფანჯარა (სურ. 1):

მთავარი ფანჯარა,

ფორმის ფანჯარა,

ობიექტის ინსპექტორის ფანჯარა,

ობიექტის ხის ფანჯარა,

პროგრამის კოდის ფანჯარა.

ნახ. 1 ეკრანის სტრუქტურა დელფის გარემოში.

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

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

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

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

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

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

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

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

დიზაინის პროცესში შექმნილი ფაილები ნაჩვენებია ცხრილში. 3

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

პროექტის ფაილი (.dpr)	ეს ტექსტური ფაილი გამოიყენება ფორმებისა და მოდულების შესახებ ინფორმაციის შესანახად. იგი შეიცავს განცხადებებს პროგრამების ინიციალიზაციისთვის და დაწყებისათვის
მოდულის ფაილი (.pas)	თქვენს მიერ შექმნილ თითოეულ ფორმას აქვს შესაბამისი მოდულის ტექსტური ფაილი, რომელიც გამოიყენება კოდის შესანახად. თქვენ შეგიძლიათ შექმნათ მოდულები, რომლებიც არ არის დაკავშირებული ფორმებთან. დელფის მრავალი ფუნქცია და პროცედურა ინახება მოდულებში.
ფორმის ფაილი (.dfm)	ეს არის ორობითი ან ტექსტური ფაილი, რომელსაც დელფი ქმნის ფორმების შესახებ ინფორმაციის შესანახად. თითოეული ფორმის ფაილს აქვს შესაბამისი მოდულის ფაილი (.pas)
პროექტის პარამეტრების ფაილი (.dfo)	ეს ფაილი ინახავს პროექტის პარამეტრების პარამეტრებს
რესურსების ფაილი (.res)	ეს ორობითი ფაილი შეიცავს პროექტის მიერ გამოყენებულ ხატს და სხვა რესურსებს.
სარეზერვო ფაილები (. ~ Dpr, Dfm, ~ Pas)	ეს არის, შესაბამისად, სარეზერვო ფაილები პროექტის, ფორმისა და მოდულის ფაილებისთვის. თუ რაიმე უიმედოდ არის კორუმპირებული პროექტში, თქვენ შეგიძლიათ შეცვალოთ ამ ფაილების გაფართოება შესაბამისად და ამით დაუბრუნდეთ წინა დაუზიანებელ ვერსიას.
ფანჯრის კონფიგურაციის ფაილი (.dsk)	ფაილი ინახავს განვითარების გარემოს ყველა ფანჯრის კონფიგურაციას
შესრულებადი ფაილი (.exe)	ეს არის პროგრამის შესრულებადი ფაილი. ეს არის დამოუკიდებელი შემსრულებელი ფაილი, რომელიც არ საჭიროებს სხვას, თუ ის არ იყენებს ბიბლიოთეკებს, რომლებიც შეიცავს DLL– ებს, OCX– ებს და ა.
მოდულის ობიექტის ფაილი (.dcu)	ეს არის შედგენილი მოდულის ფაილი (.pas), რომელიც დაკავშირებულია საბოლოო შესრულებად ფაილში.

ცხრილი 3. დიზაინის პროცესში შექმნილი ფაილები.

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

ევოლუციის ხის დაპროგრამება

სურათი 1 ევოლუციის ხის პროგრამირება

6. ბიბლიოგრაფია:

1. ი.ტ. ზარეცკაია, ბ.გ. კოლოდიაჟნი, ა.ნ. გურჯი, ა.ი. სოკოლოვი. ინფორმატიკა 10-11 კლასი. - კ .: "ფორუმი", 2001 წ

1. ეკრანის სტრუქტურა დელფის გარემოში (http://textbook.keldysh.ru/distant/delphi/del_2.htm)

2. პატრიკეევი ი. ნ. "ობიექტზე ორიენტირებული დიზაინი" (http://www.object.newmail.ru/oop1.html)

3. ს. ნემნიუგინი, ლ. პერკოლაბი "სწავლობენ ტურბოპასკალს" - SPb.: პეტრე, 2002 წ.

2. ჰ.მ. დეიტელი. როგორ პროგრამირება S. - M: "Binom", 2000 წ

3. ინტერნეტ გვერდი: http://ru.wikipedia.org/wiki/LISP

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

Წიგნი:

განყოფილებები ამ გვერდზე:

8.2. Პროგრამირების ენები

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

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

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

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

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

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

მანქანებზე დამოკიდებული პროგრამირების ენები

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

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

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

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

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

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

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

მაღალი დონის პროგრამირების ენები მოიცავს შემდეგს: Fortran, Cobol, Algol, Pascal, Basic, C, C ++, Java, HTML, Perl და სხვა.

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

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

სურათი 8.4. მთარგმნელების სახეები

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

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

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

პროგრამის შექმნის პროცესს ეწოდება პროგრამირება.

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

ალგორითმული ან მოდულური

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

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

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

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

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

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

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

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

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

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

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

ქვეპროგრამები ასრულებს სამ მნიშვნელოვან ამოცანას:

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

გააუმჯობესოს პროგრამის სტრუქტურა, გაუადვილოს გაგება;

პროგრამული შეცდომისა და გაუთვალისწინებელი შედეგებისადმი პროგრამული ცვლილებების დროს წინააღმდეგობის გაზრდა.

ობიექტზე ორიენტირებული პროგრამირება

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

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

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

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

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

1. კაფსულაცია - მონაცემების გაერთიანება მეთოდებთან ერთ კლასში;

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

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

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

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

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

MOV AL, 19

დამატება AL, 4

გარეთ 2

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

ასამბლეის ენები და მანქანების კოდი ითვლება დაბალი დონის ენებად.

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

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

FORTRAN (IBM Mathematical FORmula TRANslating System) არის პროგრამირების ენა შემუშავებული 1950 -იან წლებში მათემატიკური გამოთვლებისა და სამეცნიერო მიზნებისთვის.

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

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

პასკალი - 1970 -იან წლებში შექმნილი პროგრამირების ენა, რომელიც შეიქმნა პროგრამირების სწავლების მიზნით.

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

C ++ არის ობიექტზე ორიენტირებული C.

ჯავა არის პროგრამირების ენა, რომელიც შემუშავებულია C ++ - ის საფუძველზე.

Visual Basic, Delphi, Python, C # ყველა მესამე თაობის ენებია. მესამე თაობის მრავალი პროგრამირების ენა უფრო ახალგაზრდაა (უფრო ახალი) ვიდრე მეოთხე და მეხუთე თაობის ენები.

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

პროგრამირების ენების ძირითადი ტიპები.

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

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

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

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

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

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

ინტერპრეტირებული და შედგენილი ენები

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

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

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

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

პრინციპში, ნებისმიერ ენაზე დაწერილი პროგრამის ინტერპრეტაცია და შედგენა შესაძლებელია.

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

ვებ აპლიკაციის შემუშავება

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

ვებ პროგრამირება შეიძლება დაიყოს backend (სერვერის სკრიპტების წერა - PHP, Python, Ruby) და frontend (მომხმარებლის ინტერფეისის განვითარება - Javascript, HTML, CSS).

დესკტოპის აპლიკაციის შემუშავება

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

სერვერის განაცხადის განვითარება

ეს არის სხვადასხვა თამაშის სერვერები (თქვენი საყვარელი Dotka, CS: GO), IM სერვისები (Skype, ICQ, MSN სერვერის მხარე), საბანკო მონაცემთა ბაზები.

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

ბევრი Java პროგრამა. VK, Viber, Yandex. რუქები, მთარგმნელები, ელექტრონული მკითხველები.

ჩაშენებული პროგრამირება

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

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

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

თამაშის განვითარება

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

ოლიმპიადის პროგრამირება და პრობლემის გადაჭრა

პროგრამირება სხვადასხვა "არაპრაქტიკულ" და არა ჩვეულებრივ ენებზე (პასკალი, დელფი) ზოგიერთი ორიგინალური პრობლემის გადასაჭრელად, რომლებიც საჭიროებენ არასტანდარტულ მიდგომას, გამჭრიახობას და IQ 160-ს ზემოთ.

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

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

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

სერიოზული მიმართულება. თუ გსურთ შექმნათ მონაცემთა ბაზები, რომელთაც შეუძლიათ შეინახონ მილიარდობით ინფორმაცია VKontakte ან Facebook– ის ყველა მომხმარებლის შესახებ და ამავე დროს არ შეანელოთ - თქვენ აქ ხართ.

მეცნიერება

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

სხვათა შორის, ახლახანს NASA– ს ვებგვერდმა გამოაქვეყნა ახალი ამბები პროგრამისტის ძებნის შესახებ "უძველეს" ფორტრანის ენაზე, რომელიც 60 წელზე მეტია. პროგრამისტი იყო საჭირო პროგრამების შემუშავებისათვის, რათა გააკონტროლონ ავტომატური ზონდები Voyager 1 და Voyager 2, პროგრამული უზრუნველყოფა, რომლისთვისაც 1970 -იან წლებში იყო დაწერილი Assembler, Fortran და COBOL. თქვენ არასოდეს იცით რა ცოდნა შეიძლება გამოგადგეთ.