प्रोग्रामों की डिबगिंग

डिबग करना जाँच-पड़ताल करना है

दोष और विफलता

विफलता वह है जो देखी जाती है: ग़लत परिणाम, ऐसा प्रोग्राम जो समाप्त नहीं होता, डिटेक्टर की रिपोर्ट। दोष (या त्रुटि) कारण है: कोई पंक्ति, कोई शर्त या कोई डिज़ाइन-निर्णय जो विनिर्देश के अनुरूप नहीं है। विफलता दिखती है; दोष को खोजना पड़ता है, और वह उससे दूर भी हो सकता है। इससे यह निकलता है कि जहाँ विफलता दिखती है वहीं सुधार करना, उदाहरण के लिए परिणाम में से 2 घटा देना क्योंकि “हमेशा 2 ज़्यादा आता है”, लक्षण को सुधारता है और कारण को छोड़ देता है, जो दूसरे आँकड़ों के साथ लौट आएगा।

यदि ऐसा है, तो डिबग करना कारण की जाँच-पड़ताल है, और उसकी विधि प्रायोगिक विज्ञानों की विधि है:

1. अवलोकन और पुनरुत्पादन। विफलता का सटीक वर्णन करना (किस इनपुट के साथ, क्या अपेक्षित था, क्या मिला) और ऐसा करना कि वह जब चाहें तब घटित हो। जो दोष पुनरुत्पादित नहीं होता, उसकी जाँच नहीं की जा सकती, और न ही यह जाँचा जा सकता है कि वह सुधर गया।
2. परिकल्पना बनाना। कारण के बारे में ऐसा कथन जो असत्य सिद्ध हो सकता हो: “क्रमबद्धन सूची को क्रमबद्ध नहीं करता”, “बीच के दूसरे आँकड़े का सूचकांक एक अधिक है”।
3. प्रयोग रचना। प्रोग्राम का एक बिंदु चुनना और यह पूर्वानुमान करना कि यदि परिकल्पना सत्य है तो वहाँ कौन-सी अवस्था दिखनी चाहिए, और यदि असत्य है तो कौन-सी।
4. निष्कर्ष और दायरा सीमित करना। परिकल्पना को ख़ारिज करना या उसकी पुष्टि करना; दोनों ही दशाओं में संदिग्ध हिस्सा छोटा हो जाता है। यह तब तक दोहराया जाता है जब तक हिस्सा एक पंक्ति न रह जाए।

किंतु यह विधि अनुशासन माँगती है: एक बार में केवल एक चीज़ बदलना, हर परिकल्पना को उसके परिणाम के साथ लिखना, और जब तक पता न हो कि क्या खोजा जा रहा है तब तक कोड को न छूना। आउटपुट के सही दिखने तक पंक्तियाँ मनमाने ढंग से बदलते रहना दोष को हटाए बिना विफलता को छिपा सकता है।

#include <algorithm>#include <cstddef>#include <print>#include <vector>​// आँकड़ों की एक सूची की माध्यिका।// पूर्व-शर्त: values खाली नहीं है।// पश्च-शर्त: क्रमबद्ध सूची का बीच का आँकड़ा, या बीच के दो आँकड़ों का औसत लौटाता है।double median(std::vector<double> values){    std::ranges::sort(values);    const std::size_t n{values.size()};    const std::size_t middle{n / 2};    if (n % 2 == 1) {        return values[middle];    }    return (values[middle] + values[middle + 1]) / 2.0;}​int main(){    const std::vector<double> odd{7.0, 1.0, 5.0, 3.0, 9.0};    const std::vector<double> even{7.0, 1.0, 5.0, 3.0};    std::println("{} की माध्यिका: {}", odd, median(odd));    std::println("{} की माध्यिका: {}", even, median(even));}

[7, 1, 5, 3, 9] की माध्यिका: 5[7, 1, 5, 3] की माध्यिका: 6

द्विभाजन

जब कोई स्पष्ट परिकल्पना न हो, तब भी एक ऐसी विधि बचती है जो विफल नहीं होती: द्विभाजन। यह माना जाता है कि प्रोग्राम की अवस्था आरंभ में सही है और अंत में ग़लत, और हर बीच के बिंदु पर यह तय किया जा सकता है कि वह सही है या नहीं (हाथ से निकाले गए मान से तुलना करके, या किसी निश्चर की जाँच करके)। संदिग्ध हिस्से के बीच में अवस्था की जाँच की जाती है: यदि वह सही है, तो दोष दूसरे आधे भाग में है; यदि नहीं, तो पहले में। यह पाठ खोजना और क्रमबद्ध करना की द्विआधारी खोज है, जो किसी प्रोग्राम की पंक्तियों पर (या किसी लूप के चक्करों पर, या किसी फ़ाइल के संस्करणों पर) लागू की गई है।

चित्र सोलह पंक्तियों के द्विभाजन का अनुसरण करता है, जिनमें दोष पंक्ति 11 में है; हर निशान उस पंक्ति के बाद की अवस्था पर एक प्रयोग है: सही (✓) या ग़लत (✗)।

गिनती वही है जो द्विआधारी खोज की है: हर प्रयोग हिस्से को दो भागों में बाँट देता है, इसलिए $k$ प्रयोग $2^k$ पंक्तियों के लिए पर्याप्त हैं। एक हज़ार पंक्तियों के प्रोग्राम के लिए दस पर्याप्त हैं, क्योंकि $2^{10} = 1024$। इसी से विधि का लाभ निकलता है: इसकी लागत आकार के लघुगणक की तरह बढ़ती है, और यह पूरे प्रोग्राम को समझने की माँग नहीं करती, बल्कि यह तय कर पाने की कि किसी बिंदु पर अवस्था वैसी है या नहीं जैसी होनी चाहिए। किंतु यही निर्णय कठिन हिस्सा है: विनिर्देश और निश्चर ही वह कसौटी हैं जिससे हर बीच की अवस्था को परखा जाता है।