जैक्सन संरचित प्रोग्रामिंग
जैक्सन स्ट्रक्चर्ड प्रोग्रामिंग (जेएसपी) ब्रिटिश सॉफ्टवेयर सलाहकार माइकल ए जैक्सन (कंप्यूटर वैज्ञानिक) | माइकल ए जैक्सन द्वारा विकसित संरचित प्रोग्रामिंग के लिए एक विधि है और उनकी 1975 की पुस्तक प्रिंसिपल्स ऑफ प्रोग्राम डिजाइन में वर्णित है।[1] JSP की तकनीक उन फाइलों की डेटा संरचनाओं का विश्लेषण करना है जिन्हें एक प्रोग्राम को इनपुट के रूप में पढ़ना चाहिए और आउटपुट के रूप में उत्पन्न करना चाहिए, और फिर उन डेटा संरचनाओं के आधार पर एक प्रोग्राम डिज़ाइन का निर्माण करना चाहिए, ताकि प्रोग्राम नियंत्रण संरचना उन डेटा संरचनाओं को स्वाभाविक रूप से संभाल सके। और सहज तरीका।
जेएसपी तीन बुनियादी संरचनाओं - अनुक्रम, पुनरावृत्ति, और चयन (या विकल्प) का उपयोग करके संरचनाओं (डेटा और प्रोग्राम दोनों) का वर्णन करता है। इन संरचनाओं को एक नियमित अभिव्यक्ति के दृश्य प्रतिनिधित्व के रूप में (वास्तव में) आरेखित किया गया है।
परिचय
माइकल ए. जैक्सन (कंप्यूटर वैज्ञानिक) | माइकल ए. जैक्सन ने मूल रूप से 1970 के दशक में जेएसपी विकसित किया था। उन्होंने अपनी 1975 की किताब प्रिंसिपल्स ऑफ प्रोग्राम डिजाइन में सिस्टम का दस्तावेजीकरण किया।[1]2001 के एक सम्मेलन वार्ता में,[2] उन्होंने विधि के पीछे मूल प्रेरक शक्तियों का पूर्वव्यापी विश्लेषण प्रदान किया, और इसे बाद के सॉफ्टवेयर इंजीनियरिंग विकासों से संबंधित किया। जैक्सन का उद्देश्य COBOL बैच फाइल प्रोसेसिंग प्रोग्राम को संशोधित करना और बनाए रखना आसान बनाना था, लेकिन विधि का उपयोग किसी भी प्रोग्रामिंग भाषा के लिए प्रोग्राम डिजाइन करने के लिए किया जा सकता है जिसमें संरचित नियंत्रण निर्माण-अनुक्रम, पुनरावृत्ति और चयन (यदि/तब/अन्य) हो।
जैक्सन स्ट्रक्चर्ड प्रोग्रामिंग वार्नियर/ओआरआर डायग्राम्स|वार्नियर/ओआरआर स्ट्रक्चर्ड प्रोग्रामिंग के समान थी[3][4] हालांकि JSP ने इनपुट और आउटपुट दोनों डेटा संरचनाओं पर विचार किया, जबकि Warnier/Orr पद्धति लगभग विशेष रूप से आउटपुट स्ट्रीम की संरचना पर केंद्रित थी।
विधि के लिए प्रेरणा
जिस समय JSP विकसित किया गया था, उस समय अधिकांश प्रोग्राम बैच COBOL प्रोग्राम थे जो टेप पर संग्रहीत अनुक्रमिक फ़ाइलों को संसाधित करते थे। एक विशिष्ट प्रोग्राम अपनी इनपुट फ़ाइल के माध्यम से रिकॉर्ड के अनुक्रम के रूप में पढ़ता है, ताकि सभी कार्यक्रमों में एक ही संरचना हो - एक एकल मुख्य लूप जो फ़ाइल में सभी रिकॉर्ड को संसाधित करता है, एक समय में। जैक्सन ने जोर देकर कहा कि यह प्रोग्राम संरचना लगभग हमेशा गलत थी, और प्रोग्रामरों को अधिक जटिल डेटा संरचनाओं की तलाश करने के लिए प्रोत्साहित किया। प्रोग्राम डिजाइन के सिद्धांतों के अध्याय 3 में[1]जैक्सन एक कार्यक्रम के दो संस्करण प्रस्तुत करता है, एक जेएसपी का उपयोग करके डिज़ाइन किया गया है, दूसरा पारंपरिक सिंगल-लूप संरचना का उपयोग कर रहा है। यहाँ उनका उदाहरण है, COBOL से जावा में अनुवादित। इन दो कार्यक्रमों का उद्देश्य क्रमबद्ध फ़ाइल में दोहराए गए रिकॉर्ड (पंक्तियों) के समूह को पहचानना है, और प्रत्येक रिकॉर्ड को सूचीबद्ध करने वाली आउटपुट फ़ाइल और फ़ाइल में होने वाली संख्या को सूचीबद्ध करना है।
यहाँ कार्यक्रम का पारंपरिक, सिंगल-लूप संस्करण है।
String line;
int count = 0;
String firstLineOfGroup = null;
// begin single main loop
while ((line = in.readLine()) != null) {
if (firstLineOfGroup == null || !line.equals(firstLineOfGroup)) {
if (firstLineOfGroup != null) {
System.out.println(firstLineOfGroup + " " + count);
}
count = 0;
firstLineOfGroup = line;
}
count++;
}
if (firstLineOfGroup != null) {
System.out.println(firstLineOfGroup + " " + count);
}
यहाँ उसी प्रोग्राम का JSP-शैली संस्करण है। ध्यान दें कि (पारंपरिक कार्यक्रम के विपरीत) इसमें दो लूप होते हैं, एक दूसरे के अंदर नेस्टेड होता है। बाहरी लूप दोहराए जाने वाले रिकॉर्ड के समूहों को संसाधित करता है, जबकि आंतरिक लूप एक समूह में अलग-अलग रिकॉर्ड को संसाधित करता है।
String line;
int numberOfLinesInGroup;
line = in.readLine();
// begin outer loop: process 1 group
while (line != null) {
numberOfLinesInGroup = 0;
String firstLineOfGroup = line;
// begin inner loop: process 1 record in the group
while (line != null && line.equals(firstLineOfGroup)) {
numberOfLinesInGroup++;
line = in.readLine();
}
System.out.println(firstLineOfGroup + " " + numberOfLinesInGroup);
}
जैक्सन पारंपरिक सिंगल-लूप संस्करण की इनपुट फ़ाइल की संरचना को संसाधित करने में विफल रहने के लिए आलोचना करता है (रिकॉर्ड के दोहराए जाने वाले समूह जिसमें व्यक्तिगत रिकॉर्ड दोहराए जाते हैं) एक प्राकृतिक तरीके से। इसके अप्राकृतिक डिजाइन का एक संकेत यह है कि, ठीक से काम करने के लिए, इसे फाइल के पहले और आखिरी रिकॉर्ड को संभालने के लिए विशेष कोड शामिल करने के लिए मजबूर किया जाता है।
मूल विधि
जेएसपी प्रोग्राम के इनपुट और आउटपुट की मौजूदा संरचना को प्रोग्राम की संरचना में ही कैप्चर करने के लिए अर्ध-औपचारिक चरणों का उपयोग करता है।
इरादा ऐसे प्रोग्राम बनाने का है जो अपने जीवनकाल में संशोधित करना आसान हो। जैक्सन की प्रमुख अंतर्दृष्टि यह थी कि आवश्यकता परिवर्तन आमतौर पर मौजूदा संरचनाओं में मामूली बदलाव होते हैं। जेएसपी का उपयोग करके बनाए गए प्रोग्राम के लिए, इनपुट, आउटपुट और प्रोग्राम की आंतरिक संरचनाएं सभी मेल खाती हैं, इसलिए इनपुट और आउटपुट में छोटे बदलाव प्रोग्राम में छोटे बदलावों में तब्दील होने चाहिए।
जेएसपी चार घटक प्रकारों के संदर्भ में कार्यक्रमों की संरचना करता है:
- मौलिक संचालन
- अनुक्रम
- पुनरावृत्तियाँ
- चयन
विधि चार मौलिक घटक प्रकारों के संदर्भ में एक प्रोग्राम के इनपुट का वर्णन करके शुरू होती है। इसके बाद यह उसी तरह प्रोग्राम के आउटपुट का वर्णन करता है। प्रत्येक इनपुट और आउटपुट को एक अलग डेटा संरचना आरेख (डीएसडी) के रूप में तैयार किया गया है। डिजिटल सिग्नल प्रोसेसिंग (डीएसपी) जैसे कंप्यूट-गहन अनुप्रयोगों के लिए जेएसपी काम करने के लिए एल्गोरिथम संरचना आरेखों को आकर्षित करना भी आवश्यक है, जो इनपुट और आउटपुट वाले के बजाय आंतरिक डेटा संरचनाओं पर ध्यान केंद्रित करते हैं।
इनपुट और आउटपुट संरचनाएं तब एकीकृत होती हैं या अंतिम प्रोग्राम संरचना में विलय हो जाती हैं, जिसे प्रोग्राम स्ट्रक्चर डायग्राम (PSD) के रूप में जाना जाता है। इस कदम में इनपुट और आउटपुट को मिलाने के लिए उच्च स्तरीय नियंत्रण संरचना की एक छोटी राशि शामिल हो सकती है। कुछ प्रोग्राम किसी भी आउटपुट को करने से पहले सभी इनपुट को प्रोसेस करते हैं, जबकि अन्य एक रिकॉर्ड में पढ़ते हैं, एक रिकॉर्ड लिखते हैं और पुनरावृति करते हैं। इस तरह के तरीकों को PSD में कैप्चर करना होगा।
PSD, जो कि भाषा तटस्थ है, को फिर एक प्रोग्रामिंग भाषा में कार्यान्वित किया जाता है। जेएसपी नियंत्रण संरचनाओं के स्तर पर प्रोग्रामिंग के लिए तैयार है, इसलिए कार्यान्वित डिज़ाइन केवल आदिम संचालन, अनुक्रम, पुनरावृत्तियों और चयनों का उपयोग करते हैं। जेएसपी का उपयोग कक्षाओं और वस्तुओं के स्तर पर कार्यक्रमों की संरचना के लिए नहीं किया जाता है, हालांकि यह कक्षा के तरीकों के भीतर प्रवाह को नियंत्रित करने में मदद कर सकता है।
जेएसपी प्रत्येक मूलभूत घटक प्रकारों के लिए आरेख तत्वों के साथ इनपुट, आउटपुट और प्रोग्राम की संरचना का वर्णन करने के लिए एक आरेखण नोटेशन का उपयोग करता है।
एक साधारण ऑपरेशन को एक बॉक्स के रूप में तैयार किया गया है।
An operation
संचालन का एक क्रम लाइनों से जुड़े बक्सों द्वारा दर्शाया गया है। नीचे दिए गए उदाहरण में, ए एक अनुक्रम है जिसमें ऑपरेशन बी, सी और डी शामिल हैं।
A sequence
एक पुनरावृति को फिर से जुड़े हुए बक्सों के साथ दर्शाया गया है। इसके अलावा पुनरावृत्त ऑपरेशन में इसके बॉक्स के ऊपरी दाएं कोने में एक तारा होता है। नीचे दिए गए उदाहरण में, ए ऑपरेशन बी के शून्य या अधिक आमंत्रणों का पुनरावृत्ति पुनरावृत्ति है।
An iteration
चयन एक अनुक्रम के समान है, लेकिन प्रत्येक वैकल्पिक ऑपरेशन के ऊपरी दाएं कोने में एक वृत्त खींचा गया है। उदाहरण में, ए ऑपरेशन बी, सी या डी में से एक और केवल एक का चयन है।
A selection
ध्यान दें कि उपरोक्त आरेखों में, यह तत्व ए है जो अनुक्रम या पुनरावृत्ति है, न कि तत्व बी, सी या डी (जो उपर्युक्त आरेखों में सभी प्राथमिक हैं)। तत्व क्या है, यह निर्धारित करने के लिए जैक्सन 'लुक-डाउन नियम' देता है, यानी तत्व क्या है, यह जानने के लिए तत्व के नीचे के तत्वों को देखें।
एक काम किया उदाहरण
एक उदाहरण के रूप में, यहाँ बताया गया है कि कैसे एक JSP प्रोग्रामर एक रन-लेंथ एन्कोडिंग को डिज़ाइन और कोड करेगा। एक रन लेंथ एनकोडर एक प्रोग्राम है जिसका इनपुट बाइट्स की एक धारा है जिसे रन में घटित होने के रूप में देखा जा सकता है, जहां एक रन में समान मूल्य के बाइट्स की एक या अधिक घटनाएं होती हैं। कार्यक्रम का आउटपुट बाइट जोड़े की एक धारा है, जहां प्रत्येक बाइट जोड़ी एक रन का संकुचित विवरण है। प्रत्येक जोड़ी में, पहली बाइट एक रन में दोहराई गई बाइट का मान है और दूसरी बाइट एक संख्या है जो यह दर्शाती है कि रन में उस मान को कितनी बार दोहराया गया था। उदाहरण के लिए, इनपुट स्ट्रीम (AAAAAAAA) में अक्षर A की आठ घटनाओं का एक रन आउटपुट स्ट्रीम में A8 को बाइट जोड़ी के रूप में उत्पन्न करेगा। रन लेंथ एनकोडर का उपयोग अक्सर बिटमैप्स को गंभीर रूप से कंप्रेस करने के लिए किया जाता है।
जेएसपी के साथ, पहला कदम एक प्रोग्राम की इनपुट स्ट्रीम की डेटा संरचना का वर्णन करना है। कार्यक्रम में केवल एक इनपुट स्ट्रीम है, जिसमें समान बाइट मान के शून्य या अधिक रन शामिल हैं। यहाँ इनपुट स्ट्रीम के लिए JSP डेटा स्ट्रक्चर आरेख है।
दूसरा चरण आउटपुट डेटा संरचना का वर्णन करना है, जिसमें इस मामले में बाइट जोड़े के शून्य या अधिक पुनरावृत्तियों होते हैं।
अगला कदम इनपुट और आउटपुट संरचनाओं के घटकों के बीच पत्राचार का वर्णन करना है।
अगला कदम एक प्रोग्राम संरचना बनाने के लिए दो डेटा संरचनाओं के बीच पत्राचार का उपयोग करना है जो इनपुट डेटा संरचना को संसाधित करने और आउटपुट डेटा संरचना का उत्पादन करने में सक्षम है। (कभी-कभी यह संभव नहीं होता है। संरचना टकराव की चर्चा नीचे देखें।)
एक बार प्रोग्राम संरचना समाप्त हो जाने के बाद, प्रोग्रामर कम्प्यूटेशनल ऑपरेशंस की एक सूची बनाता है जिसे प्रोग्राम को निष्पादित करना चाहिए, और प्रोग्राम स्ट्रक्चर आरेख को उचित संरचनात्मक घटकों से उन परिचालनों को लटकाकर हटा दिया जाता है।
- एक बाइट पढ़ें
- बाइट याद रखें
- काउंटर को शून्य पर सेट करें
- इंक्रीमेंट काउंटर
- आउटपुट याद किया गया बाइट
- आउटपुट काउंटर
इसके अलावा, इस स्तर पर पुनरावृत्तियों (लूप्स) और चयन (यदि-फिर-अन्य या केस स्टेटमेंट) पर स्थितियां सूचीबद्ध हैं और प्रोग्राम संरचना आरेख में जोड़ दी गई हैं।
- जबकि बाइट्स अधिक हैं
- जबकि अधिक बाइट्स हैं और यह बाइट रन की पहली बाइट के समान है और गिनती अभी भी एक बाइट में फिट होगी
एक बार आरेख समाप्त हो जाने के बाद, इसका उपयोग किसी भी प्रोग्रामिंग भाषा में किया जा सकता है। यहाँ सी में एक अनुवाद है।
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
int c;
int first_byte;
int count;
c = getchar(); /* get first byte */
while (c != EOF) {
/* process the first byte in the run */
first_byte = c;
count = 1;
c = getchar(); /* get next byte */
/* process the succeeding bytes in the run */
while (c != EOF && c == first_byte && count < 255) {
/* process one byte of the same value */
count++;
c = getchar(); /* get next byte */
}
putchar(first_byte);
putchar(count);
}
return EXIT_SUCCESS;
}
कठिन डिजाइन समस्याओं से निपटने के लिए तकनीकें
प्रोग्राम डिज़ाइन के सिद्धांतों में जैक्सन ने उन स्थितियों को पहचाना जो विशिष्ट प्रकार की डिज़ाइन समस्याओं को उत्पन्न करती हैं, और उन्हें संभालने के लिए तकनीक प्रदान करती हैं।
इन स्थितियों में से एक ऐसा मामला है जिसमें एक प्रोग्राम एक के बजाय दो इनपुट फाइलों को प्रोसेस करता है। 1975 में, मानक दुष्ट समस्याओं में से एक यह थी कि लेन-देन-प्रसंस्करण कार्यक्रम कैसे डिज़ाइन किया जाए। इस तरह के एक प्रोग्राम में, अद्यतन रिकॉर्ड की एक अनुक्रमिक फ़ाइल एक अनुक्रमिक मास्टर फ़ाइल के विरुद्ध चलाई जाती है, जो एक अद्यतन मास्टर फ़ाइल को आउटपुट के रूप में प्रस्तुत करती है। (उदाहरण के लिए, रात में एक बैंक एक बैच प्रोग्राम चलाएगा जो उस दिन किए गए जमा और निकासी के रिकॉर्ड के आधार पर अपने ग्राहकों के खातों में शेष राशि को अपडेट करेगा।) प्रोग्राम डिज़ाइन के सिद्धांतों ने उस समस्या के लिए एक मानक समाधान प्रदान किया। , डिजाइन के पीछे के तर्क की व्याख्या के साथ।
एक अन्य प्रकार की समस्या शामिल थी जिसे जैक्सन ने पहचान की कठिनाइयाँ कहा था और आज हम पार्सिंग समस्याएँ कहेंगे। मूल JSP डिज़ाइन तकनीक को POSIT और QUIT संचालन द्वारा पूरक किया गया था ताकि डिज़ाइन की अनुमति दी जा सके जिसे हम अब बैकट्रैकिंग पार्सर कहेंगे।
JSP ने तीन स्थितियों को भी पहचाना जिन्हें स्ट्रक्चर क्लैश कहा जाता है - एक बाउंड्री क्लैश, एक ऑर्डरिंग क्लैश और एक इंटरलीविंग क्लैश- और उनसे निपटने के लिए तकनीक प्रदान की। संरचना संघर्ष स्थितियों में इनपुट और आउटपुट डेटा संरचनाएं इतनी असंगत होती हैं कि इनपुट फ़ाइल से आउटपुट फ़ाइल बनाना संभव नहीं होता है। वास्तव में, दो प्रोग्राम लिखने के लिए आवश्यक है- पहला इनपुट स्ट्रीम को प्रोसेस करता है, इसे छोटे-छोटे हिस्सों में तोड़ता है, और उन हिस्सों को एक इंटरमीडिएट फ़ाइल में लिखता है। दूसरा प्रोग्राम इंटरमीडिएट फ़ाइल पढ़ता है और वांछित आउटपुट उत्पन्न करता है।
जेएसपी और ऑब्जेक्ट-ओरिएंटेड डिज़ाइन
वस्तु-उन्मुख प्रौद्योगिकियां उपलब्ध होने से बहुत पहले JSP विकसित किया गया था। यह और इसके उत्तराधिकारी विधि जैक्सन प्रणाली के विकास का इलाज नहीं करते हैं जिसे अब वस्तुओं को अधिक या कम स्वतंत्र तरीकों के संग्रह के रूप में कहा जाएगा। इसके बजाय, सी ए आर होरे के काम का अनुसरण करते हुए, जेएसपी और जेएसडी सॉफ्टवेयर ऑब्जेक्ट्स को coroutine | सह-दिनचर्या के रूप में वर्णित करते हैं।[5][6]
यह भी देखें
- जैक्सन प्रणाली विकास
- वार्नियर/ओआरआर आरेख
संदर्भ
- ↑ 1.0 1.1 1.2 Jackson, MA (1975), Principles of Program Design, Academic.
- ↑ Jackson, MA (2001), JSP in Perspective (PDF), sd&m Pioneers’ Conference, Bonn, June 2001, retrieved 2017-01-26
{{citation}}: CS1 maint: location (link) CS1 maint: location missing publisher (link) - ↑ Warnier, JD (1974), Logical Construction of Programs, NY: Van Nostrand Reinhold
- ↑ Orr, KT (1980), "Structured programming in the 1980s", Proceedings of the ACM 1980 Annual Conference, New York, NY: ACM Press, pp. 323–26, doi:10.1145/800176.809987, ISBN 978-0897910286, S2CID 26834496
- ↑ Wieringa, R (Dec 1998), "A survey of structured and object-oriented software specification methods and techniques", Comput Surv, 30 (4): 459–527, CiteSeerX 10.1.1.107.5410, doi:10.1145/299917.299919, S2CID 14967319.
- ↑ Henderson-Sellers, Brian; Edwards, JM (Sep 1990), "The object-oriented systems life cycle", Communications of the ACM, 33 (9): 142–59, doi:10.1145/83880.84529, S2CID 14680399.
बाहरी संबंध
