ասք Մոդուլյար համակարգերի գաղտնիքների մասին

«Մոդուլային համակարգերի գաղտնիքները» հոդվածի հեղինակն է Սերգեյ Գուբանովը։

«Մոդուլ» եւ «մոդուլյար լեզու» թերմերի բացատրությունների զանազանությունը ծնում է ավներջ վեճեր։ Ինչեր ասես, որ մոդուլ չեն անվանել, ինչ լեզու ասես, որ մոդուլյար չեն համարել։ Ոմանք մոդուլ անվանում են կլասսները, ոմանք ել համեմատում են մոդուլները օբյեկտների հետ։ Առհասարակ այնպիսի տպավորություն է ստեղծվում, որ այժմ մոդուլյար եւ կոմպոնենտային լինելը նորաձեւ ոճ է։ Տարբերակների զանազանության պատճառը բացատրությունների ձեւի մեջ է՝ ներքին ձեւի։ Ներքին է այն իմաստով, որ սահմանումը տրվում է որոշ ներքին հատկությունների հիման վրա (մոդուլը պարունակում է տվյալներ, կոդ, տիպեր, ապահովում է ինկապսուլյացիան, ունի ինտերֆեյս, եւ այլն)։ Մոդուլների ներքին էական հատկությունները առանձնացնելու բազմաթիվ եղանակներ կան, իսկ դա նշանակում է, որ գոյություն ունեն նաեւ մոդուլների սահմանման բազմաթիվ եղանակներ։ Ապագայում ներքին հատկությունների քանակը գուցե եւ ավելանա, հայտնվեն սահմանումների նոր ձեւեր․ այսինքն՝ վիճելու առիթ ավելի շատ կլինի ու դա կտանի փակուղու։ Ելքը ներքին սահմանման փոխարինումն է արտաքինով։

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

Ստորեւ բացահայտենք մոդուլյար համակարգերի իմաստը:

Մոդուլյար ծրագրավորման համակարգերը եկել են միաձույլ ծրագրերը փոխարինելու համար։ Մոդուլյար համակարգեր կիրառելու իմաստը (ի տարբերություն միակուռ ծրագրերի) դինամիկ ընդարձակվելու ունակությունն է։ Մոդուլյար համակարգը կարելի է դինամիկ ընդլայնել մի քանի ձեւով։ Օրինակ՝ դրա մեջ նոր մոդուլներ ավելացնելով կամ փոխարինելով դրա միջի հին մոդուլները նորերով , որոնք ունեն ավելի լայն հնարավորություններ կամ որեւէ այլ լավացումներ։ Ընդարձակվող մոդուլյար համակարգը երբեք ավարտված չէ, այն զարգացում է ապրում։ Որոշ մոդուլներ փոխարինվում են, որոշները դինամիկ ավելացվում։ Այսպիսի համակարգի կյանքը կարող է լինել ավելի երկար, քան նրա միջի կոմպոնենտների կյանքը (տես․ մարդը եւ բջիջները, թարգմանչի նկատողություն)։ Համակարգի օգտագործողը ինքն է որոշում ինչպես այն ընդարձակել։ Կատարյալ դեպքում գոյություն ունի համակարգի կոմպոնենտների շուկա, որտեղ տարբեր արտադրողներ առաջարկում են մոդուլների իրենց իրագործումները, որոնք եւ ձեռք է բերում համակարգի օգտագործողը։ Կոմպոնենտների շուկայի բացակայությունը կարող է խոչընդոտել միաձույլ համակարգերից մոդուլյար համակարգեր անցնելուն։ Սակայն, պահանջարկը ծնում է առաջարկ։

Դիտարկենք մոդուլյար, դինամիկ ընդլայնվող համակարգի կառուցվածքը։ Մոդուլների միջեւ փոխազդեցությունը իրագործվում է մոդուլի՝ այլ մոդուլներ ներմուծելու (import) ունակության շնորհիվ։ Այսպիսով՝ ներմուծող մոդուլը հանդիսանում է ներմուծվող մոդուլների կլիենտ։ Մոդուլների ներմուծման գրաֆը միշտ ացիկլիկ է։ Գրաֆի ացիկլիկ լինելը կապված է այն հանգամանքի հետ, որ մոդուլները հանդիսանում են բեռնման, կատարման եւ բեռնաթափման միավորներ, իսկ ցիկլիկ կախվածության դեպքում բեռնման եւ կատարման միավոր կլիներ ամբողջ ցիկլը․ այսինքն՝ այն ամբողջությամբ կլիներ մոդուլ (համակարգի կոմպոնենտ)։ Մոդուլյար համակարգը ենթադրում է կատարման միջավայր, որի հիմնական խնդիրներից է մոդուլների դինամիկ բեռնումը, ուշ կապը (late linking), կատարումը եւ բեռնաթափումը։ Այլ խնդիրը ամբողջականության կոնտրոլն է․ տիպերի դինամիկ բերումը, զանգվածների (array) ինդեքսների դինամիկ ստուգումը եւ այլն։ Դինամիկ բեռնաթափման հնարավորությունը անհրաժեշտ է հին մոդուլները նորերով փոխարինելու համար։ Ի դեպ մոդուլը չի կարելի բեռնաթափել մինչեւ բեռնաթափված չեն բոլոր նրա կլիենտները։ Դա ակներեւ է թվում, սակայն այդ մասին հաճախ մոռանում են։ Մոդուլների բեռնումը եւ բեռնաթափումը կարելի է համեմատել աղյուսներից աշտարակ հավաքելու հետ․ աշտարակը կարելի է քանդել միմիայն վերեւից, այլ դեպքում այն կփլվի։ Ակներեւ է նաեւ այն, որ մոդուլը կարելի է բեռնաթափել միմիայն հստակ (explicit) հրամանով, այլ ոչ թե ավտոմատ կերպ (օրինակ՝հիմնվելով կլիենտների բացակայության փաստի վրա․ այժմ կլիենտներ չկան, իսկ որոշ ժամանակ անց կլինեն, եւ մոդուլի վիճակը պիտի պահպանվի)։ Նոր մոդուլի ավելացումը կամ հին մոդուլի փոփոխությունը չպետք է բերի ամբողջական համակարգը ավիրելուն։ Քանի որ մոդուլները կարող են մատակարարվել տարբեր արտադրողների կողմից, ապա կատարման միջավայրը պիտի ստուգի մոդուլների համատեղելիությունը եւ խոչընդոտի անհամատեղելի մոդուլների բեռնմանը։ Համատեղելիությունը ստուգվում է մոդուլի ինտերֆեյսի անալիզի միջոցով։ Մոդուլը պարունակում է իր մեջ զանազան ծրագրային էություններ` կոնստանտներ, տիպեր, փոփոխականներ, ֆունկցիաներ։ Մոդուլի որոշ էություններ հասանելի են դառնում կլիենտների համար, այսինքն` արտահանվում են (export), իսկ մնացածները թաքցվում, այլ խոսքերով՝ ինկապսուլյացիա անում։ Ի դեպ այդպիսի ինկապսուլյացիայի ձեւը ամենահզորն է, քանի որ այն խախտելու միակ միջոցը մոդուլի բինար կոդի հետազոտությունը եւ դրա ոչ անվտանգ փոփոխությունն է։ Մոդուլի արտահանվող էությունների ամբողջությունը սահմանում է մոդուլի ինտերֆեյսը։ Դրա միջոցով էլ իրականացվում է կլիենտների հետ փոխազդեցությունը։ Եթե երկու մոդուլ (նույնիսկ տարբեր արտադրողների մոդուլներ) ունեն նույն ինտերֆեյսը, ապա դրանք երկուստեք փոխարինելի են։ Եթե երկու մոդուլներից մեկը ունի առաջինի համեմատ ընդլայնված ինտերֆեյս (այսինքն՝ նրա ինտերֆեյսը ճշգրիտ կրկնում է առաջին մոդուլի ինտերֆեյսը եւ դրան գումարած արտահանում է հավելյալ էություններ), ապա երկրորդ մոդուլը փոխադարձորեն փոխարինելի է առաջինի հետ։

Ինչպե՞ս է կատարման միջավայրը որոշում մոդուլների համատեղելի լինելը։ Ամենապարզ ձեւն է՝ դրոշմել ամեն մոդուլը իր տարբերակի համարով (լինի դա հստակ նշված տարբերակ, թե վերջին կոմպիլյացիայի ժամանակը)։ Հին մոդուլյար համակարգերը օգտագործում էին ժամանակային նշումների մեխանիզմը (timestamps)։ Բայց տարբերակի հստակ (explicit) նշելը գերադասելի է, որովհետեւ ավելի ուշ timestamp-ը հայտնում է միայն այն, որ տվյալ մոդուլը ավելի ուշ է հավաքվել (compiled), բայց չի ակնարկում որ մոդուլի ինտերֆեյսը լուրջ փոփոխությունների է ենթարկվել։ Սակայն մոդուլը որոշակի համարով դրոշմելու լուծումը նույնպես թերի է։ Ենթադրենք, նոր մոդուլը հնից տարբերվում է միայն նրանով, որ նրա մեջ փոխված է ինտերֆեյսի բավականին փոքր մասը։ Օրինակ՝ փոխվել է մի արտահանվող կոնստանտի արժեքը, իսկ մնացած ամենը մնացել է անփոփոխ։ Ապա այդ մոդուլը պետք է դրոշմվի որպես նոր տարբերակ։ Սակայն գոյություն ունեն այնպիսի կլիենտ մոդուլներ, որոնք օգտագործում են միայն ինտերֆեյսի անփոփոխ մնացած մասը։ Նոր դրոշմի պատճառով այդ մոդուլի բոլոր կլիենտ մոդուլները կճանաչվեն անվավեր, այսինքն՝ կատարման միջավայրը կհրաժարվի բեռնել (աշխատեցնել) դրանք փոփոխված մոդուլի հետ համատեղ։ Մոդուլների համատեղելիության ստուգման մեխանիզմը երբեմն անհիմն անգութ է, եւ կատարման միջավայրը կարող է անվավեր համարել բազմաթիվ մոդուլներ։ Բարեբախտաբար, գոյություն ունեն մոդուլների համատեղելիությունը հաստատելու այլ, ավելի գրագետ ձեւեր։ Հավաստիանալու գաղտնիքը նրանում է, որ մոդուլի յուրաքանչյուր արտահանվող (exported) էությանը (յուրաքանչյուր կոնստանտի, փոփոխականի, տիպի, ֆունկցիաի) կցվում է ուրույն նշան, մատնահետք (fingerprint), ավելի պարզ՝ checksum, որը հաշվարկված է այդ էության որոշակի կառուցվածքային ինվարիանտ հատկությունները ի նկատի ունենալով։ Այսպիսի «մանտնահետք» դրոշմեր ստանալը հեշտ խնդիր չէ, առավել եւս ընդարձակվող համակարգերի դեպքում։ Ավելի քան տաս տարի առաջ ETH-ում մատնահետք դրոշմեր հաշվելու թեմայով դոկտորական թեզ է պաշտպանվել (Regis Crelier «Separate Compilation and Module Extension», գիտական ղեկավարներն էին Նիկլաուս Վիրտն (Wirth) ու Հանսպետեր Մոսենբոքը (Mossenbock), Oberon-2 լեզվի համահեղինակները)։ Կատարման միջավայրում մոդուլների համատեղելիության կոնտրոլի բացակայությունը կարող է բերել անկանխատեսելի հետեւանքների։ Այսպես, օրինակ, MS Windows համակարգի կատարման միջավայրը (ըստ էության պարզապես բեռնիչը), որի մեջ dll ֆայլերը հանդիսանում են մոդուլներ, չի ստուգում այդ մոդուլների համատեղելիությունը։ Որպես հետեւանք գոյություն ունի տխրահռչակ dll hell հասկացությունը։

Մոդուլյար համակարգեր ստեղծելը սկզբունքայնորեն հնարավոր է ցանկացած ծրագրավորման լեզվի օգնությամբ։ Օրինակ՝ win32 dll մոդուլյար համակարգը կարող է իրագործվել զանազան լեզուներով։ Սակայն դժվար թե լինի գոնե մեկ լեզու, որը այդ իսկ նպատակին հարմարեցված է նախագծման պահին։ Համեմատենք մեկ dll մոդուլի ստեղծման թեթեւությունը (որը որպես կանոն շատ հեշտ է, քանի որ բոլոր հոգսերը տանում է նախագծման միջավայրը) մի քանի, կամ տասնյակ/հարյուրավոր դինամիկ բեռնվող եւ բեռնաթափվող dll մոդուլներ պարունակող համակարգի ստեղծման բարդության հետ։ LoadLibrary եւ GetProcAddress կանչերի վիթխարի քանակը հարմարավետ չես անվանի եւ դրանք կիրառող տեքնոլոգիան, կամ լեզուն, ոչ մի կերպ չես անվանի մոդուլյար համակարգեր ստեղծելու համար հարմարեցված լեզու։ Ընդ որում ստատիկ կապումը (static linking) ելք համարել չի լինի, որովհետեւ բեռնաթափել եւ փոխարինել ստատիկ կապված մոդուլը անհնար է։ Ինչպես ասված էր, բնական է մոդուլյար ծրագրավորման լեզուները սահմանել որպես մոդուլյար համակարգեր ստեղծելու համար հարմարավետ, հատուկ նախագծված, նախատեսված լեզուներ, դա է իրենց իմաստը։ Բայց ինչպես մենք քիչ առաջ համոզվեցինք, մոդուլյար համակարգերը, առհասարակ, կարելի է կերտել նաեւ այդ համար հատուկ չնախատեսված լեզուների օգնությամբ։ Հարցը միմիայն աշխատանքի ծախսն է։ Կարող է պարադոքսալ թվալ, բայց լինում է եւ հակառակը․ կան ծրագրավորման լեզուներ, որոնք, կարծես, հարմարավետ են ոչ միայն միաձույլ, այլ նաեւ մոդուլյար համակարգեր ստեղծելու համար։ Ես ի նկատի ունեմ Delphi-ն։ Թվում է, որ այնպիսի սինտակտիկ միավորները, ինչպիսին են՝ unit, interface, implementation, uses, մոդուլյար համակարգեր ստեղծելու համար շատ օգտակար են․ մոդուլներ կհանդիսանային յունիթները, ավելի ճիշտ դրանց կոմպիլյացիայի արդյունքը՝ dcu ֆայլերը (delphi compiled unit)։ Բայց, ցավոք, dcu ֆայլերը մոդուլներ չեն, դրանք «կիսաֆաբրիկատներ» են։ Չնայած նրան, որ մոդուլների բոլոր արտաքին սինտակտիկ հատկանիշները առկա են, նրանց անհնար է մոդուլյար համարել․ ներկա ժամանակ աշխարհում գոյություն չունի մոդուլյար համակարգ, որի ստեղծման համար այն հատուկ հարմարեցվի։ Տեսականորեն, եթե երբեւէ ստեղծվի հատուկ կատարման միջավայր, որն ունակ կլինի դինամիկ բեռնել եւ բեռնաթափել dcu ֆայլերը, ապա այնժամ հնարավոր կլինի Delphi-ն անվանել մոդուլյար, այսինքն՝ հատուկ հարմարեցված մոդուլյար ծրագրավորման համար։ Այս տրամաբանությունը կարող է թվալ անսպասելի, բայց այն հետեւում է այս գրառման սկզբում սահմանված մոդուլյար համակարգերի իմաստից։ Մոդուլյարության հատուկ սինտակտիկ հատկանիշները անշուշտ անհրաժեշտ են, սակայն դրանք բավական չեն, այսինքն ոչ մի պարադոքս իրականում չի դիտվում։

Չնայած նրան, որ լեզվի միջի հատուկ շարահյուսական (սինտակտիկ) հատկանիշները բավական չեն լեզուն մոդուլյար անվանելու համար, դրանք միեւնույն է անհրաժեշտ են։ Անհրաժեշտ են նրա համար, որ լեզուն հարմարեցված լինի մոդուլյար համակարգեր գրելու համար։ Մոդուլյար ծրագրավորման լեզվի շարահյուսության մեջ պիտի արտահայտված լինեն ամենաքիչը երեք հասկացություն՝ ինքը մոդուլը, մոդուլների ներմուծմանվ(import) միջոցները եւ ծրագրային էությունների արտահանման (export) միջոցները։ Մոդուլյար համակարգի ամբողջականության վերահսկումը հնարավորինս վաղ իրականացնելու համար անհրաժեշտ է անջատ (separate), այլ ոչ թե անկախ (independent) կոմպիլյացիա։ Ակնհայտ է, որ մոդուլը պիտի լինի կոմպիլյացիայի միավոր։ Այլ դեպքում ինչու՞մ է կայանում հարմարավետությունը։ Մոդուլի ներքին էությունները իրար ամուր կապված են։ Եթե կոմպիլիացիայի միավոր լինի մոդուլից փոքր մեծություն, ապա անջատ կոմպիլիացիան հաշվի առնելով՝ անհրաժեշտ կլինի հնարել որոշակի թաքցրած ինտերֆեյսներ այդ էությունների փոխազդեցությունների համար։ Ակներեւ է, որ դա ավելորդ բարդացում է, գուցե նույնիսկ՝ անվտանգության ճեղք (vulnerability), եւ դրա օգուտը պարզ չէ։

Ընդհանուր առմամբ, մոդուլյար համակարգերի ծրագրավորումը չի պահանջում օբյեկտային կողմնորոշված ծրագրավորման (ՕԿԾ) մոտեցում, իրավացի է եւ հակառակը։ Սակայն, այդ երկու մոտեցումների համաժամյա կիրառությունը բերել է նոր ծրագրավորման պարադիգմայի ստեղծմանը։ Բանն այն է, որ ՕԿԾ-ն, իր ամենատարածված բացատրությամբ, հիմնված է ժառանգողականության (inheritance) հասկացության վրա։ ՕԿԾ-ն եւ մոդուլարությունը միատեղ կիրառելու ընթացքում ծնվում է միջմոդուլյար ժառանգողականությունը, սակայն այն հանդիսանում է տարբեր արտադրողների մոդուլների փոխարինելիության խոչընդոտ։ Եթե տիպի մասը սահմանված է մեկ մոդուլի մեջ, իսկ մյուս մասը՝ այլ, ապա հիմնական տիպի նկարագրությունը պարունակող մոդուլը այլ արտադրողից նույնանման մոդուլով փոխարինելը բավականին մեծ խնդիր է․ իրականացման հնարավոր մանր տարբերությունների պատճառով։ 1995 թվին, պրոֆեսոր Կլեմենս Շիպերսկին (Clemens Szyperski) ֆորմալիզացրել է Կոմպոնենտային Կողմնորոշված Ծրագրավորման (ԿԿԾ) հիմունքները սահմանափակելով եւ ՕԿԾ-ն եւ մոդուլյար մոտեցումը դրանց չհակասող համատեղ գոյության համար («Component-Oriented Programming A Refined Variation on Object-Oriented Programming», The Oberon Tribune, Vol 1, No 2, December 1995)։ ԿԿԾ-ի իմաստը ընդարձակելի համակարգերի կառուցումն է՝ մոդուլների եւ ՕԿԾ-ի օգնությամբ։ Այսպիսով, ԿԿԾ-ն, Շիպերսկու կարծիքով, գտնվում է «<ՕԿԾ-ից դուրս» (Beyond Object Oriented Programming - թարգմանչի նկատողություն) (այսպես է կոչվում նրա արդեն երկու անգամ հրատարակված բեսթսելերը)։ ԿԿԾ-ի հիմքը հանդիսանում են․ պոլիմորֆիզմը, ուշ կապումը (late linking), իսկական ինկապսուլյացիան, կատարման միջավայրի կողմից իրականացվող անվտանգութան ամբողջական վերահսկումը։ Կատարման միջավայրը նաեւ պարտավոր է աղբ հավաքել։ Աղբ հավաքելը շքեղություն չէ բնավ, այլ անհրաժեշտություն․ այն կոմպոնենտային համակարգի ամբողջականության երաշխիքներից մեկն է (հիշենք, որ համակարգի կոմպոնենտները՝ մոդուլները, ստեղծվում են, առհասարակ, տարբեր արտադրողների կողմից)։ Այժմ, ուշադրություն դարձրեք այն հանգամանքին, որ «ժառանգողականության» հասկացությունը (այսինքն տիպի ընդլայնումը), որը այնքան տարածված է ժամանակակից ՕԿԾ լեզուներում, առհասարակ չի ընդգրկված ԿԿԾ-ի հիմքերի մեջ։ Դրա բացատրությունը տրիվիալ է։ Եթե տիպերի ընդլայնումը կիրառվում է մոդուլների մեջ, ապա դա սովորական ՕԿԾ է՝ այնտեղ ուրույն կանոններ են։ Իսկ եթե օգտագործվում է տիպերի միջմոդուլյար ընդլայնումը, ապա այն մոդուլները, որոնց միջեւ տիպերը կապված են ժառանգողականողականության հարաբերություններով, կապված են լինում ավելի պինդ, ավելի կարծր կերպ։ Բարդ է փոխարինել բազային տիպ պարունակող մոդուլը այլ արտադրողի մոդուլով, առանց անվավեր անելու կլիենտ մոդուլները, որտեղ այդ տիպը ընդլայնված է։ ԿԿԾ-ն խորհուրդ է տալիս կիրառել միջմոդուլյար ժառանգողականություն միմիայն աբստրակտ տիպերից՝ դա նպատակահարմար փոխզիջում է ՕԿԾ-ի եւ մոդուլյար համակարգերի միջեւ։ Սակայն ծրագրավորողը, իհարկե, իրավացի է ինքը որոշել, արդյո՞ք արժե կոնկրետ համակարգում օգտագործել տիպերի միջմոդուլյար ժառանգողականությունը առանց սահմանափակումների (դրանով իսկ կարծր կապելով մոդուլները իրար), թե այնուամենայնիվ, նախընտրել փոխարինելի, ընդարձակվող մոդուլներ՝ տարբեր արտադրողներից։ ԿԿԾ-ի սահմաններում, «կոմպոնենտ» բառը դառնում է թերմ։ Կոմպոնենտային համակարգը դա մոդուլյար համակարգի այն մասնավոր դեպքն է, որի մեջ կիրառվում է ՕԿԾ։ Քանի որ այժմ ՕԿԾ-ն օգտագործվում է ամենուր, ապա «մոդուլյար համակարգ» կամ «կոմպոնենտային համակարգ» հասկացությունների տարբերությունը գրեթե բացակայում է։ Մյուս կողմից, կոմպոնենտ բառը այժմ չափազանց ծանրաբեռնված է տարբեր իմաստներով, այդ իսկ պատճառով կարելի է գտնել կոմպոնենտոների այլ բացատրություններ։ Քանի որ այժմ դա «նորաձեւ» է, յուրաքանչյուրը այն բացատրում է իր ձեւով։ Օրինակ՝ Delphi-ում կան ուրույն, այսպես կոչված, «կոմպոնենտներ», որոնք բնավ ոչ մի առնչություն չունեն մոդուլյար համակարգերի հետ։ Այս գրառումը ավարտելով դիտարկենք ինչպիսի կոմպոնենտային համակարգեր կան այսօր։ Microsoft ընկերությունը իրականացրել է կոմպոնենտ համակարգի իր մտապատկերը՝ .Net պլատֆորման եւ այդ պլատֆորմայի համար կանոնիկ՝ C# ծրագրավորման լեզուն։ Անկեղծ ասած, .Net համակարգը առհասարակ չի հանդիսանում դինամիկ ընլայնվող մոդուլյար համակարգ, քանի որ նրա մեջ պարզապես բացակայում է մոդուլներ բեռնաթափելու հնարավորությունը։ .Net համակարգերը ավելի շատ նման են մոնոտոն աճող միաձույլ ծրագրերի, մասնակի, հաջորդաբար կոմպիլյացիայով ու բեռնմամբ ըստ անհրաժեշտության։ Իրականում, այս ամենը ավելի բարդ է, որովհետեւ .Net-ում տարբերություն կա կոմպիլիացիայի միավորի (dll կամ exe մոդուլ) եւ բեռնման միավորի միջեւ (assembly)։ Assembly-ն մի քանի մոդուլի տրամաբանական միացումն է մեկ ենթահամակարգում։ Assembly-ների, dll-ների եւ exe մոդուլների մեջ չխառնվելու և առանց ընդհանրությունը կորցնելու պարզության համար ենթադրենք, որ assembly-ն բաղկացած է մեկ մոդուլից, եւ դրանց մեջ ոչ մի տարբերություն չկա։ Մեկ assembly-ի մեջ մի քանի մոդուլի դեպքը սկզբունքորեն ոչ մի բան չի փոխում (բացի բարդացում ավելացնելուց), այդ պատճառով կխոսենք միայն մոդուլների մասին։ Այսպիսով՝ .Net կատարման միջավայրը մոդուլների համատեղելիության վերահսկման համար չի օգտվում վերը նշված մատնահետքերի (fingerprint) մեխանիզմով։ Դրա փոխարեն կիրառվում է մոդուլի տարբերակի համարը հստակ նշելու տեխնիկան։ Դա, իհարկե, ավելի լավ է, քան ոչինչը (ինչպես win32 dll դեպքում), բայց ստեղծում է իր խնդիրները։ Օրինակ՝ եթե .Net մոդուլը արտահանում է կոնստանտ, որը, միգուցե, ոչ ոք չի օգտագործում, ապա, այդ մոդուլի ինտերֆեյսը, այսինքն՝ կոնստանտի արժեքը փոխելով, պետք է փոխել նաեւ մոդուլի տարբերակի համարը՝ այսպիսով անվավեր հանելով բոլոր կլիենտ մոդուլները, նույնիսկ նրանք, որոնք այդ կոնստանտը չեն օգտագործել։ Սա արդեն «dll hell»-ի ճիշտ հակապատկերն է։ Եթե սովորական win32 dll բեռնիչը բոլոր մոդուլները համարում էր համատեղելի, ապա .Net-ի դեպքում բեռնիչը անհամատեղելի է համարում չափազանց շատ մոդուլներ․ ինտերֆեյսում նույնիսկ չնչին փոփոխություն կատարելիս անհրաժեշտ է փոխել ամբողջ մոդուլի տարբերակի համարը։ C# լեզվի մեջ, որը, թվում է թե իր տրամաբանությամբ պիտի հարմարեցված լիներ մոդուլյար համակարգերի ծրագրավորման համար, բացակայում է մոդուլի հասկացությունը շարահյուսական մակարդակի վրա․ ուրեմն, մոդուլի ներմուծման հասկացությունը նույնպես բացակայում է։ C# լեզվով գրված մոդուլի տեքստը կարդալիս անհնար է իմանալ․ ա) ինչպիսի մոդուլներ է այն ներմուծում։ բ) որ մոդուլի մեջ է սահմանված տեքստում օգտագործված այս կամ այն իդենտիֆիկատորը։ Կիրառվող namespace մեխանիզմը կապված չէ մոդուլների անունների հետ։ C#-ը «հին նմուշի» լեզու է, որը հարմար է միաձույլ ծրագրեր ծրագրավորելու համար, ու հարմարեցված չէ մոդուլյար համակարգեր ստեղծելու համար։ Գուցե արդար չէ այդքան խիստ լինել C#-ի հետ, քանի որ .Net-ը ավելի նման է քայլ առ քայլ աճող միակուռ համակարգի, քան դինամիկ ընդարձակվող մոդուլյար համակարգի։ Մեծ պրոեկտներ հարմարավետ ծրագրավորելու համար առաջարկվում է օգտվել ոչ թե լեզվի հնարավորություններից, այլ նախագծման միջավայրի գործիքներից։ Գոյություն ունեն կոմպոնենտային համակարգեր, ու կոմպոնենտային ծրագրավորման լեզուներ, որոնք գրեթե զուրկ են թերություններից։ Դա կարող է զարմանք առաջացնել, սակայն առաջին մոդուլյար համակարգերը հայտնվել են դեռ անցյալ դարի 70-ականների ավարտին։ Օրինակ՝ դա Lilith համակարգչի համար ստեղծված օպերացիոն համակարգն է, որը գրված է պրոֆեսոր Նիկլաուս Վիրտի (Niklaus Wirth) Modula-2 լեզվով։ Այնուհետեւ, նա ու Յուրգ Գութկնեխտը (Jurg Gutknecht) ստեղծել են Oberon օպերացիոն համակարգը նույն անվանմամբ՝ Oberon լեզվի օգնությամբ, որը արդեն կարելի է համարել կոմպոնենտային, չնայած այդ համակարգը ստեղծելու աշխատանքը սկսվել է դեռ 1985 թվին՝ կոմպոնենտային ծրագրավորման հիմունքները հռչակելուց 10 տարի առաջ։ Մեր օրերում, օրինակ, Windows-ի համար գոյություն ունի անվճար (եւ ազատ արտոնագրով - թարգմանչի նկատողություն) տարածվող, 1994թ ստեղծված շվեյցարական AG Oberon Microsystems, Inc արտադրության BlackBox Component Builder կոմպոնենտային միջավայրը։ Նիկլաուս Վիրտը տնօրենների խորհրդի կազմի մեջ է, իսկ հիմնադիրներից մեկը ԿԿԾ «գաղափարային հայր», պրոֆեսոր Կլեմենս Շիպերսկին է։ Ճիշտ է այժմ նա աշխատում է որպես software architect Microsoft Research-ում։ Ամենասկզբից BlackBox համակարգը անվանվում էր Oberon/F եւ նախագծվում էր Oberon-2 լեզվով MacOS եւ Windows համակարգերի համար։ Այնուհետեւ Oberon-2 լեզուն փոփոխված էր ԿԿԾ նորաձեւ գաղափարի համաձայն։ Նոր լեզուն ստացավ Կոմպոնենտ Պասկալ (Component Pascal) անունը (1997)․ դա Oberon-2-ի արդյունաբերական տարբերակն է։ 2004 թվին BlackBox-ը հայտարարվել է անվճար, (իսկ ծրագրի կոդը՝ ազատ - թարգմանչի նկատողություն)։ Կամավորները ստեղծում են BlackBox-ի տարբերակ Linux (GNU/Linux - թարգմանչի նկատողություն) համակարգի համար (արդեն կա ալֆա տարբերակը)։ Իսկ Oberon Microsystems-ը ներկա ժամանակ աշխատում է համակարգի նոր տարբերակի վրա։ BlackBox-ով ստեղծված է Ամազոն գետի վրա գտնվող աշխարհի ամենամեծ հիդրոէլեկտրոկայանի հսկման համակարգը։ Դրա համար ստեղծվել էր BlackBox-ի հատուկ տարբերակ 64 բիտանի Unix-ի համար։ Borland ընկերության պատվերով Oberon Microsystems ընկերությունը գրել է Java-ի JIT կոմպիլյատոր։ Բացի դրանից, Oberon Microsystems-ում Կոմպոնենտ Պասկալով գրված է Portos իրական ժամանակի օպերացիոն համակարգը (չշփոթել PortOs-ի հետ, որը լրիվ այլ համակարգ է)։ Այնուհետեւ Portos-ը վերանվանվեց JBed, իսկ Oberon Microsystems-ից առանձնացվեց Esmertec ընկերությունը։ JBed-ը ավելի շատ հայտնի է որպես իրական ժամանակի օպերացիոն համակարգ embedded սարքերի համար, որը գրված է java-ով։ Ի նկատի ունենալով Java-ի լայն տարածումը եւ Component Pascal-ի թույլ ճանաչվածությունը՝ պետք է խոստովանել, որ դա հաջող մարկետինգային քայլ է։ Ռուսաստանում վերջերս հայտնվել է ընկերություն, որը հայտարարել է որպես հիմնական արտադրամիջոց BlackBox Component Builder համակարգը օգտագործոլու մասին։ Գոյություն ունի «Ինֆորմատիկա 21» միջազգային պրոեկտ, որի նպատակներից մեկն է BlackBox համակարգի առաջխաղացումը դպրոցներ, բարոյապես հնացած Turbo Pascal-ի փոխարեն։ Եթե փորձել պատասխանել այն հարցին, թե որն է ավելի լավը՝ BlackBox-ը թե Java-ն, ապա պետք է հաշվի առնել, որ բարդությունը թերություն է, իսկ .Net-ն եւ Java-ն անհամեմատ ավելի բարդ են։ Իսկ բացի BlackBox-ից գոյույթուն ունեն մի շարք հետազոտական մոդուլյար համակարգեր։ Ուզում եմ շեշտել Aos BlueBottle օպերացիոն համակարգը (այժմ A2, թարգմանչի նկատողություն) որը անմիջապես «երկաթի» վրա ապրող ակտիվ օբյեկտների հիման վրա ստեղծված առաջին եւ միակ համակարգն է։ Այն ամբողջությամբ գրված է Active Oberon լեզվով։ Համակարգի կատարման միջավայրը իրականացված է անմիջապես «երկաթի» վրա։ Սակայն, դա արդեն այլ պատմություն է։ բնորինակը

ու տենց

ասք ջավա ծրագրամիստներին ոչնչացնելու մասին

Բլոգը ճիշտ օգտագործեմ, որպես վեբ լոգ՝

Android:
1) Очень тупой интерфейс, просто груда иконок
2) Без JIT’а производительность для таких процессоров просто ужасная. С JIT’ом – лучше, но программы на C++ всё равно в разы быстрее 😉 Т.о. Android в очередной доказал, что Java-говно
3) Весь софт абсолютно типичный для закрытых мобильных платформ. Редкие исключения типа openvpn’а или ssh лишь подтверждают правило: без перепрошивок Android – это раздутая платформа а-ля P2K, но хуже
4) При наличии таких наработок, как Opie и QTopia Google предпочёл просто тупо скопировать идеи Яблока в духе “китайской Nokia”. В итоге получился второй сорт
5) У меня Спика, и в ней не работает встроенное радио, нет хардверного 3D драйвера, хотя есть нужное железо, GPS по дефолту – через пень колоду, процессор – мощный и тупой, флэш не держит. И таких обрубков под Android воз и маленькая тележка.
6) Фингерпады – зло, а в России зимой – ещё и крайне опасное зло. Да, стилус рулит и альтернатив нет.

“В заключение хотелось бы отметить”… У меня MOTOMING на более слабом железе умеет больше, а что не умеет – так нет железа для этого (WiFi нет например). Но платформа использует железку с максимальной отдачей. И это при мизерной оперативке и процессоре 312МГц.
А всё почему? Потому что в основе ezxlinux – бинарная платформа. А Android – свистоперделка для тупых Java-приложений.

Всё вышесказанное свидетельствует о том, что Java-программисты должны уничтожаться в зародыше, иначе планета погибнет от глобального потепления, будучи заваленной к тому же непереработанными аккумуляторами.

Спасибо за внимание!

այստեղից

ու տենց

ասք հռոմեական թվերի մասին

object-oriented design is the roman numerals of computing.

այստեղից

Ռոբ Փայքի, որը այժմ Գոու-ի ֆյուրերն ա ամենահայտնի խոսքերից։

Ինձ շատ ուրախացրեց այս փոսթը

> Java is done right in concept.

wtf?

[ Let me start by saying I don’t speak for any of these guys,
I can’t even get their OS to run a GUI.]

Java is better than C++, but as others have mentioned that’s like saying
toothache is better than herpes.

It’s just C without pointer arithmetic. Leaving aside actual
implementation bugs, it :

* runs on less platforms than any other language I’ve ever used,
* wimped out of having numeric types implemented as objects, then
bolted on ‘containers’ for them in 1.1
*has changed its GUI twice and *still* doesn’t do it right,
* it’s thread model is essential to its operation but differs widely
between VMs even on the same platform
* the same it true for its garbage collector.
* The APIs are huge and inconsistent.
* it *finally* – in 1.4 – has a regex API (which is unusably complex).
* it’s native code bindings are absolutely the worst I’ve ever seen,
even Perl does a better job

And don’t forget m5 current personal favourite –
its pointlessly restrictive type system.

Type is stored in the *pointer*, not the object.
So I have to hold the VMs hand each time I pass an argument.
I’m not allowed to reuse a variable to
point to an List and a Vector, even if I’m going to call a method
with the same name on both.

And then to really piss in my chips, 90% of the Collections API
which lets me store these objects and actually *do* something with them
only lets me pull them out as Object.

I HAVE TO CAST THEM. So when I get an object ‘dynamically’ – via RMI or
out of a Vector or whatever, I have to know what it is in advance.
The poor frigging object doesn’t know (no, don’t get me started on the
abomination that is the reflection API, people are already starting to
stare).

And this is a dynamic language. KERR-RIST.

None of this matters of course, because “it’s better than C++”.
And IT managers think the Sun shines out of its ass.

Java is the f*cking COBOL of the 90s and
future generations of geeks are going to fly back from Mars to piss on
our graves for inflicting it on them.

> Unfortunately. I can do system programming and command-line
> apps with Java.

Sure. If you don’t mind a fifteen second delay while the VM drags itself
up from the bottom of the sea each time you run a command line app.

Or should that ‘.’ be a ‘,’ ?

ու տենց

ասք իմ հետ համաձայն լինելու մասին

“Google distinguished engineer Rob Pike ripped the use of Java and C++ during his keynote at OSCON, saying that these ‘industrial programming languages’ are way too complex and not adequately suited for today’s computing environments. ‘I think these languages are too hard to use, too subtle, too intricate. They’re far too verbose and their subtlety, intricacy and verbosity seem to be increasing over time. They’re oversold, and used far too broadly,’ Pike said. ‘How do we have stuff like this [get to be] the standard way of computing that is taught in schools and is used in industry? [This sort of programming] is very bureaucratic. Every step must be justified to the compiler.’ Pike also spoke out against the performance of interpreted languages and dynamic typing.”

այստեղից

լրիվ տեքստը

ինչի՞ ա տենց հայտարարում։ անկապ չեր ասի, երևի ուզում են Գոու-ն տարածել։

“Go is an attempt to combine the safety and performance of statically typed languages with the convenience and fun of dynamically typed interpretative languages,” he said, before adding, “to the extent that it succeeds you’ll have to judge for yourself.”

փաստորեն։

Սա էլ Պայքի 2000 թվի թուղթ ա։ Հետաքրքիր ա։

ու տենց

ասք ջավային մի քիչ հանդուրժող լինելու մասին

Գիտեք որ արհամարհանքով եմ վերաբերվում ջավա/դոթնեթ/մոնո/քորփորեյթ/էնթերփրայս և այլ իմպերիալիստական չաղ և քաղքենիքաղցած գործիքներին։

Տեխնոլոգիապես։

Ընդհանրապես փորթաբլ լեզու ունենալու գաղափարը լավն է։

Այսինքն մի լեզու որով ոնց էլ գրես, ամեն ինչի վրա քմփայլ կլինի։

Ու ոչ թե նենց ոնց որ ասենք սի-ն որ ասենք եթե ԳՆՈՒ սի քմփայլեր ամեն տեղ կա, ուրեմն ֆսյո։

Չեմ ֆսյո չի բնավ, քանզի ասենք դուք շիֆտ-միֆտ անու՞մ եք։ Վաաաայ, բա էնդիաննեսսը մոռացա՞ք։

Բա տիպերը ձեր մոտ ի՞նչ չափսերի են։

Էթեսեթտրա։

Ու էդ տեսանկյունից իհարկե վատ չի որ ինչ որ տենց բան փորձել են մտածել։

Բայց սպասե՛ք։ Բանն այն է որ լիքը այլ լեզուներ ստեղծվել են հենց փորթաբիլիթին մտքին ունենալով։

Քանզի Լիսպը նա լյուբիծելյա ա, ապա հեռու չգնալու համար հիշեմ Ադան, որտեղ տիպերը առհասարակ ռանջերով են նկարագրվում, ասենք

type Range_Type is range -5 .. 10;

type Angle is delta Pi/2.0**31 range -Pi .. Pi;

Կարող եմ նաև նշել Լիմբո-ն, որը Ինֆերնո համակարգի հիմնական ծրագրավորման լեզուն է։

Ու եթե Լիմբոն համեմատաբար նոր է (իննսունականներ)

ապա Ադան վաղուց կար ու ջեներալփուրփոս է։

Սակայն մարկետինգը ասում է որ սիրուն չէ անել Սան Ադա Մաշին։ Ավելի լավ է մի նոր բան մտածել։

Ջավան ռադիկալ ա, սակայն բնավ ազատ չէ։ Այսինքն, գրել միմիայն օբջեքթ օրիենթեդ պետք չէ։

Լիքը խնդիր կա երբ օբյեկտները լրիվ ավելորդ են։

Մի ծրագրավորող ասում էր որ երբ ջավայով ա գրում, հա պատերի ա իրան խփում։ Քայլ ձախ, քայլ աջ՝ պատ։

Ու դրանք ոչ թե ասենք թայփ տեստեր են որոնք օբյեքտ լեզվին շատ անհրաժետ են, այլ ասենք վիրտուալ մեքենան։

Սինտաքս։

Կրկին մարկետինգ։ Սի-ի սինտակսի թերությունները մնացել են։

x=x+1 – ներեցեք, ո՞նց եք բացատրելու մարդուն էդ ո՞նց ա x-ը «հավասար»։ Չէ՞ հավասար չէ բնավ։ Վերագրվու՞մ ա։

Ապա վերագրման նշան կիրառեք, որը ընգծում ա անհավասարակշռությունը։

Այդ նշանը Ալգոլի ժամանակներից կա՝ :=

Չի դզում՝ նորը մտածեք։

Ու ասեմ որ Յունիքսի ստեղծողները իրանք ով նախագծել են Լիմբոն, արդեն այնտեղ կիրառում են հենց այդ նշանը։

Լիմբոն և Օբերոնը ինսփայր են արել Գոու, որին խորհուրդ եմ անում ուշադրություն դարձնել։ Չնայած, իրա մեջ դեռ ռեալիզացիա արած չեն շատ հնարավարություններ, որոնք կան պարզ Օբերոնում, բայց դա հիմա էական չէ։

Էդ նաև ազատում ա == որպես էքվալիթիի նշան օգտագործելուց։

Առհասարակ, ==, <> սխալի բուն են։ Նիշերից մեկը չտպվեց՝ հետո լիքը մարդ տառապում ա խնդիրը գտնելով։

Ու մի ասեք, փորձառու ծրագրավորողը տենց սխալ չի անի։ Ինչի՞ փորձառուն տենց հիմար բաներով պիտի տարբերվի անփորձից։ Փորձառուն մի քիչ այլ գաղափար ա։ Տենց հիմար փորձ պետք չէ բնավ։

Ռեալիզացիա։

Դիտարկենք ՋՎՄ/ՋԴԿ և գցջ։

ՋՎՄ-ի շերտը շատ ծանր է և չաղ։

Մասշտաբիրուեմոսծը բացակայում է։

ՄԵ-ն միկրո էդիշն ա, այլ ոչ թե ստանդարտ մեքենայի քոր, որը էքստենսիբլ ա լինում, ու դառնում ստանդարտ փլագիններ ավելացնելով։

Էքսթենսիբլիությունը – սիրուն լուծում ա։ Տարբեր էդիշններ՝ տգեղ և հիշեցնում է հենակներ, որոնք, անկասկած շատ են կիրառվել ռեալիզացիայի ժամանակ։

Վիրտուալ մեքենան ուտում է հիշողություն և մինչև վերջերս բաց չեր։

Ու որպես կանոն ջավա կոդը անհամեմատ դանդաղ ա կատարվում։

Իմ խորհին համոզմունքն է որ մենք ժամանակից թանկ բան չունենք։

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

Ինչքան արագ գրվի սոֆտը, այդքան արագ շուկա կհանվի, այդքան քիչ փող կծախսվի նախագծման ընթացքում։

Ջավայի տորմոզնուտոսծի շատ հավես իլլյուստրացիա կա։

Ռուսները Տոմմի անունով ռոբոտ ունեին։ Ինքը մասնակցում էր ԴԱՐՊԱ-ի կազմակերպած րեյսինգի մրցույթին։ Եվ սպանվեց իրան ապստենու գլուխը պատով տվեց։ Երևի ԳՑ-ն էր միացել։ Այդ դեպքից հետո ծրագրավորողների մի մաս սկսեց համաձայնվել ջավիստների հետ այն մասին որ «ջավա նե տարմազիտ»։

Իմ իմացած յուզերների մեծ մասը զզվում ա ջավա ափլիքեյշններից․ «նրանք ծանր են, դանդաղ և այլն» պատճառաբանություններով։

Այդ իսկ պատճառով հիմա ջավան հարկադրվել է հեռանալ քորփորեյթ լուծումների ասպարեզ։ Դեսքթոփ ափլիքեյշններ անտեսելի քիչ են։

գցջ-ն՝ քմփայլ է լինում նեյթիվ կոդ, լինկ էր լինում սի և այլ գրադարաններին, նույնիսկ աղբ թափելը իրականացվախ է Հանս Բոեհմի Սի/ՍիՓլասՓլասՔոլեկտորով ։ Ահագին գործ իրան լավացնելու մաջ արել է ՐեդՀատը, որը ասենք, ժամանակին պատչեր արել որ Թոմքատ իրանով քմփայլի։

Այս իրականացումը վատը չէ, նույնիսկ լավն է, սակայն իրանով լիքը բան անել չի լինի։ ՋԴԿ-ի օփենսոուրսացումը կարող է խոչընդոտել այս լուծման հետագա զարգացմանը։

Արտաքին տեսք։

Ջավայի Սվինգ ուիդջետներից տգեղ բան չկա։ Մոտիֆը նույնիսկ սիրուն ա դրա հետ համեմատ։ Այսպիսի բաներից հետ տալս գալիս ա։ Լուրջ։ Սիրտս խարնում ա։

Ընդ որում ուինդոուսում էդ ուիդջետներով հաճախ հասարակ մաուսի սքրոլ չի աշխատում։ Լինուքսում ի դեպ՝ աշխատում ա։

Եթե ԱյԲիԷմի ՍՎՏ թուլքիթը չլիներ (էկլիպսի ուիդջետները դրանով են արած) ի՞նչ էիք անելու այ դեվելոպերներ։

Իդեոլոգիապես։

Իմ կարծիքով,

Ջավան ինքը իրա դիզայնով օփեն սորսին խփում էր՝ տիպա մեզ պետք չեն իսխոդնիկներ պորտ անելու համար, այլ պլատֆորմային, քանզի ամեն պլատֆորմայի վրա մի վիրտուալ շերտ կա։

Ու ջահնդամը որ լիքը հիշուղություն ա ուտում այդ շերտը, և հիմնականում դանդաղ են աշխատում ծրագրերը։

Սաղ հեչ։ Փաստորեն հիմա ստացվում ա որ նույնիսկ նենց տգեղ լուծումը «լավն» ա դարնում երբ այֆոնը կապվում ա օբջեքթիվ-սի-կակաո վիճակներին փորթաբիլիությունը խոչընդոտելու նպատակով։ Ի դեպ, էփլին լավ կհարվածի ՔյուՏի պորտը։ Թե սիպլասնել են բան անելու։ Ո՞ր պատճառաբանությամբ։

Հա, ու ասենք ծանոթ եմ տեսնում Սոնի Էրիկսոնով, ասում եմ՝ լավ ա չի բողոքի որ բան չի կարողանում տեղակայել, քանզի իրա մոտ, ջավա կա՝ աշխատում ա լիքը բան։

Չնայած ՄԵ-ի ռեալիզացիան նենց աղքատիկ էր վախտին, ասենք թափանցիկ սպրայտեր չկային։ Չգիտեմ հիմա ավելացրել են թե ոչ։

Իսկ նապասլեդըկ խորհուրդ եմ տալիս նայել սա ու համոզվել թե ով է ջավամանը իրականում ։

_ու տենց _

պատմություն սրճի հոտի մասին

spent several months programming in Java. Contrary to its authors prediction, it did not grow on me. I did not find any new insights – for the first time in my life programming in a new language did not bring me new insights. It keeps all the stuff that I never use in C++ – inheritance, virtuals – OO gook – and removes the stuff that I find useful. It might be successful – after all, MS DOS was – and it might be a profitable thing for all your readers to learn Java, but it has no intellectual value whatsoever. Look at their implementation of hash tables. Look at the sorting routines that come with their “cool” sorting applet. Try to use AWT. The best way to judge a language is to look at the code written by its proponents. “Radix enim omnium malorum est cupiditas” – and Java is clearly an example of a money oriented programming (MOP). As the chief proponent of Java at SGI told me: “Alex, you have to go where the money is.” But I do not particularly want to go where the money is – it usually does not smell nice there.

այստեղից

_ու տենց _