Ծրագրավորման պատմության ամենաթանկ սխալներից մեկը տեղի ունեցավ, որովհետև թիվը չափազանց մեծ էր այն համակարգի համար, որտեղ պետք է պահվեր։
1996 թվականին Ariane 5 հրթիռը պայթեց թռիչքից մեկ րոպե էլ չանցած։ Պատճառը պարզապես մեխանիկական խափանում չէր։ Ուղղորդման համակարգի ծրագրային սխալը կարևոր դեր ունեցավ։ Մեկ արժեք փոխակերպվել էր ավելի մեծ թվային ձևաչափից դեպի ավելի փոքր ձևաչափ, և արդյունքը չէր տեղավորվում։
Այսպիսի խնդիրն անվանում են overflow։ Այս պատմությունը դարձավ հայտնի դաս ծրագրային ինժեներիայում․ կոդը, որը աշխատել է մեկ համակարգում, կարող է վտանգավոր ձախողվել, եթե օգտագործվի ուրիշ պայմաններում։
Ինչ է տեղի ունեցել պարզ բառերով
Հրթիռի ծրագիրը փորձեց մեծ թիվը փոխակերպել ավելի փոքր ձևաչափի։ Բայց թիվը չափազանց մեծ էր այդ ձևաչափի համար։ Համակարգը չկարողացավ այդ փոխակերպումը ճիշտ մշակել։
Այդ սխալը ազդեց ուղղորդման համակարգի վրա, և հրթիռը սխալ տեղեկություն ստացավ իր շարժման մասին։ Համակարգը սխալ արձագանքեց, հրթիռը դարձավ անկայուն և կարճ ժամանակ անց ոչնչացվեց։
Կարևոր դասը միայն այն չէ, որ թիվը չտեղավորվեց։ Ավելի խոր դասը այն է, որ ծրագիրը պետք է փորձարկվի այն իրական պայմաններում, որտեղ այն պետք է աշխատի։
Ինչու նախկին կոդի օգտագործումը դարձավ ռիսկային
Ծրագրի մի մասը վերցված էր ավելի վաղ Ariane 4 համակարգից։ Այդ կոդը նախկինում աշխատել էր, բայց Ariane 5-ը ուներ թռիչքի այլ վարքագիծ։ Այն շարժվում էր այլ կերպ և ստեղծում էր արժեքներ, որոնք հին ենթադրությունները անվտանգ չէին մշակել։
Սա ծրագրավորման մեջ տարածված ռիսկ է։ Կոդի կրկնակի օգտագործումը կարող է ժամանակ խնայել, բայց այն իր հետ բերում է հին ենթադրություններ։ Եթե նոր համակարգը այլ կերպ է աշխատում, այդ ենթադրությունները կարող են վտանգավոր դառնալ։
Որտեղ է սա պատահում սովորական ծրագրերում
Այս խնդրին բախվելու համար պարտադիր չէ հրթիռ կառուցել։ Նման սխալներ կարող են լինել սովորական ծրագրերում՝
- տվյալների բազայի դաշտը չափազանց փոքր է նոր արժեքի համար
- վճարման գումարը սխալ է կլորացվում
- հաշվիչը անցնում է սպասված սահմանը
- ֆայլի չափը մեծ է համակարգի սպասածից
- հին կոդը օգտագործվում է նոր արտադրանքի համար առանց բավարար փորձարկման
- բջջային հավելվածը ենթադրում է էկրանի չափ կամ սարքի վարքագիծ, որն այլևս ճիշտ չէ
Սխալը կարող է փոքր թվալ, բայց արդյունքը կարող է լուրջ լինել, եթե համակարգը կախված է այդ արժեքից։
Թաքնված ենթադրությունների վտանգը
Ծրագրերը հաճախ պարունակում են ենթադրություններ, որոնք հստակ գրված չեն։ Ծրագրավորողը կարող է ենթադրել, որ թիվը միշտ փոքր է լինելու, օգտատերերի քանակը երբեք չի անցնելու սահմանը կամ արժեքը միշտ գալու է նույն ձևաչափով։
Այդ ենթադրությունները կարող են ճիշտ լինել այսօր, բայց սխալ՝ վաղը։ Համակարգերը մեծանում են, օգտատերերը փոխվում են, տվյալները փոխվում են, և հին սահմանները դառնում են վտանգավոր։
Լավ համակարգերը ստուգում են սահմանները
Ավելի անվտանգ համակարգը պարզապես չի վստահում յուրաքանչյուր արժեքի։ Այն ստուգում է սահմանները, մշակում է սխալները և որոշում է՝ ինչ պետք է տեղի ունենա, երբ անսպասելի բան է հայտնվում։
Օրինակ՝ եթե արժեքը չափազանց մեծ է, համակարգը չպետք է անկանխատեսելի ձևով խափանվի։ Այն պետք է մերժի արժեքը, գրանցի խնդիրը, օգտագործի անվտանգ պահուստային տարբերակ կամ կանգնեցնի գործընթացը վերահսկվող ձևով։
Փորձարկումը պետք է համապատասխանի իրականությանը
Միայն հին իրավիճակը փորձարկելը բավարար չէ։ Երբ կոդը օգտագործվում է նոր միջավայրում, փորձարկումները պետք է արտացոլեն այդ նոր միջավայրը։
Թիմերը պետք է հարցնեն՝
- Ինչպիսի՞ արժեքներ կարող է հիմա ստանալ այս համակարգը։
- Հին սահմանները դեռ ճի՞շտ են։
- Ի՞նչ է լինում առավելագույն արժեքի դեպքում։
- Ի՞նչ է լինում, երբ փոխակերպումը ձախողվում է։
- Համակարգը անվտանգ ձևո՞վ է ձախողվում։
Այս հարցերը կարևոր են ոչ միայն տիեզերական ոլորտում, այլ նաև ֆինանսներում, առողջապահությունում, լոգիստիկայում, կրթությունում և բիզնես ծրագրերում։
Օգտակար սովորություններ ծրագրավորողների համար
- Հնարավորության դեպքում խուսափիր վտանգավոր թվային փոխակերպումներից։
- Փաստաթղթավորիր կարևոր արժեքների սպասվող սահմանները։
- Փորձարկիր սահմանային դեպքերը, ոչ միայն սովորական դեպքերը։
- Վերանայիր կրկնակի օգտագործվող կոդը՝ հին ենթադրությունների համար։
- Սխալները մշակի՛ր հստակ ձևով։
- Ձախողումը դարձրու անվտանգ, ոչ թե անկառավարելի։
Թաքնված դասը․ «նախկինում աշխատում էր» արտահայտությունը բավարար չէ
Ծրագրավորման մեջ ամենավտանգավոր արտահայտություններից մեկն է՝ «նախկինում աշխատում էր»։ Դա կարող է ճիշտ լինել, բայց այն աշխատել է որոշակի պայմաններում։ Երբ պայմանները փոխվում են, նույն կոդը կարող է այլ կերպ վարվել։
Հուսալի ծրագիրը պարզապես երեկ աշխատած կոդը չէ։ Դա կոդ է, որը հասկացված է, փորձարկված է և անվտանգ է այսօրվա պայմաններում։
Եզրակացություն
Ariane 5-ի ձախողումը սովորեցնում է, որ ծրագրային ենթադրությունները, թվային սահմանները և կրկնակի օգտագործվող կոդը պետք է շատ լուրջ ընդունել։ Փոքր փոխակերպման սխալը կարող է դառնալ մեծ համակարգային ձախողում, եթե ոչ ոք չի ստուգում՝ արդյոք հին կոդը դեռ համապատասխանում է նոր իրականությանը։