การเขียนโปรแกรมเชิงโครงสร้างของแจ็คสัน ( JSP ) เป็นวิธีการเขียนโปรแกรมเชิงโครงสร้างที่พัฒนาโดยไมเคิล เอ. แจ็คสัน ที่ปรึกษาด้านซอฟต์แวร์ชาวอังกฤษ มีการอธิบายไว้ในหนังสือ Principles of Program Design ของเขาในปี 1975 ^{[ 1 ]}เทคนิคของ JSP คือการวิเคราะห์โครงสร้างข้อมูลของไฟล์ที่โปรแกรมต้องอ่านเป็นอินพุตและสร้างเป็นเอาต์พุต จากนั้นจึงสร้างการออกแบบโปรแกรมโดยอิงจากโครงสร้างข้อมูลเหล่านั้น เพื่อให้โครงสร้างควบคุมโปรแกรมจัดการโครงสร้างข้อมูลเหล่านั้นในลักษณะที่เป็นธรรมชาติและใช้งานง่าย

JSP อธิบายโครงสร้าง (ทั้งข้อมูลและโปรแกรม) โดยใช้โครงสร้างพื้นฐานสามอย่าง ได้แก่ ลำดับ การวนซ้ำ และการเลือก (หรือทางเลือกอื่น) โครงสร้างเหล่านี้จะถูกแสดงเป็นแผนภาพ (ในทางปฏิบัติ) ในรูปแบบการแสดงภาพของนิพจน์ ปกติ

Michael A. Jacksonพัฒนา JSP ขึ้นครั้งแรกในช่วงทศวรรษ 1970 เขาได้บันทึกระบบนี้ไว้ในหนังสือPrinciples of Program Design ในปี 1975 ^{[ 1 ]}ในการบรรยายในงานประชุมเมื่อปี 2001 ^{[ 2 ]}เขาได้วิเคราะห์ย้อนหลังถึงแรงผลักดันดั้งเดิมที่อยู่เบื้องหลังวิธีการนี้ และเชื่อมโยงกับ พัฒนาการ ด้านวิศวกรรมซอฟต์แวร์ ในเวลาต่อมา จุดมุ่งหมายของ Jackson คือการทำให้ โปรแกรมประมวลผล ไฟล์แบตช์COBOL ง่ายต่อการแก้ไขและบำรุงรักษา แต่สามารถใช้วิธีนี้ในการออกแบบโปรแกรมสำหรับภาษาโปรแกรม ใดๆ ก็ได้ ที่มีโครงสร้างควบคุม เช่น ลำดับ การวนซ้ำ และการเลือก ("if/then/else")

การเขียนโปรแกรมเชิงโครงสร้างของ Jackson คล้ายกับการเขียนโปรแกรมเชิงโครงสร้างของ Warnier/Orr ^{[ 3 ] [ 4 ]}แม้ว่า JSP จะพิจารณาทั้งโครงสร้างข้อมูลขาเข้าและขาออก ในขณะที่วิธีการของ Warnier/Orr เน้นเฉพาะโครงสร้างของสตรีมเอาต์พุตเป็นหลัก

ในขณะที่ JSP ถูกพัฒนาขึ้น โปรแกรมส่วนใหญ่เป็นโปรแกรม COBOL แบบแบตช์ที่ประมวลผลไฟล์ลำดับที่จัดเก็บไว้บนเทป โปรแกรมทั่วไปจะอ่านไฟล์อินพุตเป็นลำดับของเรคอร์ด ดังนั้นโปรแกรมทั้งหมดจึงมีโครงสร้างเดียวกัน คือลูปหลักเดียวที่ประมวลผลเรคอร์ดทั้งหมดในไฟล์ทีละรายการ แจ็กสันยืนยันว่าโครงสร้างโปรแกรมนี้มักจะผิดเสมอ และสนับสนุนให้โปรแกรมเมอร์มองหาโครงสร้างข้อมูลที่ซับซ้อนกว่า ในบทที่ 3 ของPrinciples of Program Design ^{[ 1 ]}แจ็กสันนำเสนอโปรแกรมสองเวอร์ชัน เวอร์ชันหนึ่งออกแบบโดยใช้ JSP อีกเวอร์ชันหนึ่งใช้โครงสร้างลูปเดียวแบบดั้งเดิม นี่คือตัวอย่างของเขาที่แปลจาก COBOL เป็น Java จุดประสงค์ของโปรแกรมทั้งสองนี้คือการจดจำกลุ่มของเรคอร์ด (บรรทัด) ที่ซ้ำกันในไฟล์ที่เรียงลำดับแล้ว และสร้างไฟล์เอาต์พุตที่แสดงรายการเรคอร์ดแต่ละรายการและจำนวนครั้งที่ปรากฏในไฟล์

นี่คือโปรแกรมเวอร์ชันดั้งเดิมที่มีลูปเดียว

สตริงline = null ; จำนวนนับ= 0 ; สตริงfirstLineOfGroup = null ;​// เริ่มลูปหลักเดี่ยวในขณะที่( line = in.readLine ( ) ) != null ) { ถ้า( firstLineOfGroup == null หรือ! line.equals ( firstLineOfGroup ) ) { ถ้า( firstLineOfGroup != null ) { System.out.printf ( " % s %d % n " , firstLineOfGroup , count ); } count = 0 ; firstLineOfGroup = line ; } count ++ ; } ถ้า( firstLineOfGroup != null ) { System.out.printf ( "%s %d % n " , firstLineOfGroup , count ) ; }

นี่คือโปรแกรมเวอร์ชัน JSP ที่มีลักษณะเดียวกัน โปรดสังเกตว่า (แตกต่างจากโปรแกรมแบบดั้งเดิม) โปรแกรมนี้มีลูปสองลูป โดยลูปหนึ่งซ้อนอยู่ภายในอีกลูปหนึ่ง ลูปภายนอกประมวลผลกลุ่มของเรคอร์ดที่ซ้ำกัน ในขณะที่ลูปภายในประมวลผลเรคอร์ดแต่ละรายการในกลุ่ม

จำนวนบรรทัดใน กลุ่ม = 0 ;String line = in.readLine ( ) ; // เริ่มลูปภายนอก: ประมวลผล 1 กลุ่มในขณะที่line ไม่เป็นnull { numberOfLinesInGroup = 0 ; String firstLineOfGroup = line ;// เริ่มลูปภายใน: ประมวลผล 1 เรคอร์ดในกลุ่มขณะที่( บรรทัด!= null และบรรทัด. เท่ากับ( บรรทัดแรกของกลุ่ม)) { จำนวนบรรทัดในกลุ่มเพิ่มขึ้น; บรรทัด= in . readLine (); } System . out . printf ( "%s %d%n" , บรรทัดแรกของกลุ่ม, จำนวน); }

แจ็กสันวิจารณ์เวอร์ชันแบบวนลูปเดี่ยวแบบดั้งเดิมว่าไม่สามารถประมวลผลโครงสร้างของไฟล์อินพุต (ลำดับของกลุ่มที่มีระเบียนซ้ำกัน) ได้อย่างเป็นธรรมชาติ หนึ่งในข้อบ่งชี้ของการออกแบบที่ไม่เป็นธรรมชาติคือ เพื่อให้ทำงานได้อย่างถูกต้อง จำเป็นต้องมีโค้ดพิเศษสำหรับจัดการระเบียนแรกและระเบียนสุดท้ายของไฟล์

JSP ใช้ขั้นตอนกึ่งทางการเพื่อบันทึกโครงสร้างที่มีอยู่ของอินพุตและเอาต์พุตของโปรแกรมลงในโครงสร้างของโปรแกรมเอง

จุดประสงค์คือการสร้างโปรแกรมที่แก้ไขได้ง่ายตลอดอายุการใช้งาน แนวคิดสำคัญของแจ็กสันคือ การเปลี่ยนแปลงข้อกำหนดมักเป็นการปรับเปลี่ยนโครงสร้างที่มีอยู่เพียงเล็กน้อย สำหรับโปรแกรมที่สร้างโดยใช้ JSP อินพุต เอาต์พุต และโครงสร้างภายในของโปรแกรมจะตรงกัน ดังนั้นการเปลี่ยนแปลงเล็กน้อยในอินพุตและเอาต์พุตจึงควรส่งผลให้การเปลี่ยนแปลงในโปรแกรมมีขนาดเล็กเช่นกัน

JSP จัดโครงสร้างโปรแกรมโดยแบ่งออกเป็น 4 ประเภทส่วนประกอบ:

• การดำเนินงานพื้นฐาน
• ลำดับ
• การวนซ้ำ
• การเลือก

วิธีการนี้เริ่มต้นด้วยการอธิบายอินพุตของโปรแกรมในแง่ของส่วนประกอบพื้นฐานสี่ประเภท จากนั้นจึงอธิบายเอาต์พุตของโปรแกรมในลักษณะเดียวกัน โดยแต่ละอินพุตและเอาต์พุตจะถูกจำลองเป็นแผนภาพโครงสร้างข้อมูล (DSD) แยกกัน เพื่อให้ JSP สามารถใช้งานได้กับแอปพลิเคชันที่ต้องการการประมวลผลสูง เช่นการประมวลผลสัญญาณดิจิทัล (DSP) จำเป็นต้องวาดแผนภาพโครงสร้างอัลกอริทึมด้วย ซึ่งเน้นที่โครงสร้างข้อมูลภายในมากกว่าโครงสร้างอินพุตและเอาต์พุต

จากนั้นโครงสร้างอินพุตและเอาต์พุตจะถูกรวมหรือผสานเข้าด้วยกันเป็นโครงสร้างโปรแกรมสุดท้าย ซึ่งเรียกว่าแผนภาพโครงสร้างโปรแกรม (Program Structure Diagram หรือ PSD) ขั้นตอนนี้อาจเกี่ยวข้องกับการเพิ่มโครงสร้างควบคุมระดับสูงเล็กน้อยเพื่อเชื่อมโยงอินพุตและเอาต์พุตเข้าด้วยกัน โปรแกรมบางโปรแกรมประมวลผลอินพุตทั้งหมดก่อนที่จะแสดงผลลัพธ์ใดๆ ในขณะที่โปรแกรมอื่นๆ อ่านข้อมูลหนึ่งระเบียน เขียนข้อมูลหนึ่งระเบียน และทำซ้ำ วิธีการเหล่านี้จะต้องถูกบันทึกไว้ใน PSD ด้วย

PSD ซึ่งเป็นโครงสร้างที่ไม่ขึ้นกับภาษาใดภาษาหนึ่ง จะถูกนำไปใช้ในภาษาโปรแกรม JSP มุ่งเน้นไปที่การเขียนโปรแกรมในระดับโครงสร้างควบคุม ดังนั้นการออกแบบที่นำไปใช้จึงใช้เพียงการดำเนินการพื้นฐาน ลำดับ การวนซ้ำ และการเลือกเท่านั้น JSP ไม่ได้ใช้ในการจัดโครงสร้างโปรแกรมในระดับคลาสและอ็อบเจ็กต์ แม้ว่าจะสามารถจัดโครงสร้างการไหลของโปรแกรมภายในเมธอดของคลาส ได้อย่างมีประโยชน์ก็ตาม

JSP ใช้สัญลักษณ์แผนภาพเพื่ออธิบายโครงสร้างของอินพุต เอาต์พุต และโปรแกรม โดยมีองค์ประกอบแผนภาพสำหรับส่วนประกอบพื้นฐานแต่ละประเภท

การดำเนินการอย่างง่ายถูกวาดเป็นกรอบสี่เหลี่ยม

การดำเนินการ

ลำดับของการดำเนินการจะแสดงด้วยกล่องที่เชื่อมต่อกันด้วยเส้น ในตัวอย่างด้านล่าง A คือลำดับที่ประกอบด้วยการดำเนินการ B, C และ D

ลำดับ

การวนซ้ำจะแสดงด้วยกล่องที่เชื่อมต่อกัน นอกจากนี้ การดำเนินการที่วนซ้ำจะมีเครื่องหมายดาวอยู่ที่มุมบนขวาของกล่อง ในตัวอย่างด้านล่าง A คือการวนซ้ำของการเรียกใช้การดำเนินการ B ตั้งแต่ศูนย์ครั้งขึ้นไป

การวนซ้ำ

การเลือกนั้นคล้ายกับลำดับ แต่จะมีวงกลมวาดอยู่ที่มุมบนขวาของแต่ละการดำเนินการที่เป็นตัวเลือก ในตัวอย่างนี้ A คือการเลือกการดำเนินการเพียงหนึ่งเดียวจาก B, C หรือ D

การคัดเลือก

โปรดสังเกตว่าในแผนภาพข้างต้น องค์ประกอบ A คือลำดับหรือการวนซ้ำ ไม่ใช่องค์ประกอบ B, C หรือ D (ซึ่งในแผนภาพข้างต้นล้วนเป็นองค์ประกอบพื้นฐาน) แจ็กสันได้เสนอ 'กฎการดูลง' เพื่อกำหนดว่าองค์ประกอบนั้นคืออะไร กล่าวคือ ให้ดูที่องค์ประกอบที่อยู่ต่ำกว่าองค์ประกอบนั้นเพื่อหาว่ามันคืออะไร

ตัวอย่างเช่น นี่คือวิธีที่โปรแกรมเมอร์ JSP จะออกแบบและเขียนโค้ดตัวเข้ารหัสความยาวลำดับ (Run Length Encoder) ตัวเข้ารหัสความยาวลำดับเป็นโปรแกรมที่มีอินพุตเป็นสตรีมของไบต์ ซึ่งสามารถมองได้ว่าเกิดขึ้นเป็นลำดับโดยที่ลำดับประกอบด้วยไบต์ที่มีค่าเดียวกันตั้งแต่หนึ่งตัวขึ้นไป เอาต์พุตของโปรแกรมคือสตรีมของคู่ไบต์ โดยที่คู่ไบต์แต่ละคู่เป็นคำอธิบายที่ถูกบีบอัดของลำดับ ในแต่ละคู่ ไบต์แรกคือค่าของไบต์ที่ซ้ำกันในลำดับ และไบต์ที่สองคือตัวเลขที่ระบุจำนวนครั้งที่ค่านั้นซ้ำกันในลำดับ ตัวอย่างเช่น ลำดับของตัวอักษร "A" แปดครั้งในสตรีมอินพุต ("AAAAAAAA") จะสร้าง "A8" เป็นคู่ไบต์ในสตรีมเอาต์พุต ตัวเข้ารหัสความยาวลำดับมักใช้สำหรับการบีบอัดบิตแมปอย่างคร่าวๆ

ใน JSP ขั้นตอนแรกคือการอธิบายโครงสร้างข้อมูลของสตรีมอินพุตของโปรแกรม โปรแกรมมีสตรีมอินพุตเพียงสตรีมเดียว ซึ่งประกอบด้วยค่าไบต์เดียวกันตั้งแต่ศูนย์ชุดขึ้นไปนี่คือแผนภาพโครงสร้างข้อมูล JSP สำหรับสตรีมอินพุต

ขั้นตอนที่สองคือการอธิบายโครงสร้างข้อมูลเอาต์พุต ซึ่งในกรณีนี้ประกอบด้วยการวนซ้ำของคู่ไบต์ศูนย์ครั้งหรือมากกว่านั้น

ขั้นตอนต่อไปคือการอธิบายความสัมพันธ์ระหว่างส่วนประกอบของโครงสร้างอินพุตและเอาต์พุต

ขั้นตอนต่อไปคือการใช้ความสัมพันธ์ระหว่างโครงสร้างข้อมูลทั้งสองเพื่อสร้างโครงสร้างโปรแกรมที่สามารถประมวลผลโครงสร้างข้อมูลขาเข้าและสร้างโครงสร้างข้อมูลขาออกได้ (บางครั้งอาจทำไม่ได้ โปรดดูการอธิบายเรื่องความขัดแย้งของโครงสร้างด้านล่าง)

เมื่อโครงสร้างโปรแกรมเสร็จสมบูรณ์แล้ว โปรแกรมเมอร์จะสร้างรายการของการดำเนินการคำนวณที่โปรแกรมต้องดำเนินการ และเติมรายละเอียดลงในแผนภาพโครงสร้างโปรแกรมโดยการเชื่อมโยงการดำเนินการเหล่านั้นเข้ากับส่วนประกอบโครงสร้างที่เหมาะสม

1. อ่านไบต์
2. จดจำไบต์
3. ตั้งค่าตัวนับเป็นศูนย์
4. ตัวนับเพิ่ม
5. ไบต์ที่จดจำเอาต์พุต
6. ตัวนับเอาต์พุต

นอกจากนี้ ในขั้นตอนนี้ เงื่อนไขในการวนซ้ำ (ลูป) และการเลือก (คำสั่ง if-then-else หรือ case) จะถูกระบุและเพิ่มลงในแผนภาพโครงสร้างโปรแกรมด้วย

1. ในขณะที่มีจำนวนไบต์มากขึ้น
2. ถึงแม้จะมีไบต์มากกว่า และไบต์นี้เหมือนกับไบต์แรกของการทำงาน และจำนวนนับก็ยังคงอยู่ในไบต์เดียว

เมื่อวาดแผนภาพเสร็จแล้ว ก็สามารถแปลงเป็นภาษาโปรแกรมใดก็ได้ที่ใช้งานอยู่ ต่อไปนี้คือตัวอย่างการแปลงเป็นภาษาซี

#include <stdio.h> #include <stdlib.h>int main ( int argc , char * argv []) { char first_byte ; int count = 0 ;char c = getchar (); // รับไบต์แรกในขณะที่c ! = EOF { // ประมวลผลไบต์แรกในรอบการทำงานfirst_byte = c ; count = 1 ; c = getchar (); // รับไบต์ถัดไป// ประมวลผลไบต์ถัดไปในระหว่างการทำงาน ในขณะที่( c != EOF && c == first_byte && count < 255 ) { // ประมวลผลไบต์ที่มีค่าเดียวกันหนึ่งไบต์count ++ ; c = getchar (); // รับไบต์ถัดไป}putchar ( first_byte ); putchar ( count ); } return EXIT_SUCCESS ; }

ในหนังสือ Principles of Program Designแจ็กสันได้ระบุสถานการณ์ที่ก่อให้เกิดปัญหาด้านการออกแบบเฉพาะประเภท และได้เสนอเทคนิคในการจัดการกับปัญหาเหล่านั้น

หนึ่งในสถานการณ์เหล่านี้คือกรณีที่โปรแกรมประมวลผลไฟล์อินพุตสองไฟล์ แทนที่จะเป็นไฟล์เดียว ในปี 1975 หนึ่งใน "ปัญหาที่ซับซ้อน" มาตรฐานคือวิธีการออกแบบโปรแกรมประมวลผลธุรกรรม ในโปรแกรมดังกล่าว ไฟล์ลำดับของบันทึกการอัปเดตจะถูกเรียกใช้กับไฟล์หลักลำดับ โดยสร้างไฟล์หลักที่ได้รับการอัปเดตเป็นเอาต์พุต (ตัวอย่างเช่น ในเวลากลางคืน ธนาคารจะเรียกใช้โปรแกรมแบบแบตช์เพื่ออัปเดตยอดคงเหลือในบัญชีของลูกค้าโดยอิงจากบันทึกการฝากและถอนที่พวกเขาทำในวันนั้น) หลักการออกแบบโปรแกรมได้ให้วิธีแก้ปัญหามาตรฐานสำหรับปัญหานี้ พร้อมกับคำอธิบายตรรกะเบื้องหลังการออกแบบ

ปัญหาอีกประเภทหนึ่งที่แจ็กสันเรียกว่า "ความยากลำบากในการจดจำ" ซึ่งในปัจจุบันเราเรียกว่า ปัญหาการแยก วิเคราะห์ (parsing problems) เทคนิคการออกแบบ JSP พื้นฐานได้รับการเสริมด้วยการดำเนินการ POSIT และ QUIT เพื่อให้สามารถออกแบบสิ่งที่เราเรียกว่าตัวแยกวิเคราะห์แบบย้อนกลับ (backtracking parser) ได้

JSP ยังรับรู้ถึงสถานการณ์สามอย่างที่เรียกว่า "ความขัดแย้งทางโครงสร้าง" ได้แก่ ความขัดแย้งที่ขอบเขต ความขัดแย้งที่ลำดับ และความขัดแย้งที่การสลับข้อมูล และได้จัดเตรียมเทคนิคในการจัดการกับสถานการณ์เหล่านั้น ในสถานการณ์ความขัดแย้งทางโครงสร้าง โครงสร้างข้อมูลอินพุตและเอาต์พุตไม่เข้ากันจนไม่สามารถสร้างไฟล์เอาต์พุตจากไฟล์อินพุตได้ ในทางปฏิบัติ จำเป็นต้องเขียนโปรแกรมสองโปรแกรม โปรแกรมแรกประมวลผลสตรีมอินพุต แบ่งออกเป็นส่วนย่อยๆ และเขียนส่วนย่อยเหล่านั้นลงในไฟล์ชั่วคราว โปรแกรมที่สองอ่านไฟล์ชั่วคราวและสร้างเอาต์พุตที่ต้องการ

JSP ได้รับการพัฒนามานานก่อนที่เทคโนโลยีเชิงวัตถุจะพร้อมใช้งาน ทั้ง JSP และ JSD ซึ่งเป็นวิธีการต่อมา ไม่ได้มองสิ่งที่ปัจจุบันเรียกว่า "วัตถุ" ว่าเป็นชุดของเมธอดที่ค่อนข้างเป็นอิสระ แต่ JSP และ JSD กลับอธิบายวัตถุซอฟต์แวร์ว่าเป็นโครูทีนโดยอ้างอิงจากงานของCAR Hoare ^{[ 5 ] [ 6 ]}

• การพัฒนาระบบแจ็กสัน
• แผนภาพวอร์เนียร์/ออร์

วิกิมีเดียคอมมอนส์มีสื่อที่เกี่ยวข้องกับการเขียนโปรแกรมเชิงโครงสร้างแบบแจ็คสัน (Jackson Structured Programming )

• โปรแกรมแก้ไข JSP แบบกราฟิกฟรีที่เขียนด้วยภาษา Java
• ตัวแก้ไข JSP
• ประวัติโดยย่อของวิธีการของแจ็คสัน
• เว็บไซต์ Jackson Workbench