ออกแบบซอฟต์แวร์ด้วยการหลอก?

คุณรู้วิธีที่ดีในการออกแบบซอฟต์แวร์ (เช่นเขียนลง) ด้วยวิธีการตามหลอกรหัสหรือไม่?

ฉันยังใหม่กับการออกแบบซอฟต์แวร์และอ่านข้อมูลเกี่ยวกับ UML ลำดับชั้นชั้นต่ำต้อยของฉันนั้นดีอย่างไรก็ตามหลังจากมันซับซ้อนฉันสังเกตว่าด้วยภาพ "เห็นภาพทั้งหมด" ฉันสามารถใช้โครงสร้างที่แตกต่างเพื่อความยืดหยุ่นในอนาคตที่มากขึ้น เนื่องจาก Python นั้นดีในการสร้างต้นแบบฉันเกือบจะดีที่เพิ่งเริ่มเขียน แต่ก็ไม่มากนัก

ดังนั้นฉันจึงลองไดอะแกรมคลาส UML แต่พวกเขาดูเหมือนจะไม่ช่วยฉันมากนัก ปัญหาที่ฉันแก้ไขที่นั่นฉันสามารถทำในหัวของฉัน แต่ฉันสังเกตเห็นความต้องการการออกแบบเพิ่มเติมเมื่อฉันเริ่ม pseudocode วิธีการที่เกิดขึ้นจริง

ดังนั้นหากคุณต้องการออกแบบโดย pseudocode คุณจะทำอย่างไร ฉันเชื่อว่าฉันเป็นวิธีที่ประมาณ 1 ต่อ 1 กับรหัสทำงานได้ดีที่สุด แต่ซอฟต์แวร์ UML ส่วนใหญ่ไม่ได้แสดงรหัสของวิธีการ (ตรงข้ามกับรูปภาพในเช่น GoF)

มีคนอ้างว่า UML สำหรับเอกสารและการนำเสนอเท่านั้นและไม่เหมาะสำหรับการออกแบบ? ฉันก็รู้สึกเช่นนั้น ฉันคิดว่า UML บริสุทธิ์และกระดานไวท์บอร์ดแบบง่าย ๆ เป็นวิธีการออกแบบซอฟต์แวร์จนกระทั่ง googling ฉันพบ Envision APDT

ดังนั้นการพัฒนาความคล่องตัวเป็นสิ่งที่ฉันควรระวังหรือพวกเขาสุ่มเรียกว่าเปรียว - ฉันคิดว่าเปรียวเป็นเรื่องเกี่ยวกับตารางเท่านั้นหรือไม่ หรือฉันกำลังออกแบบอย่างไม่ถูกต้อง (ด้วย UML) - ไม่มีใครออกแบบโดย pseudocode หรือไม่? ฉันจะหาเครื่องมือที่ดีสำหรับสิ่งนั้นได้อย่างไร

 I thought agile is about schedule only?

มันไม่ได้เป็นเพียงการวางแผน การพัฒนาซอฟต์แวร์ Agile นั้นเกี่ยวกับการพัฒนาเชิงวิวัฒนาการและการส่งมอบแบบวนซ้ำตามกำหนดเวลาด้วยการวางแผนแบบปรับตัวซึ่งกระตุ้นการตอบสนองที่ยืดหยุ่นต่อการเปลี่ยนแปลงที่ร้องขอโดยเจ้าของผลิตภัณฑ์

 Or am I designing incorrectly (with UML) - does anyone design by pseudocode? 

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

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

มีทางเลือกอื่น ๆ ที่คุณอาจมีลักษณะ:

• ไดอะแกรมการไหลของข้อมูล
• แผนภาพสถานะ
• แผนภูมิผังกระบวนการ

ลำดับที่ดีที่จะมอง: ซอฟแวร์การออกแบบการสอน นอกจากนี้ฉันเองจะแนะนำให้อ่านบล็อกที่ดีในPseudocode หรือ Code? โพสต์โดย Coding Horror - บล็อกโปรดอ่าน :)

สรุปมีข้อเสียบางอย่างที่คุณต้องพิจารณา

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

วันนี้เราทำการเขียนโปรแกรมน้อยมากในภาษาแอสเซมบลีและฉันเห็นค่าเล็กน้อยในการเขียนโค้ดหลอกแทนที่จะเป็นแค่การเขียนโค้ด ในภาษาที่ดีรหัสจริงจะเป็นไปตามหลอกรหัสเกือบคำต่อคำและหลอกรหัสเป็นเพียงเสียเวลา

อย่างไรก็ตามฉันไม่เริ่มเขียนโค้ดที่ด้านล่าง ฉันติดตาม TDD และเริ่มด้วยการทดสอบ จากนั้นฉันก็เริ่มเขียนโค้ดที่ด้านบนและค่อยๆลงไปที่ด้านล่างตามต้องการเพื่อให้การทดสอบผ่านไป

ทางเลือกอื่นในการหลอกรหัสไม่ได้เขียน 1,000 บรรทัดของชั้นเรียนระดับต่ำ แทนที่จะเริ่มที่ด้านบนให้เรียก API ที่ดีที่สุด แต่ไม่มีอยู่จริงสำหรับโดเมนของคุณ จากนั้นสร้าง API

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

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

ฉันคิดว่าเครื่องมือกราฟิกนั้นดีกว่าการปลอมแปลงรหัส แต่ UML นั้นซับซ้อนมากจนทำให้มันรวมสิ่งที่ไม่ดีในวิธีการเหล่านั้น :-)

เพื่อความชัดเจนมากขึ้น: ฉันคิดว่าการเขียนโปรแกรมส่วนใหญ่เป็นวิธีการวิเคราะห์ปัญหาบางอย่างโดยแยกมันออกเป็นองค์ประกอบที่เล็กลงและการโต้ตอบของพวกเขา นี่คือ "การเดินทางไม่ใช่ปลายทาง" คุณพัฒนาความรู้ของคุณอย่างต่อเนื่องเกี่ยวกับปัญหาดังนั้นกราฟขององค์ประกอบที่มีการเปลี่ยนแปลง: เลเยอร์ปรากฏและจางหายไปฟังก์ชั่นและรายการข้อมูลเลื่อนขึ้นและลง ฯลฯ

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

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

แต่นี่อาจเป็นเพราะฉันได้เขียนรหัสที่ถูกโยนออกไปทั้งหมดดังนั้นฉันไม่ต้องเขียนมันตอนนี้ประสบการณ์ที่ฉันได้รับจากพวกมันอยู่กับฉันเมื่อออกแบบระบบ? ฉันต้องแก้ไขข้อความนี้ด้วย

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