The prototyping paradigm (Figure 2.

The prototyping paradigm (Figure 2.5) begins with requirements gathering. Developer and customer meet and define the overall objectives for the software, identify whatever requirements are known, and outline areas where further definition is mandatory. A "quick design" then occurs. The quick design focuses on a representation of those aspects of the software that will be visible to the customer/user (e.g., input approaches and output formats). The quick design leads to the construction of a prototype. The prototype is evaluated by the customer/user and used to refine requirements for the software to be developed. Iteration occurs as the prototype is tuned to satisfy the needs of the customer, while at the same time enabling the developer to better understand what needs to be done.
Ideally, the prototype serves as a mechanism for identifying software requirements. If a working prototype is built, the developer attempts to use existing program fragments or applies tools (e.g., report generators, window managers) that enable working programs to be generated quickly. But what do we do with the prototype when it has served the purpose just described? Brooks [BRO75] provides an answer:
In most projects, the first system built is barely usable. It may be too slow, too big, and awkward in use or all three. There is no alternative but to start again, smarting but smarter, and build a redesigned version in which these problems are solved . . . When a new system concept or new technology is used, one has to build a system to throw away, for even the best planning is not so omniscient as to get it right the first time. The management question, therefore, is not whether to build a pilot system and throw it away. You will do that. The only question is whether to plan in advance to build a throwaway, or to promise to deliver the throwaway to customers . . .
The prototype can serve as "the first system." The one that Brooks recommends we throw away. But this may be an idealized view. It is true that both customers and developers like the prototyping paradigm. Users get a feel for the actual system and developers get to build something immediately. Yet, prototyping can also be problematic for the following reasons:
1. The customer sees what appears to be a working version of the software, unaware that the prototype is held together “with chewing gum and baling wire,” unaware that in the rush to get it working no one has considered overall software quality or long-term maintainability. When informed that the product must be rebuilt so that high levels of quality can be maintained, the customer cries foul and demands that "a few fixes" be applied to make the prototype a working product. Too often, software development management relents.
2. The developer often makes implementation compromises in order to get a prototype working quickly. An inappropriate operating system or programming language may be used simply because it is available and known; an inefficient algorithm may be implemented simply to demonstrate capability. After a time, the developer may become familiar with these choices and forget all the reasons why they were inappropriate. The less-than-ideal choice has now become an integral part of the system.
Although problems can occur, prototyping can be an effective paradigm for software engineering. The key is to define the rules of the game at the beginning; that is, the customer and developer must both agree that the prototype is built to serve as a mechanism for defining requirements. It is then discarded (at least in part) and the actual software is engineered with an eye toward quality and maintainability.

ผลลัพธ์ (ไทย) 1:

กระบวนทัศน์ต้นแบบ (รูปที่ 2.5) เริ่มต้น ด้วยความต้องการรวบรวม ผู้พัฒนาและลูกค้าตอบสนอง และกำหนดวัตถุประสงค์โดยรวมสำหรับซอฟต์แวร์ ระบุความต้องการสิ่งรู้จักกัน และเค้าร่างพื้นที่ที่กำหนดเพิ่มเติมเป็นข้อบังคับ "ด่วนแบบ" เกิดขึ้นแล้ว การออกแบบรวดเร็วเน้นการแสดงเหล่านั้นด้านซอฟต์แวร์ที่จะเห็นลูกค้า/ผู้ใช้ (เช่น ป้อนวิธี และรูปแบบการแสดงผล) แบบรวดเร็วนำไปสู่การสร้างต้นแบบ ต้นแบบการประเมิน โดยลูกค้า/ผู้ใช้ และใช้เพื่อกำหนดความต้องการเพื่อให้สามารถพัฒนาซอฟต์แวร์ เกิดซ้ำเกิดขึ้นเป็นต้นแบบจะปรับเพื่อตอบสนองความต้องการของลูกค้า ที่ช่วยให้นักพัฒนาสามารถเข้าใจอะไรต้องทำกันดาว ต้นแบบทำหน้าที่เป็นกลไกในการระบุข้อกำหนดซอฟต์แวร์ ถ้าสร้างต้นแบบการทำงาน ผู้พัฒนาพยายามที่จะใช้แยกส่วนของโปรแกรมที่มีอยู่ หรือใช้เครื่องมือ (เช่น รายงานเครื่องกำเนิดไฟฟ้า ผู้จัดการหน้าต่าง) ที่เปิดทำงานโปรแกรมจะสร้างได้อย่างรวดเร็ว แต่เราทำอะไรกับต้นแบบเมื่อมันได้ทำหน้าที่เพียงอธิบายวัตถุประสงค์ บรู๊คส์ [BRO75] แสดงคำตอบ:ในโครงการใหญ่ ระบบแรกที่สร้างคือแทบไม่ได้ มันอาจจะช้าเกินไป มากเกินไป และไม่สะดวกในการใช้ทั้งหมด 3 ไม่มีทางเลือกแต่เริ่มอีก smarting แต่ฉลาด การสร้างเวอร์ชันใหม่ที่มีแก้ไขปัญหาเหล่านี้อยู่ เมื่อแนวคิดระบบใหม่หรือเทคโนโลยีใหม่ที่จะใช้ หนึ่งได้สร้างระบบการโยน แม้สุดวางแผนว่าไม่ดัง omniscient เป็นได้รับมันขวาครั้งแรก คำถามการจัดการ ดังนั้น ไม่ได้ว่าจะสร้างระบบนำร่อง และโยนมันทิ้ง คุณจะทำเช่นนั้น คำถามเดียวคือว่าวางแผนล่วงหน้าสร้าง throwaway การ หรือจะส่ง throwaway ที่ให้...ต้นแบบสามารถทำหน้าที่เป็น "ตัวแรกระบบ" หนึ่งบรู๊คส์ที่แนะนำให้เราทิ้ง แต่อาจดูที่ idealized มันเป็นความจริงว่า ทั้งลูกค้าและนักพัฒนาเช่นกระบวนทัศน์ต้นแบบ ผู้ใช้รับความรู้สึกระบบจริง และพัฒนาไปสร้างบางสิ่งบางอย่างทันที ยัง ต้นแบบสามารถเป็นปัญหาสำหรับเหตุผลต่อไปนี้:1. ลูกค้าเห็นสิ่งที่ดูเหมือนจะ เป็นรุ่นทำงานของซอฟแวร์ ไม่รู้ว่า ต้นแบบที่จัดเก็บร่วมกัน "หมากฝรั่งและสายบาลิง ไม่รู้ว่า วิ่งเข้าทำงานไม่มีพิจารณาคุณภาพซอฟต์แวร์โดยรวมหรือ maintainability ระยะยาว เมื่อทราบว่า ต้องสร้างผลิตภัณฑ์เพื่อให้สามารถรักษาระดับคุณภาพสูง ลูกค้าทุกคนได้ยิน foul และต้องว่า "ไม่แก้ไข" สามารถใช้ทำต้นแบบผลิตภัณฑ์ทำงาน บ่อยเกินไป การพัฒนาโครงการซอฟต์แวร์ relents2. นักพัฒนามักทำรับงานเพื่อให้ได้ต้นแบบการทำงานได้อย่างรวดเร็ว เป็นระบบปฏิบัติการไม่เหมาะสมหรือภาษาโปรแกรมอาจใช้เพียง เพราะว่าง และ รู้จัก อัลกอริทึมไม่อาจนำมาใช้ได้เพียงแค่แสดงให้เห็นถึงความสามารถในการ หลังจากเวลา นักพัฒนาอาจคุ้นเคยกับตัวเลือกเหล่านี้ และลืมเหตุผลทำไมพวกเขาไม่เหมาะสม ตัวเลือกน้อยกว่าเหมาะมีตอนนี้กลายเป็น เป็นส่วนหนึ่งของระบบแม้ว่าปัญหาที่เกิดขึ้น ต้นแบบสามารถเป็นกระบวนทัศน์มีประสิทธิภาพสำหรับวิศวกรรมซอฟต์แวร์ สำคัญคือการ กำหนดกฎของเกมที่ต้น คือ ลูกค้าและผู้พัฒนาต้องทั้งยอมรับว่า ต้นแบบถูกสร้างขึ้นเพื่อเป็นกลไกในการกำหนดความต้องการ มันจะถูกยกเลิกแล้ว (น้อยบางส่วน) และซอฟต์แวร์จริงจะได้วางแผนกับตาต่อคุณภาพและ maintainability การ

ผลลัพธ์ (ไทย) 2:

กระบวนทัศน์การสร้างต้นแบบ (รูปที่ 2.5) เริ่มต้นด้วยการรวบรวมความต้องการ พัฒนาและตอบสนองลูกค้าและกำหนดวัตถุประสงค์โดยรวมสำหรับซอฟแวร์ที่ระบุความต้องการสิ่งที่เป็นที่รู้จักและร่างพื้นที่ที่มีความหมายต่อการมีผลบังคับใช้ "การออกแบบได้อย่างรวดเร็ว" นั้นเกิดขึ้น การออกแบบได้อย่างรวดเร็วมุ่งเน้นไปที่การเป็นตัวแทนของด้านที่ของซอฟต์แวร์ที่จะสามารถมองเห็นให้กับลูกค้า / ผู้ใช้ (เช่นวิธีการป้อนข้อมูลและรูปแบบการออก) การออกแบบได้อย่างรวดเร็วนำไปสู่การก่อสร้างต้นแบบ ต้นแบบได้รับการประเมินโดยผู้ใช้ลูกค้า / และใช้ในการปรับแต่งความต้องการสำหรับซอฟต์แวร์ที่ได้รับการพัฒนา ซ้ำเกิดขึ้นเป็นเครื่องต้นแบบที่มีการปรับเพื่อตอบสนองความต้องการของลูกค้าในขณะที่ในเวลาเดียวกันช่วยให้นักพัฒนาที่จะเข้าใจในสิ่งที่ดีกว่าที่ต้องทำ.
จะเป็นการดีต้นแบบทำหน้าที่เป็นกลไกในการระบุความต้องการซอฟต์แวร์ ถ้าต้นแบบการทำงานที่ถูกสร้างขึ้นนักพัฒนาพยายามที่จะใช้ชิ้นส่วนโปรแกรมที่มีอยู่หรือใช้เครื่องมือ (เช่นเครื่องกำเนิดไฟฟ้ารายงานผู้จัดการหน้าต่าง) ที่ช่วยให้โครงการการทำงานที่จะสร้างได้อย่างรวดเร็ว แต่สิ่งที่เราจะทำกับต้นแบบเมื่อมันได้ทำหน้าที่วัตถุประสงค์ที่อธิบายเพียง? บรูคส์ [BRO75] ให้คำตอบ:
ในโครงการส่วนใหญ่ระบบแรกที่สร้างขึ้นแทบจะไม่สามารถใช้งานได้ มันอาจจะช้าเกินไปขนาดใหญ่เกินไปและอึดอัดใจในการใช้งานหรือทั้งสาม ไม่มีทางเลือก แต่ที่จะเริ่มต้นอีกครั้งคือเจ็บ แต่อย่างชาญฉลาดและสร้างรุ่นที่ออกแบบใหม่ซึ่งปัญหาเหล่านี้จะแก้ไขได้ . . เมื่อแนวคิดระบบใหม่หรือเทคโนโลยีใหม่ถูกนำมาใช้อย่างใดอย่างหนึ่งที่มีการสร้างระบบที่จะโยนออกไปแม้การวางแผนที่ดีที่สุดคือไม่ให้รอบรู้ที่จะได้รับมันขวาครั้งแรก คำถามการจัดการจึงเป็นไม่ได้ว่าจะสร้างระบบนำร่องและโยนมันออกไป คุณจะทำอย่างนั้น คำถามเดียวก็คือไม่ว่าจะเป็นในการวางแผนล่วงหน้าในการสร้างใบปลิวหรือสัญญาว่าจะส่งมอบให้กับลูกค้าใบปลิว . .
ต้นแบบสามารถทำหน้าที่เป็น "ระบบแรก." หนึ่งที่บรูคส์แนะนำให้เราทิ้ง แต่นี่อาจจะเป็นมุมมองที่เงียบสงบ มันเป็นความจริงว่าทั้งลูกค้าและนักพัฒนาเช่นกระบวนทัศน์การสร้างต้นแบบ ผู้ได้รับความรู้สึกสำหรับระบบที่เกิดขึ้นจริงและนักพัฒนาได้รับการสร้างบางสิ่งบางอย่างได้ทันที แต่การสร้างต้นแบบยังสามารถจะเป็นปัญหาสำหรับเหตุผลต่อไปนี้:
1 ลูกค้าเห็นสิ่งที่ดูเหมือนจะเป็นรุ่นที่ทำงานของซอฟต์แวร์ที่ไม่ทราบว่าต้นแบบที่มีการจัดขึ้นร่วมกัน "กับหมากฝรั่งและลวด baling" ไม่รู้ว่าในการวิ่งที่จะได้รับมันทำงานไม่มีใครได้รับการพิจารณาคุณภาพของซอฟต์แวร์โดยรวมหรือในระยะยาว การบำรุงรักษา เมื่อทราบว่าผลิตภัณฑ์ที่จะต้องสร้างขึ้นมาใหม่เพื่อให้ระดับสูงของที่มีคุณภาพสามารถรักษาลูกค้าร้องไห้เหม็นและเรียกร้องให้ "แก้ไขไม่กี่" ถูกนำมาใช้เพื่อให้ต้นแบบผลิตภัณฑ์การทำงาน บ่อยครั้งที่การจัดการการพัฒนาซอฟแวร์เคา.
2 นักพัฒนามักจะทำให้การดำเนินการประนีประนอมเพื่อให้ได้รับต้นแบบการทำงานได้อย่างรวดเร็ว ระบบปฏิบัติการที่ไม่เหมาะสมหรือการเขียนโปรแกรมภาษาอาจจะใช้เพียงเพราะมันมีอยู่และเป็นที่รู้จักกัน; อัลกอริทึมไม่มีประสิทธิภาพอาจจะนำมาใช้เพียงเพื่อแสดงให้เห็นถึงความสามารถในการ หลังจากเวลาผ่านไปอาจพัฒนากลายเป็นความคุ้นเคยกับตัวเลือกเหล่านี้และลืมเหตุผลทั้งหมดว่าทำไมพวกเขาไม่เหมาะสม ทางเลือกที่น้อยกว่าเหมาะได้ตอนนี้กลายเป็นส่วนหนึ่งของระบบ.
แม้ว่าปัญหาจะเกิดขึ้นต้นแบบสามารถเป็นกระบวนทัศน์ที่มีประสิทธิภาพสำหรับวิศวกรรมซอฟต์แวร์ ที่สำคัญคือการกำหนดกฎของเกมที่จุดเริ่มต้น; ว่ามีลูกค้าและนักพัฒนาจะต้องทั้งสองยอมรับว่าต้นแบบที่ถูกสร้างขึ้นเพื่อใช้เป็นกลไกในการกำหนดความต้องการ มันถูกทิ้งแล้ว (อย่างน้อยในบางส่วน) และซอฟแวร์ที่เกิดขึ้นจริงถูกออกแบบด้วยตาที่มีต่อคุณภาพและการบำรุงรักษา

ผลลัพธ์ (ไทย) 3:

การสร้างกระบวนทัศน์ ( รูปที่ 2.5 ) เริ่มต้นด้วยการรวบรวมความต้องการ นักพัฒนาและลูกค้าได้กำหนดวัตถุประสงค์โดยรวมของซอฟต์แวร์ที่ระบุสิ่งที่ความต้องการเป็นที่รู้จักและพื้นที่ร่างที่นิยามเพิ่มเติมมีผลบังคับใช้ " รวดเร็วออกแบบ " ก็เกิดขึ้นออกแบบได้อย่างรวดเร็วมุ่งเน้นการเหล่านั้นในลักษณะของซอฟต์แวร์ที่สามารถให้ลูกค้า / ผู้ใช้ ( เช่นวิธีการป้อนข้อมูลและรูปแบบ output ) ออกแบบได้อย่างรวดเร็ว นำไปสู่การสร้างเครื่องต้นแบบ ต้นแบบคือการประเมินโดยลูกค้า / ผู้ใช้และใช้เพื่อปรับปรุงข้อกำหนดสำหรับซอฟต์แวร์ที่ได้รับการพัฒนาการเกิดขึ้นเป็นต้นแบบปรับเพื่อตอบสนองความต้องการของลูกค้าในขณะที่ในเวลาเดียวกันช่วยให้นักพัฒนาเพื่อให้เข้าใจในสิ่งที่ต้องทำ .
ใจกลาง ต้นแบบที่ทำหน้าที่เป็นกลไกในการระบุความต้องการซอฟต์แวร์ ถ้าต้นแบบการทำงานที่ถูกสร้างขึ้น , นักพัฒนาพยายามที่จะใช้ชิ้นส่วนโปรแกรมที่มีอยู่ หรือใช้เครื่องมือ เช่น เครื่องกำเนิดไฟฟ้ารายงานผู้จัดการหน้าต่าง ) ที่ช่วยให้โปรแกรมทำงานจะถูกสร้างขึ้นได้อย่างรวดเร็ว แต่เราจะทำยังไงกับต้นแบบเมื่อมันได้ทำหน้าที่จุดประสงค์แค่อธิบาย ? บรูคส์ [ bro75 ] ให้คำตอบ :
ในโครงการส่วนใหญ่ ระบบแรกที่สร้างขึ้นใช้งานน้อยมาก มันอาจจะช้าเกินไป และอึดอัดในการใช้ หรือ ทั้งหมด สาม ไม่มีทางเลือกแต่ที่จะเริ่มต้นอีกครั้ง ดูดีหรือไม่ แต่ฉลาดและสร้างใหม่รุ่นที่ปัญหาเหล่านี้จะหมดไป . . . . . . . เมื่อระบบแนวคิดใหม่หรือเทคโนโลยีใหม่มาใช้ มีการสร้างระบบเพื่อทิ้ง แม้แต่การวางแผนที่ดีที่สุดไม่ซูฮกที่จะได้รับมันขวาครั้งแรก การจัดการคำถาม ดังนั้น ไม่ว่าการสร้างระบบนำร่องและโยนมันออกไป คุณจะทำอย่างนั้นคำถามก็คือว่า การ วางแผนล่วงหน้าเพื่อสร้างใบปลิว หรือ สัญญาว่าจะส่งใบปลิวให้กับลูกค้า . . . . . . .
ต้นแบบสามารถใช้เป็น " ระบบ " ที่ทนให้เราทิ้ง แต่นี้อาจเป็นมุมมองในอุดมคติ . มันเป็นความจริงที่ทั้งลูกค้าและนักพัฒนาเหมือนต้นแบบกระบวนทัศน์ .ผู้ใช้ได้รับความรู้สึกสำหรับระบบที่เกิดขึ้นจริงและได้รับการพัฒนาเพื่อสร้างอะไรบางอย่างทันที แต่การสร้างยังสามารถเป็นปัญหาสำหรับเหตุผลต่อไปนี้ :
1 ลูกค้าเห็นสิ่งที่ดูเหมือนจะเป็นรุ่นการทำงานของซอฟต์แวร์ , ไม่รู้ว่าต้นแบบที่จัดขึ้นร่วมกัน " กับการเคี้ยวหมากฝรั่งและลวด ," ไม่รู้ว่า ในการวิ่งที่จะได้รับมันทำงานไม่มีใครถือว่าคุณภาพซอฟต์แวร์โดยรวมหรือผญา ระยะยาว เมื่อทราบว่าผลิตภัณฑ์จะต้องถูกสร้างใหม่ให้สูงระดับคุณภาพที่สามารถรักษาลูกค้าร้องไห้เหม็นและความต้องการที่ " ไม่กี่แก้ไข " ถูกนำมาใช้เพื่อให้ต้นแบบผลิตภัณฑ์การทำงาน บ่อยครั้งที่การจัดการการพัฒนาซอฟต์แวร์ relents .
2นักพัฒนามักจะทำให้การดำเนินงานเพื่อให้ได้ต้นแบบการทำงานได้อย่างรวดเร็ว ที่ไม่เหมาะสมของระบบปฏิบัติการหรือโปรแกรมภาษาอาจจะใช้เพียงเพราะมันสามารถใช้ได้และเป็นที่รู้จัก ; ขั้นตอนวิธีไม่ได้ผลอาจจะใช้เพียงเพื่อแสดงให้เห็นถึงความสามารถในการ หลังจากเวลานักพัฒนาอาจจะคุ้นเคยกับตัวเลือกเหล่านี้ และลืมทั้งหมด เหตุผลที่พวกเขาไม่เหมาะสม น้อยกว่าทางเลือกที่ตอนนี้ได้กลายเป็นส่วนหนึ่งของระบบ
ถึงแม้ว่าปัญหาที่สามารถเกิดขึ้นได้ สามารถสร้างกระบวนทัศน์ที่มีประสิทธิภาพสำหรับวิศวกรรมซอฟต์แวร์ กุญแจสำคัญคือการกำหนดกฎของเกมที่เริ่มต้น นั่นคือลูกค้าและนักพัฒนาต้องยอมรับว่า ต้นแบบถูกสร้างขึ้นเพื่อใช้เป็นกลไกสำหรับการกำหนดความต้องการ มันถูกยกเลิกแล้ว ( อย่างน้อยในบางส่วน ) และซอฟต์แวร์จริงถูกออกแบบด้วยตาที่มีต่อคุณภาพและ maintainability .