மென்பொருள் சோதனைக்கு அடிப்படையான வழிமுறைகளை ஏழு நெறிமுறைகளாக(Software Testing Principles)த் தொகுத்திருக்கிறார்கள். அவற்றைத் தாம் இந்தப் பதிவில் பார்க்கப் போகிறோம்.
நெறிமுறை #1: பிழைகள் எங்கெங்கு இருக்கின்றன என்று காட்டுவது தான் சோதனை.
(Testing shows presence of defects.)
பிழைகள் எங்கெங்கு இருக்கின்றன என்று காட்டுவது தான் சோதிப்பது ஆகும். எனவே இந்த நெறிமுறையை மனத்தில் கொண்டு அதற்கேற்ப டெஸ்ட் கேஸ்களை உருவாக்க வேண்டும். அதற்காகப் பிழைகளே இல்லாத ஒரு மென்பொருளை உருவாக்கி விட முடியும் என்று நம்பாதீர்கள். (அப்படி ஒரு மென்பொருள் இருந்தால் எதற்கு அடுத்தடுத்த பதிப்புகள்(வெர்ஷன்கள்) தேவைப்படும்?)
நெறிமுறை #2: எல்லாவகைச் சோதனைகளையும் செய்து முடிப்பது சாத்தியமே இல்லாத ஒன்று.
(Exhaustive Testing is impossible.).
ஒரு மென்பொருளைச் சோதிக்கும் போது எல்லாவகைச் சோதனைகளையும் சோதிப்பது என்பது இயலாத ஒன்றாகும். ஒரு கடவுச்சொல் பதியும் பெட்டியைச் சோதிப்பதாக வைத்துக் கொள்ளுங்கள். ஒவ்வொரு பயனரும், ஒவ்வொரு விதமாகத் தம்முடைய கடவுச்சொல்லை வைத்திருப்பார். அதை ஒவ்வொன்றையும் ஒரு டெஸ்டரால் உருவாக்கிச் சோதிக்க முடியாதல்லவா? ஒரு பொது வரையறையை உருவாக்கி அதன் அடிப்படையில் சோதனையைச் செய்ய முடியும். ஆனால், எல்லா வகைகளையும் சோதனைக்கு உட்படுத்த முடியாது.
நெறிமுறை #3: முன்கூட்டிய சோதனை(Early Testing)
வாழ்க்கையைப் போலவே தான் டெஸ்டிங்கும்! சோதனைகளை முதலிலேயே எதிர்கொள்வது சிறந்தது. ஒரு மென்பொருள் உருவாக்கத்தின் கடைசிக்கட்டத்தில் சோதனைகளைச் செய்து பிழைகளைக் கண்டுபிடிக்கலாம். ஆனால், அந்தப் பிழைகளைக் களைய ஆகும் நேரமும் உழைப்பும் அதிகமாகத் தேவைப்படும் அல்லவா? எனவே தான், கூடிய வரை சோதனையை முன் கூட்டியே தொடங்குவது என்பது சாலச் சிறந்தது. இந்த நெறிமுறையைப் பின்பற்றும் போது டெஸ்டர்களையும் முன் கூட்டியே களத்தில் இறக்கி விடலாம். டெஸ்டர்கள் முன்னதாகக் களம் இறங்க, இறங்க, மென்பொருளின் தரம் மேல் உயரும்.
நெறிமுறை #4: பிழை கொத்து (Defect Clustering)
என்ன தலைப்பு இது? பிழைகளைக் கொத்துவது தானே டெஸ்டரின் வேலை? என்கிறீர்களா? இது கொத்துவது இல்லை! கொத்துகள் – அதாவது பிழைகளைக் குவிப்பது! ஒரு டெஸ்டர் எப்படிப் பிழைகளைக் கொத்திக் குவிப்பது என்பதைப் பற்றியது!
உங்களுக்கு இத்தாலியைச் சேர்ந்த பொருளியல் அறிஞர் பரேட்டோவைத் தெரியுமா? பரேட்டோ – (Pareto) எங்கேயோ கேள்விப்பட்ட பெயர் போல இருக்கிறது என்கிறீர்களா? கேள்விப்பட்டிருந்தால் கூடப் போதும்! அவருடைய புகழ்பெற்ற வாக்கியம் ஒன்றிருக்கிறது – 80 % அளவுச் சொத்துகள் 20% மக்களிடம் தாம் இருக்கின்றன என்றார் அவர். உண்மை தானே! என்கிறீர்களா? இது மட்டுமில்லை! அவருடைய தோட்டத்தில் விளைந்த கடலையில் 80% கடலை 20% செடிகளில் விளைந்திருந்ததாக அறிந்தார் பரேட்டோ.
1930-40களில் அமெரிக்க மேலாண்மை வல்லுநர் முனைவர் ஜோசப் ஜூரன் (Joseph Juran) பரேட்டோவின் இந்த விதி அனைத்து விடயங்களுக்கும் பொருந்தும் என்று கூறினார். இதற்குப் பரேட்டோ கொள்கை என்னும் பெயரை அவரே சூட்டினார். இந்த விதி தான் பின்னர் 80/20 விதி என்று பலராலும் அழைக்கப்பட்டது.
இப்போது எதற்கு இந்த 80/20 விதி பற்றிய கதை – என்கிறீர்களா?
பரேட்டோவின் இந்த விதி தான் எல்லா விடயங்களுக்கும் பொருந்தும் என்று கண்டுபிடித்து விட்டார்களே! அப்படியானால், நம்முடைய மென்பொருள் சோதனைக்குப் பொருந்தாதா? பொருந்தும் தானே! 80% பிழைகளுக்குக் காரணம் நிரலர் உருவாக்கும் மென்பொருளின் 20% பகுதிகள் தாம்! அவற்றைக் கண்டுபிடித்தால் போதும் – பெரும்பாலான பிழைகளைக் கண்டுபிடித்து விடலாம். இந்த விதிக்கேற்ப பிழைகளைக் கொத்துகளாக(clusters)ப் பிரித்துக் கொள்ள வேண்டும் என்பது தான் இந்த நெறி கூறும் கருத்து.
இன்னும் மீதம் இருக்கும் மூன்று நெறிமுறைகளையும் அடுத்த பதிவில் பார்ப்போம்.
– கி. முத்துராமலிங்கம்(muthu@payilagam.com)