Ստեղծվեց ծրագրավորման առաջին լեզուն։ Ինչպե՞ս եք դեռ ընտրում ձեր (առաջին) ծրագրավորման լեզուն: Կամ ինչպե՞ս ճիշտ հարցեր տալ: Ինչ է ծրագրավորման լեզուն

Եթե ​​մտածում եք ծրագրավորում սովորելու մասին, ապա այն ծրագրավորման լեզուն, որը դուք առաջինը կընտրեք, մեծ նշանակություն ունի, այն պետք է կապված լինի ապագայում ձեր անելիքների հետ և համապատասխան լինի։ Թեև ծրագրավորումն ընդհանրապես ծույլերի համար չէ, որոշ լեզուներ ավելի հեշտ են սովորել, քան մյուսները և ունեն համայնքներ, որոնք նվիրված են սովորելուն և առաջարկում են օգտակար հմտություններ այլ ծրագրավորման լեզուներ սովորելու համար:

Ընտրության սխեման

Կան հարցեր, որոնք այնքան հաճախ են տրվում, որ դրանց պատասխանելու համար ստեղծվում են ամբողջական դիագրամներ: Ահա, օրինակ, դրանցից մեկը՝ նվիրված ծրագրավորման առաջին լեզվի ընտրությանը։

Ձեր առաջին ծրագրավորման լեզուն ընտրելիս պետք է սթափ գնահատել հետևյալ գործոնները.

• Աշխատանքի շուկա.
• Լեզվի երկարաժամկետ հեռանկարներ.
• Լեզու սովորելու դժվարություն.
• Կոնկրետ ի՞նչ կարող ես ստեղծել սովորելու ընթացքում և, ցույց տալով ուրիշներին, պահպանել մոտիվացիան։

Հանրաճանաչություն և պահանջարկ

JavaScript

JavaScript-ը, չշփոթել Java-ի հետ, ծրագրավորման լեզու է, որը մշակվել է 90-ականներին Բրենդան Էյխի կողմից, նախկինում Netscape Communications-ից, իսկ այժմ՝ Mozilla Foundation-ից: JavaScript-ը հիմնարար տեխնոլոգիաներից մեկն է, որը հզորացնում է վեբ համայնքը, ինչպես մենք գիտենք: Մի խաբվեք, չնայած JavaScript-ը գոյություն ունի զննարկիչից դուրս, այն հիմնականում գոյություն ունի կապված հավելվածների և ծառայությունների համատեքստում:

Լեզուն ինքնին դինամիկ է և ծրագրավորողներին տալիս է օբյեկտի վրա հիմնված ծրագրավորման ոճեր օգտագործելու ճկունություն (քանի որ լեզուն ինքնին հիմնականում օբյեկտի վրա է), ինչպես նաև ֆունկցիոնալ և հրամայական: Այն իր շարահյուսության մեծ մասը բխում է C-ից, և եթե դուք պլանավորում եք որևէ ձևով վեբ մշակում կատարել, JavaScript-ը սովորելը պետք է լինի ձեր ցանկում:

Բարեբախտաբար, JavaScript-ը համեմատաբար հեշտ է սովորել, այն արդեն ձեր բրաուզերում է, որպեսզի դուք կարողանաք խաղալ, և թեև այն վաղուց էր, այն արագորեն դառնում է ժողովրդականություն: Ձեզանից շատերը, ովքեր առաջադրել են այն, նշել են, որ JavaScript սովորելիս ձեր գումարը մեծ է, քանի որ դուք կարող եք անմիջապես օգտագործել այն համացանցի համար իրեր ստեղծելու համար, ինչը շատ լավ կարող է լինել այն, ինչ շատ մարդիկ սովորում են կոդավորել:

Պիթոն

Կարող եմ նաև խորհուրդ տալ Python-ին։

Չնայած Python-ին պատմականորեն բնորոշ մի շարք խնդիրների, այն շարունակում է մնալ առաջատար գործիք մի շարք խորշերում.

Տպավորիչ է, այնպես չէ՞։ Ինչ վերաբերում է Python-ով գրված մեծ և հանրաճանաչ նախագծերին, ապա դրանք այնպիսի հրեշներ են, ինչպիսիք են.

Դուք կարող եք գտնել նաև մեր կայքում:

Ծրագրավորումը աշխատատար և բարդ գործընթաց է, որը ոչ բոլորն են կարողանում հասկանալ: Մեքենայի լեզուն բաղկացած է բազմաթիվ ալգորիթմներից և այսօրվա համակարգիչները այնքան առաջադեմ սարքավորումներ են, քանի որ դրանք ծրագրավորված են: Եվ ծրագրային ապահովման մշակման պատմությունն այդքան հաջող չէր լինի, եթե չհայտնվեր հատուկ լեզու մեքենաների համար, որոնք խորհրդանշական հիմնաբառերը վերածում էին մեքենայի կոդերի։ Եկեք նայենք, թե ինչպես է ձևավորվել ծրագրավորման լեզուների զարգացման պատմությունը:

Առաջին ավտոկոդերը հայտնվեցին 1955 թվականին IBM ծրագրավորողների ջանքերով՝ ինժեներ Ջոն Բաքուսի ղեկավարությամբ։ Դա բարձր մակարդակի լեզու էր, որը կոչվում էր Fortran, ոչ թե մեկուսացված պարզ հրամանների մի շարք, այլ ավելի մեծ կոդերի կազմակերպություն, որոնք սկսեցին կոչվել օպերատորներ կամ ալգորիթմական լեզուներ: Դրանք մեքենայական կոդի թարգմանելու համար հայտնագործվեցին թարգմանիչներ, որոնք փոխակերպում էին ալգորիթմները և այն հասկանալի դարձնում էլեկտրոնային համակարգչի համար։ Դա տեղի է ունենում երկու եղանակով` մեկնաբանության և կազմման: Իրենց պարզության շնորհիվ Fortran-ի տարբերակները արագորեն գործածության մեջ մտան, և դրանցից վերջինն այսօր էլ հիմնական համակարգիչներից մեկն է:

Այնուամենայնիվ, սա մեքենաների միակ ավտոկոդը չէ: Ծրագրավորման լեզուների զարգացման պատմությունը շարունակվում է Algol ալգորիթմների ստեղծմամբ, որոնք հիմնականում օգտագործվում են գիտական ​​հանրության մեջ և պարունակում են մեծ թվով նոր հասկացություններ: Այս իրադարձությունը տեղի է ունենում 1960 թ. Եվ մի փոքր ավելի ուշ, IBM-ի հետաքրքրասեր աշխատակիցները հորինեցին Cobol լեզուն, որը ուղղված էր բիզնես միջավայրում օգտագործելուն և օգտագործվում էր տնտեսական բնույթի բարդ և ծավալուն տեղեկատվության մշակման համար:

Ծրագրավորման լեզուների զարգացման պատմությունը շարունակվում է Դարտսմութ քոլեջի պրոֆեսորներ Տ. Կուրցը և Ջ. Քեմենին, ովքեր մշակել են հայտնի BASIC-ը: Այն շատ ավելի պարզ է, քան Fortran-ը, և, հետևաբար, օգտագործվել է Այն ունեցել է պայթյունավտանգ ազդեցություն՝ դառնալով ավտոմատ ծրագրավորման կոդերի հիմնական հավաքածուն և համակարգիչները դարձնելով ամենասովորական օգտագործողների սեփականությունը:

Օգտագործման հեշտությունը և ինտերակտիվ հաղորդակցության հնարավորությունը BASIC լեզվի կարևորագույն առավելություններն են: Թերությունները ներառում են ծրագրերի կազմման սահմանափակումների բացակայությունը, ինչը շատ հաճախ շփոթեցնում է դրանք և դարձնում դրանք տրամաբանորեն անհասկանալի։ BASIC-ի միջոցով գրված ծրագրերը դանդաղ են, քանի որ հիմնված են ոչ թե կոմպիլյատորների, այլ թարգմանիչների վրա:

Այսօր գիտնականները շարունակում են աշխատել դրա կատարելագործման ուղղությամբ և փորձում են այն մոտեցնել Պասկալ ծրագրին, որն էլ ավելի նշանավորեց ծրագրավորման լեզուների զարգացման պատմությունը։ Ցյուրիխի պոլիտեխնիկական համալսարանի պրոֆեսոր Նիկլաուս Վիրտն իրավամբ համարվում է դրա ստեղծողը։ Եվ նա իր գյուտին անունը տվեց ի պատիվ Պասկալի, ով հենց առաջին համակարգչի առաջին դիզայներն էր։ Սա ծրագրավորման ամենահեշտ և հասանելի լեզուներից մեկն է, որը թույլ է տալիս գրել պարզ և հասկանալի ծրագրեր:

Ծրագրավորման զարգացման պատմությունը թերի կլիներ առանց Ադա լեզվի, որն անվանվել էր ի պատիվ առաջին կին ծրագրավորող Ադա Լավլեյսի, որը հայտնի քրտինքի դուստրն է:

Ծրագրային ապահովման մշակման պատմությունն իր զինանոցում ունի շատ ավելի շատ ծրագրավորման լեզուներ, որոնք գրված են կիրառման հատուկ ոլորտների համար: Օրինակ, մոդելավորման մեջ օգտագործվում են Simul, Simkrit և GPSS: FORT լեզուն օգտագործվում է սարքավորումները կառավարելու համար: գրված են SI լեզվով։ Տվյալների բազաները ստեղծվում են Kodasil լեզվով: Ծրագրավորում սովորելու համար հարմար են լոգոն, Robik-ը և A.P. Էրշովան։

Ծրագրավորման զարգացման պատմությունը դեռ ամբողջությամբ գրված չէ, և դա դժվար թե տեղի ունենա մոտ ապագայում։

Ամենահեղափոխական գաղափարներից մեկը, որը հանգեցրեց ավտոմատ թվային համակարգիչների ստեղծմանը, 19-րդ դարի 20-ական թվականներին Չարլզ Բեբիջի կողմից արտահայտված գաղափարն էր՝ հաշվարկների հետագա ավտոմատ իրականացման համար մեքենայի աշխատանքի կարգը նախապես գրանցելու մասին՝ ծրագիր. . Եվ, չնայած Babyge-ի կողմից օգտագործվող ծակված քարտերի վրա ծրագրերի ձայնագրումը, որը հորինել է ֆրանսիացի գյուտարար Ժոզեֆ Մարի Ժակարդի կողմից նման մեքենաները կառավարելու համար, տեխնիկապես ոչ մի ընդհանուր բան չունի ԱՀ-ում ծրագրերը պահելու ժամանակակից մեթոդների հետ, այստեղ սկզբունքը ըստ էության նույնն է: Այս պահից սկսվում է ծրագրավորման պատմությունը։
Babidge-ի ժամանակակից Ադա Լևելասին անվանում են աշխարհի առաջին ծրագրավորող: Նա տեսականորեն մշակել է հաշվարկների հաջորդականությունը վերահսկելու որոշ տեխնիկա, որոնք այսօր էլ օգտագործվում են ծրագրավորման մեջ: Նա նաև նկարագրեց գրեթե ցանկացած ժամանակակից ծրագրավորման լեզվի ամենակարևոր կառուցվածքներից մեկը՝ օղակը:

Ծրագրավորման լեզուների պատմության մեջ հեղափոխական պահը հատուկ նիշերի օգտագործմամբ մեքենայական հրահանգների կոդավորման համակարգի առաջացումն էր, որն առաջարկել էր Ջոն Մաուչլին: Նրա առաջարկած կոդավորման համակարգը ոգեշնչեց իր գործընկերներից մեկին՝ Գրեյս Մյուրեյ Հոփերին: Mark-1 համակարգչի վրա աշխատելիս նա և իր խումբը ստիպված եղան բախվել բազմաթիվ խնդիրների, և այն ամենը, ինչ նրանք հայտնվեցին, առաջին անգամն էր: Մասնավորապես, նրանք ենթածրագրերով են հանդես եկել. Եվ ծրագրավորման տեխնիկայի մեկ այլ հիմնարար հայեցակարգ առաջին անգամ ներկայացվեց Հոփերի և նրա խմբի կողմից՝ «վրիպազերծում»:
40-ականների վերջին J. Mauchly-ն ստեղծեց «Կարճ կոդ» կոչվող համակարգը, որը պարզունակ բարձր մակարդակի ծրագրավորման լեզու էր: Դրանում ծրագրավորողը գրել է լուծվող խնդիրը մաթեմատիկական բանաձևերի տեսքով, իսկ հետո հատուկ աղյուսակի միջոցով թարգմանել նիշ առ նիշ՝ այդ բանաձևերը վերածելով երկտառանի կոդերի։ Հետագայում հատուկ համակարգչային ծրագիր այս կոդերը վերածեց երկուական մեքենայի կոդի: J. Mauchly-ի մշակած համակարգը համարվում է առաջին պարզունակ թարգմանիչներից մեկը։

Արդեն 1951 թվականին Հոփերը ստեղծեց աշխարհում առաջին կոմպիլյատորը և նա նույնպես ներմուծեց այս տերմինը: Hopper կոմպիլյատորը կատարում էր հրամանների համակցման գործառույթը և թարգմանության ընթացքում կազմակերպում էր ենթածրագրերը, հատկացնում համակարգչի հիշողությունը և բարձր մակարդակի հրամանները (այն ժամանակ կեղծ կոդեր) վերածում մեքենայի հրամանների։ «Ենթածրագրերը գտնվում են գրադարանում (համակարգչում), և երբ դուք ընտրում եք նյութը գրադարանից, դա կոչվում է հավաքում», - այսպես բացատրեց նա իր հորինած տերմինի ծագումը:

1954 թվականին Գ.Հոփերի գլխավորած խումբը մշակեց համակարգ, որը ներառում էր ծրագրավորման լեզու և կոմպիլյատոր, որը հետագայում կոչվեց Math-Matic։ Երբ Math-Matic-ը հաջողությամբ ավարտվեց, Հոփերը և նրա թիմը ձեռնամուխ եղան նոր լեզվի և կոմպիլյատորի մշակմանը, որը թույլ կտա օգտվողներին ծրագրավորել սովորական անգլերենին նման լեզվով: 1958 թվականին հայտնվեց Flow-Matic կոմպիլյատորը։ Flow-Matic կոմպիլյատորը առաջին լեզուն էր առևտրային տվյալների մշակման առաջադրանքների համար:
Այս ուղղությամբ զարգացումները հանգեցրին COBOL լեզվի (Common Business Oriented Language) ստեղծմանը: Այն ստեղծվել է 1960 թվականին։ Այս լեզվով, համեմատած Fortran-ի և Algol-ի հետ, մաթեմատիկական գործիքներն ավելի քիչ են զարգացած, բայց լավ զարգացած են տեքստի մշակման գործիքները և տվյալների ելքի կազմակերպումը պահանջվող փաստաթղթի տեսքով: Այն նախատեսված էր որպես կառավարման և բիզնես ոլորտներում տվյալների զանգվածային մշակման հիմնական լեզու:

50-ականների կեսերը բնութագրվում են ծրագրավորման ոլորտում արագ առաջընթացով։ Ծրագրավորման դերը մեքենայի հրամաններում սկսեց նվազել։ Սկսեցին ի հայտ գալ ծրագրավորման լեզուների նոր տեսակներ, որոնք հանդես էին գալիս որպես միջնորդ մեքենաների և ծրագրավորողների միջև: Առաջինը և ամենատարածվածներից մեկը Fortran-ն էր (FORTRAN, FORmula TRANslator-ից՝ բանաձեւի թարգմանիչ), որը մշակվել է IBM-ի մի խումբ ծրագրավորողների կողմից 1954 թվականին (առաջին տարբերակը)։ Այս լեզուն կենտրոնացած էր մաթեմատիկական բնույթի գիտական ​​և տեխնիկական հաշվարկների վրա և դասական ծրագրավորման լեզու է համակարգչի վրա մաթեմատիկական և ինժեներական խնդիրների լուծման համար:
Առաջին բարձր մակարդակի ծրագրավորման լեզուների համար լեզուների առարկայական կողմնորոշումը բնորոշ հատկանիշ էր:
Ծրագրավորման լեզուների շարքում առանձնահատուկ տեղ է զբաղեցնում Algol-ը, որի առաջին տարբերակը հայտնվել է 1958 թվականին։ Algol-ի մշակողներից մեկը Ֆորտրանի «հայրն» էր՝ Ջոն Բակուսը: ALGOrithmic Language անվանումը ընդգծում է այն փաստը, որ այն նախատեսված է ալգորիթմներ գրելու համար։ Իր հստակ տրամաբանական կառուցվածքի շնորհիվ Algol-ը դարձել է գիտական ​​և տեխնիկական գրականության մեջ ալգորիթմներ գրելու ստանդարտ միջոց։

60-ականների կեսերին Թոմաս Կուրցը և Ջոն Կամենին (Դարտմութ քոլեջի մաթեմատիկայի բաժնի աշխատակիցներ) ստեղծեցին ծրագրավորման մասնագիտացված լեզու, որը բաղկացած էր պարզ անգլերեն բառերից։ Նոր լեզուն կոչվում էր «Սկսնակ բոլոր նպատակային սիմվոլիկ հրահանգների կոդ, կամ կարճ՝ «BASIC»: Նոր լեզվի ծննդյան տարեթիվը կարելի է համարել 1964 թվականը: Այսօր ունիվերսալ BASIC լեզուն (որն ունի բազմաթիվ տարբերակներ) մեծ ժողովրդականություն է ձեռք բերել և տարածված է տարբեր կատեգորիաների ԱՀ օգտագործողների շրջանում ամբողջ աշխարհում: Դրան մեծապես նպաստեց այն, որ BASIC-ը սկսեց օգտագործվել որպես անհատական ​​համակարգիչների ներկառուցված լեզու, որի լայն կիրառումը սկսվեց 70-ականների վերջին։ Այնուամենայնիվ, BASIC-ը չկառուցված լեզու է և, հետևաբար, վատ հարմարեցված է որակյալ ծրագրավորում դասավանդելու համար: Արդարության համար պետք է նշել, որ համակարգիչների համար BASIC-ի վերջին տարբերակները (օրինակ՝ QBasic) դարձել են ավելի կառուցվածքային և իրենց տեսողական հնարավորություններով մոտենում են այնպիսի լեզուների, ինչպիսին է Pascal-ը:

Մշակողները կենտրոնացրել են լեզուները տարբեր դասերի առաջադրանքների վրա, դրանք այս կամ այն ​​չափով կապել են որոշակի համակարգչի ճարտարապետության հետ և իրականացրել անձնական ճաշակներ և գաղափարներ: 60-ականներին փորձեր արվեցին հաղթահարել այդ «տարաձայնությունը»՝ ստեղծելով ունիվերսալ ծրագրավորման լեզու։ Այս ուղղության առաջին գաղափարը եղել է PL/1 (Programm Language One), որը մշակվել է IBM-ի կողմից 1967 թվականին: Այս լեզուն պնդում էր, որ կարող է լուծել ցանկացած խնդիր՝ հաշվարկ, տեքստի մշակում, տեղեկատվության կուտակում և առբերում: Այնուամենայնիվ, պարզվեց, որ այն չափազանց բարդ էր, դրանից թարգմանիչը բավականաչափ օպտիմալ չէր և պարունակում էր մի շարք չբացահայտված սխալներ:
Այնուամենայնիվ, լեզուների համընդհանուրացման գիծը աջակցվեց: Հին լեզուները արդիականացվել են ունիվերսալ տարբերակների` ALGOL-68 (1968), Fortran-77: Ենթադրվում էր, որ նման լեզուները կզարգանան և կբարելավվեն և կսկսեն տեղահանել բոլոր մյուսները: Սակայն այս փորձերից ոչ մեկը հաջողությամբ չպսակվեց։

LISP լեզուն հայտնվել է 1965 թվականին։ Դրանում հիմնական հասկացությունը ռեկուրսիվորեն սահմանված ֆունկցիաների հասկացությունն է։ Քանի որ ապացուցված է, որ ցանկացած ալգորիթմ կարելի է նկարագրել՝ օգտագործելով որոշակի ռեկուրսիվ ֆունկցիաներ, LISP-ն ըստ էության ունիվերսալ լեզու է։ ԱՀ-ն իր օգնությամբ կարող է մոդելավորել բավականին բարդ գործընթացներ, մասնավորապես՝ մարդկանց ինտելեկտուալ գործունեությունը։
Prolog-ը մշակվել է Ֆրանսիայում 1972 թվականին՝ «արհեստական ​​ինտելեկտի» խնդիրները լուծելու համար։ Prologue-ը թույլ է տալիս պաշտոնապես նկարագրել տարբեր հայտարարություններ, տրամաբանության տրամաբանությունը և ստիպում է ԱՀ-ին տալ պատասխաններ տրված հարցերին:
Ծրագրավորման լեզուների պատմության մեջ նշանակալի իրադարձություն էր 1971 թվականին Պասկալ լեզվի ստեղծումը։ Դրա հեղինակը շվեյցարացի գիտնական Նիկլաուս Վիրտն է։ Վիրտն այն անվանել է 17-րդ դարի ֆրանսիացի մեծ մաթեմատիկոս և կրոնական փիլիսոփա Բլեզ Պասկալի պատվին, ով հորինել է առաջին ավելացնող սարքը, ինչի պատճառով էլ նոր լեզուն անվանվել է նրա անունով։ Այս լեզուն ի սկզբանե մշակվել է որպես կառուցվածքային ծրագրավորման կրթական լեզու, և, իսկապես, այժմ այն ​​դպրոցներում և համալսարաններում ծրագրավորման դասավանդման հիմնական լեզուներից մեկն է:

1975-ին երկու իրադարձություն դարձան ծրագրավորման պատմության կարևոր իրադարձություններ. Բիլ Գեյթսը և Փոլ Ալենը հայտարարեցին իրենց՝ մշակելով BASIC-ի իրենց տարբերակը, իսկ Վիրտն ու Ջենսենը թողարկեցին լեզվի դասական նկարագրությունը՝ «Pascal User Manual and Report»:

Ոչ պակաս տպավորիչ, այդ թվում՝ ֆինանսական հաջողությունների է հասել Ֆիլիպ Կանը՝ ֆրանսիացի, ով մշակել է Turbo-Pascal համակարգը 1983 թվականին։ Նրա գաղափարի էությունը ծրագրի մշակման հաջորդական փուլերը՝ կոմպիլացիա, հղումների խմբագրում, վրիպազերծում և սխալների ախտորոշում համատեղելն էր մեկ ինտերֆեյսի մեջ։ Turbo Pascal-ը ոչ միայն լեզու և թարգմանիչ է դրանից, այլ նաև գործող պատյան, որը թույլ է տալիս օգտագործողին հարմարավետ աշխատել Pascal-ով: Այս լեզուն դուրս է եկել իր կրթական նպատակից և դարձել է ունիվերսալ հնարավորություններով ծրագրավորման պրոֆեսիոնալ լեզու։ Այս առավելությունների շնորհիվ Պասկալը դարձել է բազմաթիվ ժամանակակից ծրագրավորման լեզուների աղբյուր։ Այդ ժամանակից ի վեր Turbo Pascal-ի մի քանի տարբերակներ են հայտնվել, որոնցից վերջինը յոթերորդն է:
Borland/Inprise-ն ավարտեց Turbo Pascal արտադրանքի գիծը և անցավ Windows-ի համար տեսողական զարգացման համակարգի թողարկմանը՝ Delphi-ին:

C լեզուն (առաջին տարբերակ – 1972), որը շատ տարածված է ծրագրային համակարգերի (ներառյալ օպերացիոն համակարգեր) մշակողների շրջանում, մեծ հետք է թողել ժամանակակից ծրագրավորման վրա։ Այս լեզուն ստեղծվել է որպես գործիքային լեզու՝ օպերացիոն համակարգերի, թարգմանիչների, տվյալների բազաների և այլ համակարգային ու կիրառական ծրագրերի մշակման համար։ C-ն համատեղում է ինչպես բարձր մակարդակի լեզվի, այնպես էլ մեքենայական լեզվի առանձնահատկությունները՝ թույլ տալով ծրագրավորողին մուտք գործել մեքենայական բոլոր ռեսուրսները, որոնք լեզուները, ինչպիսիք են BASIC-ը և Pascal-ը, չեն տրամադրում:
60-ականների վերջից մինչև 80-ականների սկիզբն ընկած ժամանակահատվածը բնութագրվում էր տարբեր ծրագրավորման լեզուների թվի արագ աճով, որոնք ուղեկցում էին ծրագրային ապահովման ճգնաժամին: 1975 թվականի հունվարին Պենտագոնը որոշեց կարգի բերել թարգմանիչների քաոսը և ստեղծեց հանձնաժողով, որին հանձնարարվեց զարգացնել մեկ համընդհանուր լեզու: 1979 թվականի մայիսին հաղթողը հայտարարվեց՝ գիտնականների խումբը՝ Ժան Իխբիայի գլխավորությամբ։ Հաղթող լեզուն մկրտվել է Ադա՝ ի պատիվ Ավգուստա Ադա Լևելասի: Այս լեզուն նախատեսված է խոշոր ծրագրային համակարգերի ստեղծման և երկարաժամկետ (երկարաժամկետ) պահպանման համար, այն թույլ է տալիս զուգահեռ մշակել և իրական ժամանակում վերահսկել գործընթացները:

Երկար տարիներ ծրագրակազմը կառուցվել է գործառնական և ընթացակարգային լեզուների հիման վրա, ինչպիսիք են Fortran, BASIC, Pascal, Ada, C: Ծրագրավորման լեզուների զարգացման հետ մեկտեղ լայն տարածում գտան ծրագրեր ստեղծելու այլ, սկզբունքորեն տարբեր մոտեցումներ:
Կան ծրագրավորման լեզուների մեծ թվով դասակարգումներ՝ ըստ տարբեր չափանիշների: Ամենատարածված դասակարգումներն են.
 բարձր մակարդակի (Pascal, BASIC) և ցածր մակարդակի ծրագրավորման լեզուներ (Assembler);
 խիստ տպագրված (Pascal) և թույլ տպագրված (BASIC);
 օբյեկտի վրա հիմնված ծրագրավորման աջակցությամբ և առանց դրա (C++) և այլն:

Դիտարկենք մեկ այլ դասակարգում. Ծրագրավորման լեզուները բաժանվում են.
1) մեքենա ուղղված լեզուներ.
- մեքենայական լեզուներ;
- խորհրդանշական կոդավորման լեզուներ;
 ավտոմատ կոդեր;
- մակրո.
2) Մեքենայից անկախ լեզուներ.
- խնդրին ուղղված լեզուներ;
- ունիվերսալ լեզուներ;
- ինտերակտիվ լեզուներ;
- ոչ ընթացակարգային լեզուներ.

Մեքենա-կողմնորոշված ​​լեզուներ

Մեքենա-կողմնորոշված ​​լեզուները այն լեզուներն են, որոնց օպերատորների և գրաֆիկական միջոցների հավաքածուները զգալիորեն կախված են ԱՀ-ի բնութագրերից (ներքին լեզու, հիշողության կառուցվածք և այլն): Մեքենա-կողմնորոշված ​​լեզուներն ունեն հետևյալ հատկանիշները.
 ստեղծված ծրագրերի բարձր որակ (կոմպակտություն և կատարման արագություն);
 հատուկ ապարատային ռեսուրսներ օգտագործելու ունակություն.
 օբյեկտների կոդի և հիշողության կարգերի կանխատեսելիություն.
 արդյունավետ ծրագրեր ստեղծելու համար դուք պետք է իմանաք այս ԱՀ-ի հրամանատարական համակարգը և գործառնական առանձնահատկությունները.
 ծրագրեր գրելու աշխատատար գործընթացը (հատկապես մեքենայական լեզուներով և ԲԲԸ), որը վատ պաշտպանված է սխալներից.
 ցածր ծրագրավորման արագություն;
 այլ տեսակի համակարգիչների վրա այս լեզուներով կազմված ծրագրերն ուղղակիորեն օգտագործելու անհնարինությունը:
Մեքենակենտրոն լեզուները բաժանվում են դասերի՝ ըստ ավտոմատ ծրագրավորման աստիճանի։

Մեքենայի լեզու

Առանձին համակարգիչն ունի իր հատուկ մեքենայական լեզուն (այսուհետ՝ ML), այն նախատեսված է որոշակի գործողություններ կատարել իրենց սահմանած օպերանդների վրա, հետևաբար ML-ը հրամանի լեզու է: Հրամանը հաղորդում է տեղեկատվություն օպերանդների գտնվելու վայրի և կատարվող գործողության տեսակի մասին:
ԱՀ-ի նոր մոդելներում նկատվում է ապարատային ներքին լեզուների բարելավման միտում՝ ավելի բարդ հրամաններ իրականացնելու համար, որոնք իրենց ֆունկցիոնալ գործողություններով ավելի մոտ են ալգորիթմական ծրագրավորման լեզուների օպերատորներին:

Խորհրդանշական կոդավորման լեզուներ

Խորհրդանշական կոդավորման լեզուները (այսուհետ՝ SKL), ինչպես ML-ն, հրամանի լեզուներ են: Այնուամենայնիվ, մեքենայի հրահանգների գործառնական կոդերը և հասցեները, որոնք երկուական (ներքին կոդով) կամ օկտալ (հաճախ օգտագործվում են ծրագրեր գրելիս) թվանշանների հաջորդականություն, ԵԳԿ-ում փոխարինվում են սիմվոլներով (իդենտիֆիկատորներով), որոնց գրելու ձևն օգնում է ծրագրավորողին։ ավելի հեշտ է հիշել գործողության իմաստային բովանդակությունը: Սա ապահովում է ծրագրեր կազմելիս սխալների թվի զգալի կրճատում։
Խորհրդանշական հասցեների օգտագործումը YASK ստեղծելու առաջին քայլն է: ԱՀ հրամանները պարունակում են սիմվոլիկ հասցեներ՝ իրական (ֆիզիկական) հասցեների փոխարեն: Կազմված ծրագրի արդյունքների հիման վրա որոշվում է նախնական միջանկյալ և ստացված արժեքները պահելու համար անհրաժեշտ քանակությամբ բջիջներ: Հասցեների նշանակումը, որը կատարվում է ծրագրի կազմումից առանձին՝ խորհրդանշական հասցեներով, կարող է իրականացվել ոչ այնքան որակավորված ծրագրավորողի կամ հատուկ ծրագրի կողմից, որը մեծապես հեշտացնում է ծրագրավորողի աշխատանքը։

Ավտոկոդեր

Կան լեզուներ, որոնք ներառում են ԵԳԿ-ի բոլոր հնարավորությունները՝ մակրոհրամանների ընդլայնված ներդրման միջոցով. դրանք կոչվում են ավտոկոդեր:

Տարբեր ծրագրերում կան բավականին հաճախ օգտագործվող հրամանների հաջորդականություններ, որոնք համապատասխանում են տեղեկատվության փոխակերպման որոշակի ընթացակարգերին: Նման ընթացակարգերի արդյունավետ իրականացումն ապահովվում է դրանց նախագծմամբ՝ հատուկ մակրոհրամանների տեսքով և վերջիններիս ծրագրավորողին հասանելի ծրագրավորման լեզվում ներառելով։ Մակրո հրամանները թարգմանվում են մեքենայական հրամանների երկու եղանակով՝ դասավորություն և սերունդ: Բեմադրման համակարգը պարունակում է «կմախքներ»՝ մի շարք հրամաններ, որոնք իրականացնում են պահանջվող գործառույթը՝ նշված մակրո հրամանով: Մակրո հրահանգները ապահովում են փաստացի պարամետրերի փոխանցում, որոնք թարգմանության գործընթացում տեղադրվում են ծրագրի «կմախքի» մեջ՝ այն վերածելով իրական մեքենայի ծրագրի:
Գեներացիոն համակարգում կան հատուկ ծրագրեր, որոնք վերլուծում են մակրո հրամանը, որոշում, թե ինչ գործառույթ է պետք կատարել և ձևավորում հրամանների անհրաժեշտ հաջորդականությունը, որոնք իրականացնում են այս գործառույթը:
Այս երկու համակարգերն էլ օգտագործում են JSC-ի թարգմանիչներ և մակրո հրամանների մի շարք, որոնք նաև ավտոկոդավորման օպերատորներ են:
Մշակված ավտոկոդերը կոչվում են հավաքիչներ։ Ծառայողական ծրագրերը և այլն, որպես կանոն, գրվում են անսամբլի լեզուներով։

Մակրո

Լեզուն, որը գործիք է համակարգչային պահանջվող գործողությունների կատարումը նկարագրող նիշերի հաջորդականությունը ավելի խտացված ձևով փոխարինելու համար, կոչվում է մակրո (փոխարինման գործիք):
Հիմնականում մակրոը նախատեսված է բնօրինակ ծրագրի ձայնագրությունը կրճատելու համար: Ծրագրային բաղադրիչը, որը հնարավորություն է տալիս մակրոներին գործել, կոչվում է մակրոպրոցեսոր: Մակրոպրոցեսորը ստանում է մակրոսահմանող և սկզբնաղբյուր տեքստ: Մակրոպրոցեսորի պատասխանը զանգին ելքային տեքստ թողարկելն է:
Մակրոները կարող են հավասարապես աշխատել ինչպես ծրագրերի, այնպես էլ տվյալների հետ:

Մեքենայից անկախ լեզուներ

Մեքենայից անկախ լեզուները խնդիրների և մշակման ենթակա տեղեկատվության լուծման ալգորիթմների նկարագրության միջոց են: Դրանք հեշտ է օգտագործել օգտատերերի լայն շրջանակի համար և նրանցից չեն պահանջում իմանալ ԱՀ-ի աշխատանքի կազմակերպման առանձնահատկությունները:
Նման լեզուները կոչվում են բարձր մակարդակի ծրագրավորման լեզուներ: Նման լեզուներով կազմված ծրագրերը հայտարարությունների հաջորդականություն են, որոնք կառուցված են լեզվի դիտման կանոնների համաձայն (առաջադրանքներ, հատվածներ, բլոկներ և այլն): Լեզուների օպերատորները նկարագրում են այն գործողությունները, որոնք համակարգը պետք է կատարի ծրագիրը ML-ի թարգմանելուց հետո:
Այսպիսով, հրամանների հաջորդականությունները (ընթացակարգերը, ենթածրագրերը), որոնք հաճախ օգտագործվում են մեքենայական ծրագրերում, ներկայացված են բարձր մակարդակի լեզուներով առանձին հայտարարություններով: Ծրագրավորողը կարողացել է ոչ թե մանրամասն նկարագրել հաշվողական գործընթացը մեքենայի հրահանգների մակարդակով, այլ կենտրոնանալ ալգորիթմի հիմնական հատկանիշների վրա։

Խնդրահարույց լեզուներ

Համակարգչային տեխնոլոգիաների կիրառման ոլորտների ընդլայնմամբ անհրաժեշտություն առաջացավ ձևակերպել նոր դասերի խնդիրների ձևակերպման և լուծման ներկայացումը։ Անհրաժեշտ էր ստեղծել ծրագրավորման լեզուներ, որոնք, օգտագործելով նշումներ և տերմինաբանություն այս ոլորտում, հնարավորություն կտար նկարագրել հանձնարարված խնդիրների լուծման համար անհրաժեշտ ալգորիթմները: Այս լեզուները կենտրոնացած են կոնկրետ խնդիրների լուծման վրա և պետք է ծրագրավորողին տրամադրեն գործիքներ, որոնք թույլ կտան համառոտ և հստակ ձևակերպել խնդիրը և ստանալ արդյունքներ անհրաժեշտ ձևով:
Կան բազմաթիվ խնդրահարույց լեզուներ, օրինակ.
- Fortran, Algol – լեզուներ, որոնք ստեղծված են մաթեմատիկական խնդիրների լուծման համար.
- Simula, Slang - մոդելավորման համար;
- Lisp, Snoball - ցուցակի կառուցվածքների հետ աշխատելու համար:

Ունիվերսալ լեզուներ

Ունիվերսալ լեզուները ստեղծվել են խնդիրների լայն շրջանակի համար՝ առևտրային, գիտական, մոդելավորում և այլն: Առաջին ունիվերսալ լեզուն մշակվել է IBM-ի կողմից, որը լեզուների հաջորդականությամբ դարձել է PL/1: Երկրորդ ամենահզոր ունիվերսալ լեզուն կոչվում է ALGOL-68:

Խոսակցական լեզուներ

Նոր տեխնիկական հնարավորությունների ի հայտ գալը խնդիր է դրել համակարգի ծրագրավորողների համար՝ ստեղծել ծրագրային գործիքներ, որոնք ապահովում են մարդու և ԱՀ-ի արագ փոխազդեցությունը, դրանք կոչվում են ինտերակտիվ լեզուներ:
Այս աշխատանքն իրականացվել է երկու ուղղությամբ. Ստեղծվել են կառավարման հատուկ լեզուներ՝ առաջադրանքների կատարման վրա գործառնական ազդեցություն ապահովելու համար, որոնք կազմվել են նախկինում չմշակված (ոչ երկխոսության) լեզուներով: Մշակվել են նաև լեզուներ, որոնք, բացի կառավարման նպատակներից, կապահովեն խնդիրների լուծման ալգորիթմների նկարագրություն:
Օգտատիրոջ հետ արագ փոխազդեցության ապահովման անհրաժեշտությունը պահանջում էր աղբյուրի ծրագրի պատճենը պահել համակարգչային հիշողության մեջ նույնիսկ օբյեկտի ծրագիրը մեքենայական կոդով ստանալուց հետո: Ծրագրում փոփոխություններ կատարելիս ինտերակտիվ լեզվով, ծրագրավորման համակարգը, օգտագործելով հատուկ աղյուսակներ, հաստատում է կապը աղբյուրի և օբյեկտի ծրագրերի կառուցվածքների միջև: Սա թույլ է տալիս կատարել անհրաժեշտ խմբագրական փոփոխությունները օբյեկտ ծրագրում:
Խոսակցական լեզուների օրինակներից մեկը BASIC-ն է:

Ոչ ընթացակարգային լեզուներ

Ոչ ընթացակարգային լեզուները կազմում են լեզուների խումբ, որը նկարագրում է մշակված տվյալների կազմակերպումը ֆիքսված ալգորիթմների միջոցով (աղյուսակային լեզուներ և հաշվետվությունների գեներատորներ) և օպերացիոն համակարգերի հետ հաղորդակցվելու լեզուներ:
Թույլ տալով ձեզ հստակ նկարագրել և՛ առաջադրանքը, և՛ դրա լուծման համար անհրաժեշտ գործողությունները, որոշումների աղյուսակները հնարավորություն են տալիս հստակորեն որոշել, թե ինչ պայմաններ պետք է բավարարվեն՝ նախքան որևէ գործողության անցնելը: Որոշումների մեկ աղյուսակը, որը նկարագրում է որոշակի իրավիճակ, պարունակում է լուծման ալգորիթմների իրականացման բոլոր հնարավոր բլոկային դիագրամները:
Աղյուսակային մեթոդները հեշտությամբ յուրացվում են ցանկացած մասնագիտության մասնագետների կողմից: Աղյուսակային լեզվով գրված ծրագրերը հարմար կերպով նկարագրում են բարդ իրավիճակներ, որոնք առաջանում են համակարգի վերլուծության ժամանակ:
Ծրագրավորման լեզուները ծառայում են տարբեր նպատակների, և դրանց ընտրությունը որոշվում է օգտատերերի հարմարավետությամբ, տվյալ համակարգչի և տվյալ առաջադրանքի համար համապատասխանությամբ: Իսկ համակարգչի համար խնդիրները կարող են լինել շատ բազմազան՝ հաշվողական, տնտեսական, գրաֆիկական, փորձագիտական ​​և այլն: Համակարգչի կողմից լուծվող խնդիրների այս բազմազանությունը որոշում է ծրագրավորման լեզուների բազմազանությունը: Ծրագրավորման մեջ լավագույն արդյունքները ձեռք են բերվում անհատական ​​մոտեցմամբ՝ հիմնված խնդրի դասի, մակարդակի և ծրագրավորողի հետաքրքրությունների վրա։

Basic և Visual Basic ծրագրավորման լեզուների ստեղծման պատմությունը

Հիմնական ծրագրավորման լեզուն ստեղծվել է 1964 թվականին Դարթմութ քոլեջի երկու դասախոսների՝ Ջոն Քենեմիի և Թոմաս Կուրցի կողմից՝ ուսանողներին ծրագրավորման հմտություններ սովորեցնելու համար։ Լեզուն այնքան պարզ ու հասկանալի է ստացվել, որ որոշ ժամանակ անց այն սկսել է օգտագործել այլ ուսումնական հաստատություններում։ 1975 թվականին, երբ հայտնվեցին առաջին միկրոհամակարգիչները, հիմնական էստաֆետը ստանձնեցին Microsoft-ի հիմնադիրներ Բիլ Գեյթսը և Փոլ Ալենը: Հենց նրանք ստեղծեցին Basic-ի նոր տարբերակը առաջին Altair համակարգիչների համար (MITS Altairs), որը կարող է աշխատել 4KB RAM-ով: Ժամանակի ընթացքում հենց այս տարբերակն էր, որ վերածվեց աշխարհի ամենահայտնի ծրագրավորման լեզուներից մեկի: Փառքի գագաթնակետին հասնելու ճանապարհին Basic-ը բազմաթիվ դժվարություններ ունեցավ, որոնք միշտ պատվով հաղթահարեց, և երբ հայտնվեցին IBM PC առաջին անհատական ​​համակարգիչները, այն դարձավ ստանդարտ ծրագրավորման մեջ, բայց GW-Basic-ի տեսքով։ Այնուհետև կային Turbo Basic, QuickBasic, Basic PDS, բայց միշտ լեզվի նոր տարբերակ մշակելիս, նախկին տարբերակների հետ համատեղելիությունը պահպանվում էր, և գրեթե առաջին Basic-ի համար գրված ծրագիրը կարող էր լավ (փոքր փոփոխություններով) աշխատել դրա հետագա տարբերակներում։ լեզու. Բայց եկել են նոր ժամանակներ, և 90-ականների սկզբին հայտնվեց Microsoft Windows օպերացիոն համակարգը նոր գրաֆիկական ինտերֆեյսով (GUI):

Ծրագրավորողների կյանքը դարձել է դժոխք. Պարզ ծրագիր ստեղծելու համար պետք է գրել մի քանի էջ կոդ՝ ստեղծել ընտրացանկեր և պատուհաններ, փոխել տառատեսակները, մաքրել հիշողությունը, «գծել» կոճակները և այլն: Այնուամենայնիվ, նոր ինտերֆեյսի առավելություններն այնքան անհերքելի էին, որ այս օպերացիոն համակարգի արդեն երրորդ տարբերակը դարձավ դե ֆակտո ստանդարտ անհատական ​​համակարգչի համար։ Այս պահին Microsoft-ի շրջանակներում մի քանի զուգահեռ նախագծեր էին ընթանում՝ Windows-ի համար ծրագրավորման նոր լեզու ստեղծելու համար։ Իսկ 1991-ին «այժմ նույնիսկ սկսնակ ծրագրավորողները կարող են հեշտությամբ հավելվածներ ստեղծել Windows-ի համար» կարգախոսի ներքո հայտնվեց նոր Microsoft Visual Basic գործիքի առաջին տարբերակը: Այդ պահին Microsoft-ը բավականին համեստորեն գնահատեց այս համակարգի հնարավորությունները՝ թիրախավորելով այն առաջին հերթին սկսնակների և ոչ պրոֆեսիոնալ ծրագրավորողների կատեգորիայի վրա։ Այնուհետև հիմնական խնդիրն այն էր, որ շուկա թողարկվի մի պարզ և հարմար մշակման գործիք այն ժամանակվա բավականին նոր Windows միջավայրում, որի ծրագրավորումը խնդիր էր նույնիսկ փորձառու մասնագետների համար: Visual Basic-ի ծրագրավորողների կողմից ստեղծված ծրագրավորման համակարգը հնարավորություն տվեց «հետ կանգնել» Windows-ի բարդ ներքին կառուցվածքից և ծրագրեր ստեղծել «խորանարդներից», ինչպես մանկական շինարարական հավաքածուում: Ցանկերը, պատուհանները, ցուցակները, կոճակները, տեքստի մուտքագրման դաշտերը և Windows ինտերֆեյսի այլ տարրեր ավելացվել են ծրագրին՝ օգտագործելով պարզ քաշել և թողնել գործողությունները:

VB ծրագրավորողները ստեղծեցին իրենց առաջին ծրագիրը այս լեզուն սովորելուց մի քանի րոպեի ընթացքում: Ավելին, Visual Basic-ը ծրագրավորողներին թույլ է տվել ստեղծել նոր «խորանարդային» օբյեկտներ, որոնք կարող են օգտագործվել նաև ծրագրերում՝ ստանդարտների հետ մեկտեղ: Եվ չնայած C-ի շատ ծրագրավորողներ լուռ ծիծաղում էին Microsoft-ի՝ Windows-ի ծրագրեր մշակելու համար պարզ և հասկանալի գործիք ստեղծելու փորձերի վրա, Visual Basic-ը սկսեց իր հաղթական երթը աշխարհով մեկ, և ոչինչ չկարողացավ կանգնեցնել այս գործընթացը: Վերջնական արգելքներն ընկան 1994 թվականին Visual Basic-ի հավելվածների թողարկմամբ: Հենց այս ժամանակ, Microsoft Office-ում VBA-ի ընդգրկումից հետո, Basic-ը սկսեց վերածվել Windows-ի հիմնական ծրագրավորման ստանդարտներից մեկի։ Microsoft-ի համար Basic լեզուն ժամանակին առանձնահատուկ նշանակություն ունի, Altair 8800 համակարգչի հիմնական տարբերակի մշակումը նշանավորեց նրա հիմնադիրների՝ Բիլ Գեյթսի և Փոլ Ալենի ծրագրավորման կարիերայի սկիզբը: Հետևաբար, մի ժամանակ՝ 1989 թվականին, երբ եկավ տարբեր ընկերությունների միջև տարբեր ծրագրավորման լեզուներով զարգացման միջավայրեր ստեղծելու հիմնական ուղղությունները բաշխելու ժամանակը, Microsoft-ը պահպանեց QuickBasic-ը՝ Basic-ում ծրագրեր մշակելու միջավայր՝ հրաժարվելով, օրինակ, հետագա աշխատել Pascal-ի ծրագրավորման լեզվի վրա՝ այն թողնելով Borland-ին, որն իր հերթին դադարեցրեց իր Basic տարբերակի աշխատանքը (Pascal-ը հետագայում դարձավ Delphi լեզու):

Microsoft-ի Visual Basic-ն ի սկզբանե նախատեսված էր որպես խաղալիք, փոթորկի տակ ընկավ ծրագրավորման աշխարհը: Դրա ժողովրդականությունը պայմանավորված է երկու պատճառով՝ հարաբերական պարզությամբ և արտադրողականությամբ: VB ծրագրերն ավելի դանդաղ են, քան իրենց C/C++ գործընկերները, սակայն դրանք դեռ բավականաչափ արագ են բազմաթիվ բիզնես նպատակների համար և պահանջում են շատ ավելի քիչ մշակման ժամանակ: Ձևերը նույն ջանք խնայող աբստրակցիան էին, որը VB-ն առաջարկում էր Windows ծրագրավորողներին: VB IDE-ն հնարավորություն տվեց նախագծել պատուհանները գրաֆիկորեն՝ գործիքագոտուց քաշելով կառավարիչներ, ինչպիսիք են կոճակները և ցուցակի տուփերը: Երբ գոհ էիք ձևի տեսքից, կարող եք անցնել կոդի կողմը և գրել իրադարձությունների մշակիչներ յուրաքանչյուր ձևի կառավարման համար:

Այսպիսով, VB-ում հավելվածի մշակումը բաղկացած էր մի քանի ձևաթղթերի ստեղծումից, որոնք զրուցում էին միմյանց հետ և, հնարավոր է, խորհրդակցում էին տվյալների բազայի վրա՝ անհրաժեշտ տեղեկատվության համար: Ստացված ձևը պարզվեց, որ պատուհանն էր, որն առաջարկում էր պատուհանապատման տեխնիկայի օգտագործման շատ ավելի հարմար տարբերակ: VB-ն նվազեցրել է սխալները՝ հեռացնելով որոշ թաքնված C/C++ շարահյուսություն: Բացառությամբ հատուկ դեպքերի, արտահայտությունները սահմանափակվում էին կոդի մեկ տողով, և փոփոխականները պետք է հայտարարվեին և սկզբնավորվեին կոդի առանձին տողերի վրա: Հանձնարարության և համեմատության օպերատորներն օգտագործում էին նույն նշանը, բայց VB քերականությունը պահանջում էր, որ այդ օպերատորները օգտագործվեին այնպես, որ պարզ դառնար նրանց մտադրությունը:

Ամենակարևորը, թերևս, չկային ցուցիչներ. Բիլ Գեյթսի պահանջը Microsoft BASIC-ի առաջին տարբերակներից ի վեր: Թեև ցուցիչները օգտակար են, քանի որ դրանք թույլ են տալիս անմիջական մուտք դեպի հիշողություն ցանկացած հասցեով, դրանց օգտագործումը հակված է սխալների, եթե դրանք ուշադիր չեն օգտագործվում: BASIC-ի քերականական պարզության պահանջը բխում է նրանից, որ այն ի սկզբանե ստեղծվել է որպես ուսուցման լեզու. «Սկսնակ»-ի բոլոր նպատակային սիմվոլիկ ուսուցման ծածկագիրը: VB-ի 6-րդ տարբերակն արդեն հզոր լեզու է, որը կարող է օգտագործվել բաշխված հավելվածներ ստեղծելու համար՝ օգտագործելով COM բաղադրիչները և Microsoft Transaction Server-ը առաջարկել են եռաստիճան մոտեցում հաճախորդ-սերվերի ճարտարապետությունների համար, որոնցում օգտագործողի բարակ միջերեսները փոխազդում են հեռավոր VB բաղադրիչների հետ՝ տվյալների բազայից կամ մեկ այլ մեքենայից ստանալու համար:

Օգտագործելով VBScript և VBA (VB for Applications), դուք կարող եք գրել սկրիպտներ վեբ բրաուզերների համար և ավտոմատացնել Microsoft Office հավելվածները: Ավելին, VB6-ը կարող է օգտագործվել Active-X կառավարիչներ ստեղծելու համար, որոնք աշխատում են Internet Explorer-ի հետ, թեև դա հազվադեպ է արվում, քանի որ պահանջում է VB-ի գործարկման ժամանակի DLL-ի տեղադրումը ինտերնետ-հաճախորդի մեքենայի վրա: Սկսած VB5-ից, VB ծրագրերը կազմվել են մեքենայի կոդով, սակայն դրանք հիմնված են եղել DLL-ի օգտագործման վրա, որն ապահովում է սովորաբար օգտագործվող գործառույթները և իրականացնում է VB-ի օբյեկտի հնարավորությունները: Հետաքրքիրն այն է, որ VB կոմպիլյատորը թարգմանության համար օգտագործում է բազմապատիկ ռեժիմ և, ի վերջո, հենվում է Microsoft C++ կոմպիլյատորի վրա՝ միջանկյալ լեզվով կոմպիլյացիայից հետո մեքենայի կոդ արտադրելու համար: .NET-ի սերմերը տեսանելի են VB-ի այս հատկանիշում` գործարկման ժամանակի գրադարանի և C++ backend-ի օգտագործումը:

C# ծրագրավորման լեզվի ստեղծման պատմություն

C# լեզուն ծնվել է 2000թ.-ի հունիսին՝ Անդերս Հեյլսբերգի գլխավորությամբ Microsoft-ի մշակողների մի մեծ խմբի քրտնաջան աշխատանքի արդյունքում: Այս մարդը հայտնի է որպես IBM անհատական ​​համակարգիչների համար կազմված առաջին ծրագրավորման լեզուներից մեկի՝ Turbo Pascal-ի հեղինակ: Հավանաբար, նախկին Խորհրդային Միության տարածքում շատ փորձառու ծրագրավորողներ և պարզապես մարդիկ, ովքեր այս կամ այն ​​ձևով ծրագրավորում են սովորել համալսարաններում, զգացել են այս արտադրանքի հմայքն ու օգտագործման հեշտությունը: Բացի այդ, Borland Corporation-ում աշխատելու ընթացքում Անդերս Հեյլսբերգը հայտնի դարձավ Delphi ինտեգրված միջավայրի ստեղծմամբ (նա ղեկավարեց այս նախագիծը մինչև 4.0 տարբերակի թողարկումը):
Պատահական չէր, որ C# լեզվի և .NET նախաձեռնության ի հայտ գալը տեղի ունեցավ 2000 թվականի ամռան սկզբին: Հենց այս պահին Microsoft-ը պատրաստեց նոր բաղադրիչ տեխնոլոգիաների և լուծումների արդյունաբերական տարբերակները հաղորդագրությունների փոխանակման և տվյալների փոխանակման ոլորտում. ինչպես նաև ինտերնետային հավելվածների ստեղծում (COM+, ASP+, ADO+, SOAP, Biztalk Framework): Անկասկած, այս նոր արտադրանքը գովազդելու լավագույն միջոցը մշակողների համար գործիքակազմ ստեղծելն է՝ նրանց լիարժեք աջակցությամբ: Սա նոր C# լեզվի գլխավոր նպատակներից մեկն է։ Բացի այդ, Microsoft-ն այլևս չէր կարող ընդլայնել նույն գործիքներն ու զարգացման լեզուները՝ դրանք ավելի ու ավելի բարդ դարձնելով ժամանակակից սարքավորումների աջակցության և 1990-ականների սկզբին ստեղծված արտադրանքների հետ հետամնաց համատեղելիության պահպանման հակասական պահանջներին բավարարելու համար: Windows-ի առաջին հայտնվելու ժամանակ։ Գալիս է մի պահ, երբ անհրաժեշտ է սկսել զրոյից, որպեսզի ստեղծվի լեզուների, միջավայրերի և զարգացման գործիքների պարզ, բայց բարդ շարք, որը թույլ կտա մշակողին հեշտությամբ ստեղծել ժամանակակից ծրագրային արտադրանք:

C#-ը և .NET-ը մեկնարկային կետն են: Պարզ ասած, .NET-ը նոր հարթակ է, Windows-ում ծրագրավորման նոր API, իսկ C#-ը նոր լեզու է, որը ստեղծվել է ի սկզբանե այդ պլատֆորմի հետ աշխատելու և զարգացման միջավայրի առաջընթացից լիարժեք օգտվելու համար: օբյեկտ-կողմնորոշված ​​ծրագրավորման սկզբունքների իմացություն վերջին 20 տարիների ընթացքում:
Պետք է նշել, որ հետամնաց համատեղելիությունը չի կորել։ Գործող ծրագրերը կաշխատեն, իսկ .NET պլատֆորմը ստեղծվել է գոյություն ունեցող ծրագրային ապահովման հետ աշխատելու համար: Windows-ի բաղադրիչների միջև հաղորդակցությունն այժմ գրեթե ամբողջությամբ իրականացվում է COM-ի միջոցով: Սա նկատի ունենալով, .NET-ը կարող է (ա) ստեղծել փաթաթումներ գոյություն ունեցող COM բաղադրիչների շուրջ, որպեսզի .NET բաղադրիչները կարողանան խոսել նրանց հետ, և (բ) ստեղծել փաթաթաներ .NET բաղադրիչների շուրջ, որպեսզի նրանք նման լինեն սովորական COM բաղադրիչներին:

C#-ի հեղինակները ձգտել են ստեղծել մի լեզու, որը համատեղում է ժամանակակից օբյեկտ-կողմնորոշված ​​լեզուների պարզությունն ու արտահայտիչությունը (ինչպես Java-ն) C++-ի հարստության և հզորության հետ: Ըստ Անդերս Հեյլսբերգի՝ C#-ն իր շարահյուսության մեծ մասը փոխառում է C++-ից։ Մասնավորապես, այն պարունակում է տվյալների այնպիսի հարմար տիպեր, ինչպիսիք են կառուցվածքները և թվարկումները (C++-ի մեկ այլ ժառանգորդ՝ Java-ն, չունի այդ տարրերը, ինչը որոշակի անհարմարություններ է ստեղծում ծրագրավորման ժամանակ): C# շարահյուսական կոնստրուկցիաները ժառանգվում են ոչ միայն C++-ից, այլև Visual Basic-ից։ Օրինակ, C#-ը, ինչպես և Visual Basic-ը, օգտագործում է դասի հատկություններ: Ինչպես C++-ը, C#-ն էլ թույլ է տալիս օպերատորի ծանրաբեռնում ձեր ստեղծած տեսակների համար (Java-ն չի աջակցում որևէ հատկանիշ): C#-ն իրականում տարբեր լեզուների հիբրիդ է: Միևնույն ժամանակ, C#-ը շարահյուսական առումով ոչ պակաս (եթե ոչ ավելի) մաքուր է Java-ից, Visual Basic-ի պես պարզ և ունի գրեթե նույն ուժն ու ճկունությունը, ինչ C++-ը։

C#-ի առանձնահատկությունները.

Հիմնական տեսակների ամբողջական և հստակ սահմանված հավաքածու:
- Ներկառուցված աջակցություն XML փաստաթղթերի ավտոմատ ստեղծման համար: Դինամիկ տեղաբաշխված հիշողության ավտոմատ թողարկում:
- Օգտատիրոջ կողմից սահմանված ատրիբուտներով դասեր և մեթոդներ նշելու ունակություն: Սա կարող է օգտակար լինել փաստաթղթավորման համար և կարող է ազդել կազմման գործընթացի վրա (օրինակ, կարող եք նշել մեթոդներ, որոնք պետք է կազմվեն միայն վրիպազերծման ռեժիմում):
- Ամբողջական մուտք դեպի .NET բազային դասի գրադարան, ինչպես նաև հեշտ մուտք դեպի Windows API (եթե իսկապես դրա կարիքն ունեք):
- Ցուցիչներ և ուղղակի հիշողության հասանելիություն, անհրաժեշտության դեպքում: Այնուամենայնիվ, լեզուն նախագծված է այնպես, որ գրեթե բոլոր դեպքերում դուք կարող եք անել առանց դրա:
- Աջակցություն VB ոճի հատկությունների և իրադարձությունների համար:
- Հեշտ է փոխել կոմպիլացիոն ստեղները: Թույլ է տալիս ձեռք բերել .NET բաղադրիչի գործադիրներ կամ գրադարաններ, որոնք կարող են կանչվել այլ կոդով այնպես, ինչպես ActiveX կոնտրոլները (COM բաղադրիչներ):
- C#-ի օգտագործման հնարավորություն՝ դինամիկ ASP.NET վեբ էջեր գրելու համար:

Մի ոլորտ, որի համար այս լեզուն նախատեսված չէ, ժամանակի կարևոր և բարձր թողունակության ծրագրերն են, որտեղ կարևոր է, թե արդյոք հանգույցը 1000 կամ 1050 մեքենայական ցիկլ է պահանջում, և ռեսուրսները պետք է անհապաղ թողարկվեն: C++-ը մնում է լավագույն ցածր մակարդակի լեզուն այս ոլորտում: C#-ին բացակայում են որոշ հիմնական գործառույթներ, որոնք անհրաժեշտ են բարձր արդյունավետությամբ հավելվածներ ստեղծելու համար, ինչպիսիք են ներկառուցված գործառույթները և դեստրուկտորները, որոնք երաշխավորված են գործարկվելու կոդի որոշակի կետերում: Այս լեզուն ակտիվորեն օգտագործվում է նաև ժամանակակից տեսախաղեր ստեղծելու համար, օրինակ՝ Battlefield 3 խաղը մասամբ գրված է C#-ով, իսկ ամբողջությամբ՝ .NET տեխնոլոգիայով։

Բաղկացած էր հաշվողական սարքի առջևի վահանակի վրա առանցքային անջատիչների տեղադրումից: Ակնհայտ է, որ այս կերպ կարելի էր գրել միայն փոքր ծրագրեր։

Համակարգչային տեխնոլոգիաների զարգացման հետ մեկտեղ հայտնվեց մեքենայական լեզուն, որի օգնությամբ ծրագրավորողը կարող էր հրամաններ սահմանել՝ գործելով հիշողության բջիջներով՝ ամբողջությամբ օգտագործելով մեքենայի հնարավորությունները։ Այնուամենայնիվ, համակարգիչների մեծամասնության օգտագործումը մեքենայական լեզվի մակարդակով դժվար է, հատկապես երբ խոսքը վերաբերում է մուտքագրման/ելքի: Ուստի մենք ստիպված եղանք հրաժարվել դրա օգտագործումից։

Օրինակ՝ անգործունյա սկավառակից տվյալների բլոկ կարդալու համար ծրագրավորողը կարող է օգտագործել 16 տարբեր հրամաններ, որոնցից յուրաքանչյուրի համար պահանջվում է 13 պարամետր, օրինակ՝ սկավառակի բլոկի համարը, ուղու հատվածի համարը և այլն: Երբ սկավառակը գործողությունն ավարտվում է, վերահսկիչը վերադարձնում է 23 արժեքներ, որոնք արտացոլում են վերլուծության կարիք ունեցող սխալների առկայությունը և տեսակները:

«Բառերը» մեքենայական լեզվով կոչվում են հրահանգներ,որոնցից յուրաքանչյուրը ներկայացնում է մեկ տարրական գործողություն կենտրոնական պրոցեսորի համար, ինչպիսին է, օրինակ, հիշողության բջիջից տեղեկատվություն կարդալը:

Յուրաքանչյուր պրոցեսորի մոդել ունի մեքենայի հրահանգների իր հավաքածուն, թեև դրանցից շատերը նույնն են: Եթե ​​պրոցեսոր A-ն լիովին հասկանում է պրոցեսոր B-ի լեզուն, ապա պրոցեսոր A-ն ասում են, որ համատեղելի է պրոցեսոր B-ի հետ: Պրոցեսոր B-ն անհամատեղելի է A պրոցեսորի հետ, եթե A-ն ունի հրահանգներ, որոնք չեն ճանաչվում պրոցեսորի կողմից:

60-ականների ընթացքում ծրագրային ապահովման մշակման պահանջները մեծացան, և ծրագրերը դարձան շատ մեծ: Մարդիկ սկսեցին հասկանալ, որ ծրագրային ապահովման ստեղծումը շատ ավելի բարդ խնդիր էր, քան նրանք պատկերացնում էին: Սա հանգեցրեց կառուցվածքային ծրագրավորման զարգացմանը: Կառուցվածքային ծրագրավորման զարգացմամբ հաջորդ առաջընթացը ընթացակարգերն ու գործառույթներն էին: Օրինակ, եթե կա առաջադրանք, որը կատարվում է մի քանի անգամ, ապա այն կարող է հայտարարվել որպես ֆունկցիա կամ պրոցեդուրա և պարզապես կանչվել ծրագրի կատարման ժամանակ։ Ծրագրի ընդհանուր կոդը այս դեպքում դառնում է ավելի փոքր: Ֆունկցիաները թույլ են տալիս ստեղծել մոդուլային ծրագրեր:

Հաջորդ առաջխաղացումը կառույցների օգտագործումն էր, որը հանգեցրեց դասերի: Կառուցվածքները տվյալների կոմպոզիտային տեսակներ են, որոնք կառուցված են այլ տեսակների օգտագործմամբ: Օրինակ՝ ժամանակի կառուցվածքը։ Այն ներառում է՝ ժամեր, րոպեներ, վայրկյաններ: Ծրագրավորողը կարող էր ստեղծել ժամանակային կառուցվածք և աշխատել դրա հետ որպես առանձին կառուցվածք։ Դասը կառույց է, որն ունի իր սեփական փոփոխականները և գործառույթները, որոնք աշխատում են այս փոփոխականների հետ: Սա շատ մեծ ձեռքբերում էր ծրագրավորման ոլորտում։ Այժմ ծրագրավորումը կարելի էր բաժանել դասերի և փորձարկել ոչ թե ամբողջ ծրագիրը, որը բաղկացած է 10000 տող կոդից, այլ ծրագիրը կարելի էր բաժանել 100 դասի և փորձարկել յուրաքանչյուր դաս։ Սա շատ ավելի հեշտացրեց ծրագրային արտադրանք գրելը:

Ասամբլեայի լեզու

Այն դեպքում, երբ անհրաժեշտ է ունենալ արդյունավետ ծրագիր, մեքենայական լեզուների փոխարեն օգտագործվում են մեքենա-կողմնորոշված ​​լեզուներ, որոնք մոտ են դրանց՝ assemblers: Մարդիկ օգտագործում են մնեմոնիկ հրամաններ մեքենայի հրամանների փոխարեն:

Բայց նույնիսկ assembler-ի հետ աշխատելը բավականին բարդ է և պահանջում է հատուկ ուսուցում:

Կառուցվածքային ծրագրավորումը ներառում է ճշգրիտ սահմանված վերահսկման կառուցվածքներ, ծրագրի բլոկներ, առանց անվերապահ թռիչքի (GOTO) հրահանգներ, ինքնուրույն ենթածրագրեր, ռեկուրսիայի և տեղական փոփոխականների աջակցություն:

Այս մոտեցման էությունը ծրագիրն իր բաղադրիչ տարրերի բաժանելու ունակությունն է:

Նաեւ ստեղծվել է ֆունկցիոնալ(կիրառական) լեզուներ (Օրինակ՝ Lisp - անգլերեն: ՑԱՆԿ Մշակում, 1958) և ինտելեկտուալ խաղլեզուներ (օրինակ՝ Prolog - անգլերեն) Ծրագրավորում LOGic-ում, 1972).

Չնայած կառուցվածքային ծրագրավորումը, երբ օգտագործվում է, տվել է ակնառու արդյունքներ, նույնիսկ այն ձախողվում է, երբ ծրագիրը հասնում է որոշակի երկարության: Ավելի բարդ (և ավելի երկար) ծրագիր գրելու համար անհրաժեշտ էր ծրագրավորման նոր մոտեցում։

OOP

Արդյունքում 1970-ականների վերջին և 1980-ականների սկզբին մշակվեցին օբյեկտի վրա հիմնված ծրագրավորման սկզբունքները։ OOP-ը համատեղում է կառուցվածքային ծրագրավորման լավագույն սկզբունքները հզոր նոր հասկացությունների հետ, որոնց հիմնականները կոչվում են encapsulation, polymorphism և inheritance:

Օբյեկտ-կողմնորոշված ​​լեզուների օրինակներն են՝ Object Pascal, C++, Java և այլն:

OOP-ը թույլ է տալիս օպտիմալ կերպով կազմակերպել ծրագրերը՝ խնդիրը բաժանելով դրա բաղադրիչ մասերի և աշխատելով յուրաքանչյուրի հետ առանձին: Օբյեկտ-կողմնորոշված ​​լեզվով ծրագիրը, որը լուծում է որոշակի խնդիր, ըստ էության նկարագրում է այս խնդրին առնչվող աշխարհի մի մասը:

Տարբեր լեզուներով ծրագիր գրելու օրինակ

Բարձր մակարդակի լեզու (Դելֆի)

X: = մեղք (y* Pi) + 1;

x86 հավաքող (համապրոցեսոր)

Fldpi fmul qword ptr [Y] fsin fld1 fadd p st (1), st (0) fstp qword ptr [X]

Մեքենայի կոդը (վեցանկյուն, յուրաքանչյուր հրաման սկսվում է նոր տողից)

D9 EB DC 0D D0 97 40 00 D9 FE D9 E8 DE C1 DD 1D 98 97 40 00

Մեքենայի կոդը (երկուական ներկայացում)

11011001 11101011 11011100 00001101 11010000 10010111 01000000 00000000 11011001 11111110 11011001 11101000 11011110 11000001 11011101 00011101 10011000 10010111 01000000 00000000

Հղումներ

Ծրագրավորման հիմնական լեզուներ (IDE համեմատություն պատմությունժամանակագրություն)
Օգտագործված զարգացման մեջ
Ակադեմիական
IEC 61131-3
Մյուսները
Էզոտերիկ
Տեսողական

Վիքիմեդիա հիմնադրամ. 2010 թ.

• Այ-այե
• Կաբանով, Նիկոլայ Ալեքսանդրովիչ

Տեսեք, թե ինչ է «Ծրագրավորման լեզուների պատմությունը» այլ բառարաններում.

Python ծրագրավորման լեզվի պատմություն- Python-ը մտահղացվել է 1980-ականներին, և դրա ստեղծումը սկսվել է 1989 թվականի դեկտեմբերին Գվիդո վան Ռոսումի կողմից՝ որպես Նիդեռլանդների մաթեմատիկայի և համակարգչային գիտության կենտրոնի մաս: Python լեզուն ստեղծվել է որպես ABC ծրագրավորման լեզվի ժառանգ, որը կարող է մշակել ... ... Վիքիպեդիա

Ծրագրավորման լեզուների ժամանակագրություն- Ծրագրավորման լեզուների ցուցակներ Ըստ կատեգորիայի Ժամանակագրական ծագումնաբանական ծրագրավորման լեզուների ժամանակագրությունը ծրագրավորման լեզուների ժամանակագրական կարգով կազմակերպված ցուցակ է: Բովանդակություն... Վիքիպեդիա

Ծրագրավորման լեզուների համեմատություն- Այս հոդվածը պետք է լինի Վիքիֆիկացված։ Խնդրում ենք ֆորմատավորել հոդվածի ձևաչափման կանոնների համաձայն։ Կոնվենցիաներ... Վիքիպեդիա

Ծրագրավորման լեզուների զարգացման համառոտ պատմություն- Համակարգչային տեխնոլոգիաների զարգացմանը զուգընթաց առաջացան ծրագրավորման տարբեր տեխնիկա: Յուրաքանչյուր փուլում ստեղծվել է նոր մոտեցում՝ օգնելու ծրագրավորողներին ծրագրերի աճող բարդության հարցում: Բովանդակություն 1 Զարգացման սկիզբ 2 Ասամբլեայի լեզու 3 Կառուցվածք ... Վիքիպեդիա

Տրամաբանության պատմություն- ուսումնասիրում է գիտության զարգացումը ճիշտ մտածողության (տրամաբանության) ձևերի և օրենքների մասին. Տրամաբանության առաջացումը՝ որպես եզրակացության սկզբունքների մշակված վերլուծություն, վերաբերում է բացառապես երեք տեղական քաղաքակրթություններին, մասնավորապես՝ Չինաստանին, Հնդկաստանին և Հին ... ... Վիքիպեդիային:

Linux-ի պատմություն- Այս հոդվածը կամ բաժինը վերանայման կարիք ունի: Խնդրում եմ բարելավել հոդվածը հոդվածներ գրելու կանոններին համապատասխան... Վիքիպեդիա

Ազատ ծրագրաշարի պատմություն- «Ազատ ծրագրակազմ» արտահայտությունը կամ Ազատ ծրագրակազմը վերաբերում է ազատական ​​լիցենզիաների ներքո բաշխված ապրանքներին, որոնք օգտվողին ավելի շատ տարբերակներ են տրամադրում, քան ավանդական ծրագրային ապահովման լիցենզիաները... ... Վիքիպեդիա

Շատ կարևոր է իմանալ ծրագրավորման լեզուների ընդհանուր պատմությունը և հայտնի և անհայտ լեզուների զարգացման պատմությունը: Այս հոդվածում դուք կծանոթանաք սրան, բայց նախ հիշենք «Ի՞նչ է ծրագրավորման լեզուն»։

Ծրագրավորման լեզուՆշումների և կանոնների համակարգ է, որը թույլ է տալիս գրել խնդիր լուծելու ծրագիր հաջորդական տեքստի տեսքով՝ մարդու համար հարմար ձևով:

50-ական թթ

20-րդ դարի հիսունական թվականներին, վակուումային խողովակային համակարգիչների գալուստով, սկսվեց ծրագրավորման լեզուների արագ զարգացումը: Ծրագրավորումը սկսվել է ուղղակիորեն մեքենայական հրահանգների տեսքով (ինչպես ասում են ծրագրավորողները) ծրագրեր գրելով։ Համակարգիչները, որոնք այն ժամանակ զգալիորեն ավելի թանկ արժեին, քան ցանկացած ծրագրի մշակումը, պահանջում էին բարձր արդյունավետ կոդ։

Կոդավորումն ավելի դյուրին դարձնելու համար մշակվել է մեքենայական ուղղվածություն, ինչը հնարավորություն է տվել սիմվոլիկ ձևով գրել մեքենայի հրահանգները։ Ասամբլեայի լեզուն կախված էր որոշակի համակարգչի հրահանգավորման համակարգից: Այն բավական հարմար էր փոքր առաջադրանքների ծրագրավորման համար, որոնք պահանջում էին կատարման առավելագույն արագություն:

Այնուամենայնիվ, մեծ նախագծերը դժվար էր զարգացնել Ասամբլեայի լեզվով: Հիմնական խնդիրն այն էր, որ ժողովում գրված ծրագիրը կապված էր որոշակի համակարգչի ճարտարապետության հետ և չէր կարող փոխանցվել այլ մեքենաների: Երբ համակարգիչը բարելավվեց, Ասամբլեայի բոլոր ծրագրերը պետք է նորից վերաշարադրվեին:

Համակարգիչների գալուստով գրեթե անմիջապես ստեղծվեցին բարձր մակարդակի լեզուներ, այսինքն. լեզուներ, որոնք կախված չեն կոնկրետ ճարտարապետությունից: Ծրագիրը բարձր մակարդակի լեզվով գործարկելու համար այն նախ պետք է թարգմանվի մեքենայի հրամանների լեզվով: Նման թարգմանություն կատարող հատուկ ծրագիրը կոչվում է թարգմանիչ կամ կոմպիլյատոր։

Այնուհետև թարգմանված ծրագիրը գործարկվում է անմիջապես համակարգչի կողմից: Կա նաև ծրագիրը միջանկյալ լեզվով թարգմանելու հնարավորություն, որը կախված չէ կոնկրետ համակարգչի ճարտարապետությունից, բայց, այնուամենայնիվ, հնարավորինս մոտ է մեքենայի հրամանի լեզվին:

Այնուհետև միջանկյալ լեզվի ծրագիրն իրականացվում է հատուկ ծրագրի միջոցով, որը կոչվում է թարգմանիչ: Հնարավոր է նաև կոմպիլյացիա, երբ կատարվող ծրագրի հատվածը միջանկյալ լեզվից թարգմանվում է մեքենայական հրամանների լեզվի անմիջապես կատարումից առաջ։

50-ականների կեսերին Ջոն Բաքուսի ղեկավարությամբ IBM-ի համար մշակվել է բարձր մակարդակի ալգորիթմական ծրագրավորման FORTRAN լեզուն։ Չնայած այն հանգամանքին, որ արդեն կային զարգացումներ այն լեզուներում, որոնք թվաբանական արտահայտությունները վերածում էին մեքենայական կոդի, դարձավ FORTRAN լեզվի ստեղծումը (FORmula TRANslator), որն ապահովում էր պայմանական հայտարարությունների և մուտքային/ելքային օպերատորների միջոցով հաշվարկման ալգորիթմ գրելու հնարավորություն։ բարձր մակարդակի ծրագրավորման լեզուների դարաշրջանի մեկնարկային կետը։

Որպես FORTRAN լեզվի այլընտրանք, որն ի սկզբանե ուղղված էր IBM-ի ճարտարապետությանը, ALGOL-ը (ԱԼԳՈՐիթմիկ լեզու) մշակվեց 50-ականների վերջին Պիտեր Նաուրի ղեկավարությամբ: Այս լեզվի մշակողների կողմից հետապնդվող հիմնական նպատակը համակարգչային համակարգի կոնկրետ ճարտարապետությունից անկախանալն էր։

Բացի այդ, ALGOL լեզվի ստեղծողները ձգտել են մշակել լեզու, որը հարմար է ալգորիթմները նկարագրելու և մաթեմատիկայում ընդունվածին մոտ նշագրման համակարգ օգտագործելու համար: FORTRAN-ը և ALGOL-ը առաջին լեզուներն էին, որոնք կենտրոնացած էին հաշվողական ծրագրավորման վրա:

60-ական թթ

60-ականների վերջին Նայարդի և Դալի ղեկավարությամբ մշակվեց Simula-67 լեզուն՝ օգտագործելով օգտագործողի կողմից սահմանված տվյալների տեսակների հայեցակարգը։ Փաստորեն, դա առաջին լեզուն է, որն օգտագործում է դասեր հասկացությունը:

70-ական թթ

70-ականների կեսերին Վիրտն առաջարկեց Պասկալ լեզուն, որն անմիջապես լայն կիրառություն գտավ։ Միևնույն ժամանակ, ԱՄՆ պաշտպանության նախարարության նախաձեռնությամբ, աշխատանք սկսվեց բարձր մակարդակի լեզվի ստեղծման վրա, որը կոչվում է Ada՝ ի պատիվ ծրագրավորող և լորդ Բայրոնի դուստր Ադա Լավլեյսի:

Լեզվի ստեղծումը սկսվեց պահանջների սահմանմամբ և բնութագրերի մշակմամբ: Նախագծի վրա աշխատել են չորս անկախ խմբեր, բայց նրանք բոլորն էլ որպես հիմք օգտագործել են Պասկալը։ 1980-ականների սկզբին ստեղծվեց Ադա լեզվի առաջին արդյունաբերական կոմպիլյատորը։

Գ զարգացում

Համընդհանուր ծրագրավորման լեզուն մշակվել է 70-ականների կեսերին Դենիս Ռիչիի և Քեն Թոմփսոնի կողմից։ Լեզուն դարձավ հայտնի համակարգերի ծրագրավորման լեզու և ժամանակին օգտագործվում էր UNIX օպերացիոն համակարգի միջուկը գրելու համար:

C լեզվի ստանդարտը մշակվել է ANSI աշխատանքային խմբի կողմից 1982 թ. C լեզվի միջազգային ստանդարտը ընդունվել է 1990 թվականին։ C լեզուն հիմք հանդիսացավ ծրագրավորման լեզուների և Java-ի զարգացման համար:

C լեզուն հնարավորություն տվեց իրականում ազատվել Assembler-ից օպերացիոն համակարգեր ստեղծելիս։ Օրինակ, Unix օպերացիոն համակարգի գրեթե ամբողջ տեքստը գրված է C-ով և, հետևաբար, կախված չէ որոշակի համակարգչից:

C-ի հիմնական առավելությունը նրա պարզությունն է և կեղծ գիտական ​​լուծումների բացակայությունը։ Պարամետրերը ֆունկցիային փոխանցելու մեխանիզմը (միայն ըստ արժեքի) նկարագրված է պարզ և հստակ: C ծրագիր ստեղծող ծրագրավորողը միշտ հստակ հասկանում է, թե ինչպես է այս ծրագիրը գործարկվելու:

C լեզվի ցուցիչի, ստատիկ և ավտոմատ (կույտ) փոփոխականների հայեցակարգը առավել սերտորեն արտացոլում է ցանկացած ժամանակակից համակարգչի կառուցվածքը, հետևաբար C ծրագրերը արդյունավետ և հարմար են վրիպազերծման համար:

Ներկայումս ծրագրերի ճնշող մեծամասնությունը գրված է C և C++ լեզուներով: Ցանկացած օպերացիոն համակարգի ինտերֆեյսը (այսպես կոչված API - Application Program Interface), այսինքն. Համակարգային զանգերի մի շարք, որոնք նախատեսված են հավելվածների մշակողների համար, սովորաբար գործառույթների մի շարք են C լեզվով:

Ալգորիթմական լեզուների հետ զուգահեռ զարգացել են նաև բիզնես տեղեկատվության մշակման համար նախատեսված լեզուները, ինչպես նաև արհեստական ​​բանականության լեզուները։ Առաջինը ներառում է COBOL (Common Business Oriented Language) լեզուն, իսկ երկրորդը ներառում է LISP (LISt Processing) և Prolog լեզուները:

LISP լեզուն, որը մշակվել է 60-ականներին Ջ. Մաքքարթիի ղեկավարությամբ, առաջին ֆունկցիոնալ ցուցակների մշակման լեզուն էր, որը լայն կիրառություն գտավ խաղերի տեսության մեջ։

90-ական թթ

90-ականներին ինտերնետի տարածման հետ մեկտեղ ընդլայնվեցին բաշխված տվյալների մշակման հնարավորությունները, ինչը ազդեց նաև ծրագրավորման լեզուների զարգացման վրա։ Հայտնվել են սերվերային հավելվածներ ստեղծելու վրա կենտրոնացած լեզուներ, ինչպիսիք են Perl-ը, Փաստաթղթերի նկարագրության լեզուներ և XML:

Ավանդական ծրագրավորման լեզուները՝ C++ և Pascal-ը նույնպես փոփոխության ենթարկվեցին. ծրագրավորման լեզուն սկսեց նշանակել ոչ միայն բուն լեզվի ֆունկցիոնալությունը, այլև ծրագրավորման միջավայրի կողմից տրամադրված դասի գրադարանները:

Շեշտը տեղափոխվեց հենց ծրագրավորման լեզուների ճշգրտումից դեպի բաշխված հավելվածների փոխազդեցության մեխանիզմների ստանդարտացում: Հայտնվել են նոր տեխնոլոգիաներ՝ COM և CORBA, որոնք հստակեցնում են բաշխված օբյեկտների փոխազդեցությունը։

Ծրագրավորման լեզուների կիրառման ոլորտները

Ներկայումս ծրագրավորման լեզուներն օգտագործվում են մարդկային գործունեության մի շարք ոլորտներում, ինչպիսիք են.

• գիտական ​​հաշվարկ (լեզուներ C++, FORTRAN, Java);
• համակարգի ծրագրավորում (լեզուներ C++, Java);
• տեղեկատվության մշակում (լեզուներ C++, COBOL, Java);
• արհեստական ​​ինտելեկտ (LISP, Prolog);
• հրատարակչական գործունեություն (Postscript, TeX);
• տեղեկատվության հեռավոր մշակում (Perl, PHP, Java, C++);
• փաստաթղթերի նկարագրություն (HTML, XML):

Ելնելով ծրագրավորման լեզուների պատմության վրա, կարող ենք ասել, որ ժամանակի ընթացքում որոշ լեզուներ զարգացել են, ձեռք են բերել նոր առանձնահատկություններ և մնացել են պահանջված, իսկ մյուսները կորցրել են իրենց արդիականությունը և այսօր, լավագույն դեպքում, զուտ տեսական հետաքրքրություն են ներկայացնում:

 

Կարող է օգտակար լինել կարդալ.

• Ձայնի ձայնագրում ծրագրերի և առցանց ծառայությունների միջոցով;
• Միավորել PDF ֆայլերը առցանց;
• Բջջային հեռախոս լսելու ծրագիր;
• Թղթապանակում ֆայլերի ճիշտ ընտրություն;
• Ինչպես անցնել անսահմանափակ սակագնի;
• Լսեք բջջային հեռախոս անվճար;
• G-Shock Bluetooth գործառույթով - միացեք ձեր հեռախոսին G-Shock ժամացույցը Bluetooth-ով;
• Ամերիկյան IROBOT կամ չինական LILIN. ո՞ր ռոբոտ փոշեկուլն է ավելի լավը:;