วิศวกรรมซอฟต์แวร์

หากต้องการทำให้อินเทอร์เฟซง่ายขึ้นจะดีกว่าgetBalance()ไหมที่ไม่มีวิธี? การส่งผ่าน0ไปยังcharge(float c);จะให้ผลลัพธ์เดียวกัน: public class Client { private float bal; float getBalance() { return bal; } float charge(float c) { bal -= c; return bal; } } อาจจดบันทึกในjavadoc? หรือเพียงแค่ปล่อยให้ผู้ใช้ระดับชั้นเรียนรู้วิธีการรับยอดคงเหลือ

30 interfaces  cqrs 

ตัวประมวลผลล่วงหน้า C เชื่อมต่อกับ C แต่มีไวยากรณ์ที่แตกต่างอย่างสิ้นเชิงจากภาษาหลัก: ช่องว่างที่มีความสำคัญทางไวยากรณ์ (จุดสิ้นสุดของบรรทัดยกเลิกคำสั่งช่องว่างหลังจากแมโครกำหนดจุดเริ่มต้นของรายการการแทนที่) บล็อกที่ใช้คำหลักแทนที่จะเป็นบล็อกที่มีเครื่องหมายค้ำยันelifแทนelse if คำจำกัดความที่นำโดยคำหลักแทนการประกาศ - สะท้อน - ใช้ไม่มี=สำหรับการกำหนดค่า คำแนะนำของไวยากรณ์สตริงทางเลือก ( #include <>vs #include "") การประเมินผลที่ขี้เกียจ (จาก C, ชัด ๆ แต่6.10.3.1สามารถอ่านได้โดยอ้างถึงคำสั่งเฉพาะของการขยายตัวของแมโครเช่นกันในบางแห่งที่มีความสำคัญ) มันดูไม่เหมือน C เลย! ในทางเทคนิคแล้วมันเป็นภาษาของตัวเอง แต่มันถูกใช้เป็นส่วนสำคัญเกือบทั้งหมดของ C และดูเหมือนว่าแปลกมากที่มันจะไม่รวมเข้ากับ syntactically Wikipedia ไม่ได้พูดถึงประวัติของมัน Portland Pattern Repository ได้กล่าวถึงการผ่านแต่ไม่ได้มีรายละเอียดนอกเหนือจากข้อเท็จจริงที่ว่ามันถูกออกแบบโดยคนอื่นนอกเหนือจากส่วนที่เหลือของเว็บไซต์ C. Dennis Ritchie ที่มีประวัติของ C อาจมีคำตอบ แต่น่าเสียดายที่ไม่มี ใช้ได้อีกต่อไป ในฐานะที่เป็นเครื่องมือมาโครก็เห็นได้ชัดว่ามีความหมายแตกต่างกันมากจากภาษารันไทม์ซึ่งจะอธิบายบางอย่างที่แตกต่างกัน แต่ไม่ได้ด้านการออกแบบภาพ …

30 c  history  macros 

Userสมมติว่าสำหรับตัวอย่างเช่นคุณมีการประยุกต์ใช้กับการเรียนร่วมกันอย่างกว้างขวางเรียกว่า คลาสนี้จะเปิดเผยข้อมูลทั้งหมดเกี่ยวกับผู้ใช้ ID ชื่อระดับการเข้าถึงแต่ละโมดูลเขตเวลา ฯลฯ ข้อมูลผู้ใช้นั้นถูกอ้างอิงอย่างกว้างขวางทั่วทั้งระบบ แต่ไม่ว่าจะด้วยเหตุผลใดก็ตามระบบได้รับการตั้งค่าเพื่อให้แทนที่จะส่งผู้ใช้วัตถุนี้ไปยังคลาสที่ขึ้นอยู่กับว่าเรากำลังส่งผ่านคุณสมบัติของแต่ละบุคคล คลาสที่ต้องการ ID ผู้ใช้เพียงแค่ต้องการ GUID userIdเป็นพารามิเตอร์บางครั้งเราอาจต้องการชื่อผู้ใช้ด้วยดังนั้นจะถูกส่งผ่านเป็นพารามิเตอร์แยกต่างหาก ในบางกรณีสิ่งนี้จะถูกส่งไปยังแต่ละวิธีดังนั้นค่าจะไม่ถูกเก็บไว้ที่ระดับชั้นเลย ทุกครั้งที่ฉันต้องการเข้าถึงข้อมูลที่แตกต่างจากคลาสผู้ใช้ฉันต้องทำการเปลี่ยนแปลงโดยการเพิ่มพารามิเตอร์และเมื่อการเพิ่มโอเวอร์โหลดใหม่ไม่เหมาะสมฉันต้องเปลี่ยนการอ้างอิงถึงเมธอดหรือตัวสร้างคลาสทุกครั้ง ผู้ใช้เป็นเพียงตัวอย่างเดียว นี่คือการฝึกฝนอย่างกว้างขวางในรหัสของเรา ฉันคิดถูกไหมว่านี่เป็นการละเมิดหลักการเปิด / ปิด? ไม่ใช่แค่การเปลี่ยนคลาสที่มีอยู่ แต่ตั้งค่าไว้ตั้งแต่แรกเพื่อให้การเปลี่ยนแปลงอย่างกว้างขวางมีความเป็นไปได้สูงที่จะเป็นสิ่งจำเป็นในอนาคต? ถ้าเราเพิ่งผ่านไปใน Userวัตถุฉันสามารถเปลี่ยนแปลงชั้นเรียนเล็ก ๆ ที่ฉันทำงานด้วยได้ ถ้าฉันต้องเพิ่มพารามิเตอร์ฉันอาจต้องทำการเปลี่ยนแปลงหลายสิบครั้งเพื่ออ้างอิงไปยังคลาส มีหลักการอื่นใดที่ผิดไปจากการฝึกฝนนี้หรือไม่? การผกผันของการพึ่งพาอาจจะ? แม้ว่าเราจะไม่ได้อ้างถึงสิ่งที่เป็นนามธรรม แต่ก็มีผู้ใช้เพียงประเภทเดียวดังนั้นจึงไม่จำเป็นต้องมีอินเทอร์เฟซผู้ใช้ มีการละเมิดหลักการอื่น ๆ ที่ไม่ใช่แบบแข็งเช่นหลักการตั้งโปรแกรมการป้องกันขั้นพื้นฐานหรือไม่? ตัวสร้างของฉันควรมีลักษณะเช่นนี้: MyConstructor(GUID userid, String username) หรือสิ่งนี้: MyConstructor(User theUser) โพสต์แก้ไข: มีคนแนะนำว่าคำถามนั้นตอบใน "รหัสผ่านหรือวัตถุ?" สิ่งนี้ไม่ได้ตอบคำถามว่าการตัดสินใจไปทางใดมีผลต่อความพยายามในการปฏิบัติตามหลักการของ SOLID ซึ่งเป็นหัวใจหลักของคำถามนี้

30 java  c#  design  solid 

ฉันได้รับการตรวจสอบการเขียนโปรแกรม C และมีเพียงสองสามสิ่งที่รบกวนฉัน ลองทำโค้ดนี้กันตัวอย่าง: int myArray[5] = {1, 2, 2147483648, 4, 5}; int* ptr = myArray; int i; for(i=0; i<5; i++, ptr++) printf("\n Element %d holds %d at address %p", i, myArray[i], ptr); ฉันรู้ว่า int สามารถมีค่าสูงสุดเป็นบวก 2,147,483,647 ดังนั้นเมื่อทำอย่างนั้นมันจะ "ล้น" ไปยังที่อยู่หน่วยความจำถัดไปซึ่งทำให้องค์ประกอบ 2 ปรากฏเป็น "-2147483648" ที่ที่อยู่นั้นหรือไม่ แต่นั่นก็ไม่สมเหตุสมผลเพราะในผลลัพธ์มันยังบอกว่าที่อยู่ถัดไปเก็บค่า 4 จากนั้น 5 ถ้าจำนวนที่หกไปยังที่อยู่ถัดไปนั่นจะไม่เปลี่ยนค่าที่เก็บไว้ที่ที่อยู่นั้น ? …

30 architecture  c  memory  hexadecimal 

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

30 agile  development-process  tdd  development-methodologies 

ฉันอ่านคำถามที่เกี่ยวข้องมีรูปแบบการออกแบบใดที่ไม่จำเป็นในภาษาไดนามิกเช่น Python หรือไม่? และจดจำคำพูดนี้บน Wikiquote.org สิ่งมหัศจรรย์เกี่ยวกับการพิมพ์แบบไดนามิกคือช่วยให้คุณสามารถแสดงสิ่งที่คำนวณได้ และประเภทของระบบไม่พิมพ์ - ระบบประเภทมักจะตัดสินใจได้และพวกเขา จำกัด ให้คุณเป็นส่วนย่อย ผู้ที่ชื่นชอบระบบแบบสแตติกพูดว่า“ ใช้ได้เลยมันดีพอ โปรแกรมที่น่าสนใจทั้งหมดที่คุณต้องการเขียนจะใช้งานได้ตามประเภท” แต่นั่นไร้สาระ - เมื่อคุณมีระบบพิมพ์คุณจะไม่รู้ด้วยซ้ำว่าโปรแกรมที่น่าสนใจนั้นมีอะไรบ้าง --- วิทยุวิศวกรรมซอฟต์แวร์ตอนที่ 140: Newspeak และประเภทที่เสียบได้ด้วย Gilad Bracha ฉันสงสัยว่ามีรูปแบบการออกแบบหรือกลยุทธ์ที่มีประโยชน์โดยใช้สูตรของคำพูด "ไม่ทำงานเป็นประเภท" หรือไม่?

30 design-patterns  python  type-systems  dynamic-typing 

ที่ บริษัท ของเราเราจะไม่ใช้เอกสารการออกแบบผลิตภัณฑ์ใด ๆ เรามีพนักงานทั้งหมดสามคนดังนั้นการอภิปรายการออกแบบผลิตภัณฑ์ทั้งหมดจึงเกิดขึ้นด้วยตนเองหรือบน Slack (เราอยู่ในแพ็คเกจ Slack พื้นฐานที่อนุญาตให้ดูข้อความล่าสุดเท่านั้น) ผลิตภัณฑ์ของเรายังอยู่ในช่วงเริ่มต้นและเรามักจะทบทวนองค์ประกอบการออกแบบที่ตัดสินใจเมื่อหลายเดือนก่อน ปัญหาที่เราเผชิญอยู่บ่อยครั้งคือการลืมสาเหตุที่ทำให้การตัดสินใจออกแบบผลิตภัณฑ์เกิดขึ้น ซึ่งส่งผลให้หลายชั่วโมงสูญเสียการหล่อเลี้ยงพื้นดินเดียวกัน เราจะบันทึกเหตุผลอย่างมีประสิทธิภาพหลังการตัดสินใจออกแบบได้อย่างไร ขั้นตอนการทำงานของเราขึ้นอยู่กับ Pivotal Tracker ทางออกหนึ่งที่เกิดขึ้นกับฉันคือการบันทึกเหตุผลในการตัดสินใจการออกแบบที่เกี่ยวข้องทั้งหมดเป็นความคิดเห็นเกี่ยวกับเรื่องราวของผู้ใช้ แต่สิ่งนี้ดูเหมือนไม่น่าเชื่อถือ เพื่อความชัดเจน 100%: ฉันไม่ได้พูดถึงการออกแบบรหัส ฉันกำลังพูดถึงการออกแบบผลิตภัณฑ์ที่รับรู้โดยรหัส กล่าวอีกนัยหนึ่งฉันไม่ได้พูดถึงการตัดสินใจเช่น "เราควรจัดโครงสร้างคลาสนี้โดยใช้การแต่งเพลงมากกว่าการรับมรดกหลายอันหรือไม่"; ฉันกำลังพูดถึงการตัดสินใจเช่น "เราควรกำหนดให้ผู้ใช้ยืนยันที่อยู่อีเมลก่อนที่จะสามารถเข้าสู่ระบบได้หรือไม่" จุดประสงค์ของเอกสารนี้คือเพื่อให้ธุรกิจสามารถดูบันทึกว่าทำไมจึงทำการตัดสินใจเพื่อช่วยในการตัดสินใจเพิ่มเติมเกี่ยวกับหัวข้อเดียวกัน

30 design  communication  design-decisions 

เหตุใดพวกเขาจึงกล่าวว่า XML มีความปลอดภัยของประเภทและมันแสดงใน XML ได้อย่างไร? มันแตกต่างจาก JSON อย่างไร (เช่นที่ฉันเข้าใจ) ซึ่งไม่ปลอดภัยประเภท?

30 xml  type-safety 

ฉันไม่เข้าใจเหตุผลที่ทำให้การเรียกร้อง / น้ำหนักบรรทุกของ JWT เปิดเผยต่อสาธารณชนหลังจาก base64 ถอดรหัส ทำไม? ดูเหมือนว่ามันจะมีประโยชน์มากกว่าที่จะเข้ารหัสด้วยความลับ บางคนสามารถอธิบายได้ว่าทำไมหรือในสถานการณ์ใดการทำให้ข้อมูลนี้เป็นประโยชน์ต่อสาธารณะ

30 security  json  authentication  jwt 

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

30 java  language-design  interfaces 

ฉันสงสัยว่าฉันสามารถเปลี่ยนจาก Java เป็น Scala ในโครงการ Spring + Hibernate เพื่อใช้ประโยชน์จากคุณสมบัติ Scala บางอย่างเช่นการจับคู่รูปแบบตัวเลือกและสิ่งที่ฉันคิดว่าเป็นไวยากรณ์ที่สะอาดกว่าโดยทั่วไป ฉันกำลังมองหา ORM เป็นค่าเริ่มต้นในระบบนิเวศของ Scala และฉันพบว่าคิดว่าเปิดใช้งาน (แต่ส่วนใหญ่ฉันพยายามค้นหาว่าไฮเบอร์เนตสามารถใช้กับ Scala ได้หรือไม่) ค้นหาสิ่งนี้ฉันได้อ่านสิ่งนี้ในเอกสารประกอบการเล่นเกี่ยวกับ JPA + Scala แต่ประเด็นที่สำคัญที่สุดคือ: คุณต้องการ Relationnal to mapper Objects จริงๆหรือไม่เมื่อคุณมีพลังของภาษาที่ใช้งานได้? อาจจะไม่. JPA เป็นวิธีที่สะดวกในการสรุปการขาดพลังงานในการแปลงข้อมูลของ Java แต่ก็รู้สึกผิดเมื่อคุณเริ่มใช้จาก Scala ฉันไม่มีความเข้าใจอย่างลึกซึ้งเกี่ยวกับวิธีการใช้การเขียนโปรแกรมเชิงฟังก์ชั่นเพื่อสร้างแอปพลิเคชันที่สมบูรณ์ (นั่นเป็นเหตุผลที่ฉันตั้งใจจะใช้ Scala เพื่อที่ฉันจะได้เข้าใจสิ่งที่เพิ่มขึ้นเนื่องจากมันรวม OO + Functional) ทำไมฉันไม่ต้องการ ORM ด้วยภาษาที่ใช้งานได้และอะไรคือแนวทางการทำงานเพื่อแก้ไขปัญหาการคงอยู่ของโมเดลโดเมน แนวทาง DDD สำหรับตรรกะทางธุรกิจยังคงสมเหตุสมผลกับ Scala …

30 scala  functional-programming 

ฉันกำลังอ่านคำตอบยอดนิยมเกี่ยวกับการทำนายสาขาจากhttps://stackoverflow.com/q/11227809/555690และมีบางอย่างที่ทำให้ฉันสับสน: หากคุณเดาถูกมันก็จะดำเนินต่อไป หากคุณเดาผิดกัปตันจะหยุดสำรองและตะโกนใส่คุณเพื่อสลับสวิตช์ จากนั้นมันสามารถรีสตาร์ทลงเส้นทางอื่น หากคุณเดาถูกทุกครั้งรถไฟจะไม่หยุด หากคุณเดาผิดบ่อยเกินไปรถไฟจะใช้เวลาหยุดมาก ๆ ในการสำรองและรีสตาร์ท แต่นี่คือสิ่งที่ฉันไม่ได้รับที่จะรู้ว่าคุณคงเดาได้ถูกต้องหรือไม่ถูกต้องคุณจะต้องทำให้การตรวจสอบสภาพอยู่แล้ว ดังนั้นการคาดคะเนสาขาจะทำงานได้อย่างไรถ้าอย่างใดอย่างหนึ่งที่คุณยังคงทำการตรวจสอบเงื่อนไขเดียวกัน สิ่งที่ฉันพยายามจะพูดคือไม่ได้ทำนายสาขาเหมือนกันกับที่ไม่มีการทำนายสาขาเลยเพราะคุณกำลังทำการตรวจสอบตามเงื่อนไขแบบเดียวกันหรือไม่? (เห็นได้ชัดว่าฉันผิด แต่ฉันไม่เข้าใจ)

30 optimization 

ฉันกำลังพยายามสร้างเฟรมเวิร์ก ACL ที่ยืดหยุ่นใน Java สำหรับแอปพลิเคชันของฉัน กรอบ ACL หลายคนที่ถูกสร้างขึ้นในรายการที่อนุญาตของกฎที่กฎอยู่ในรูปแบบของการใช้: การกระทำ: ทรัพยากร ตัวอย่างเช่น, "JOHN สามารถดูทรัพยากร FOOBAR-1" "MARY สามารถดูทรัพยากร FOOBAR-1" "MARY สามารถแก้ไขทรัพยากร FOOBAR-1" สิ่งนี้เป็นสิ่งที่น่าสนใจเนื่องจากกฎสามารถทำให้เป็นอนุกรม / คงอยู่กับฐานข้อมูลได้อย่างง่ายดาย แต่แอปพลิเคชันของฉันมีตรรกะทางธุรกิจที่ซับซ้อน ตัวอย่างเช่น, "ผู้ใช้ทุกคนในแผนก 1 ที่มีอาวุโสกว่า 5 ปีสามารถดูทรัพยากร FOOBAR-1 ไม่ได้รับอนุญาต" "ผู้ใช้ทุกคนในแผนก 2 หากวันที่หลังวันที่ 15/15/2016 สามารถดูทรัพยากร FOOBAR-2 ไม่ได้รับอนุญาต" เมื่อคิดเป็นครั้งแรกมันจะเป็นฝันร้ายที่จะสร้างโครงสร้างของฐานข้อมูลที่สามารถจัดการกับกฎที่ซับซ้อนเช่นนี้ ดังนั้นดูเหมือนว่าฉันจะต้อง "อบ" พวกเขาลงในใบสมัครที่รวบรวมการประเมินพวกเขาสำหรับผู้ใช้แต่ละคนและจากนั้นผลิตเจ้าของ: การกระทำ:กฎทรัพยากรเป็นผลมาจากการประเมินผล ฉันต้องการหลีกเลี่ยงการอบตรรกะในแอปพลิเคชันที่รวบรวม ดังนั้นฉันคิดของการเป็นตัวแทนของการปกครองในรูปแบบของคำกริยา : การกระทำ: ทรัพยากรที่สรุปคือการแสดงออกบูลที่กำหนดว่าผู้ใช้ที่ได้รับอนุญาต เพรดิเคตจะเป็นสตริงของนิพจน์ …

30 java  javascript  scripting  permissions  access-control 

ฉันพบว่าตัวเองอยู่ในจุดที่ยากลำบากของสาย เคยทำงานในเกมกับเพื่อนเขียนโปรแกรมมาเกือบ 8 เดือนแล้ว เราทั้งคู่เริ่มต้นในฐานะผู้มาใหม่ในการเขียนโปรแกรมประมาณเดือนสิงหาคมของปีที่แล้วเขาเป็นนักเรียน CS ปีที่ 2 ฉันเป็นผู้ให้การสนับสนุนด้านเทคโนโลยีโดยการค้าและเป็นโปรแกรมเมอร์ที่สอนตัวเองด้วยหนังสือมากมายและการสมัครสมาชิกออนไลน์ ปัญหาที่ฉันเห็นอยู่ตลอดเวลาคือเมื่อเราเขียนโค้ดจำนวนหนึ่งบ่อยครั้งที่มันจะถูกแฮ็กเข้าด้วยกันมีความล้มเหลวมากมายและหากเป็นแนวคิดใหม่เอี่ยมสำหรับเราหนึ่งคนที่เต็มไปด้วยโซลูชั่นไร้เดียงสา นี่เป็นสิ่งที่ดีเรากำลังเรียนรู้ฉันคาดหวังว่าโค้ดทั้งสองของเราจะถูกแฮ็กเข้าด้วยกันในภาคเรียนหรือรอบที่สอง ปัญหานำเสนอตัวเองเมื่อมันมาถึงการแก้ไขและ refactoring พฤติกรรมที่แฮ็กด้วยกัน คู่ของฉันจะยึดติดกับก้อนกรวดที่สดใหม่ของเขาด้วยกันอย่างโจ๋งครึ่มปฏิเสธที่จะเห็นข้อผิดพลาดใด ๆ ในขณะที่มันเริ่มทำงาน การอ้างถึงความสมบูรณ์แบบจากชิ้นส่วนของโครงสร้างฉันไม่สามารถแม้แต่จะใช้แม้ว่ามันจะมีความคิดเห็นและวิธีการและฟิลด์ที่ตั้งชื่อไว้อย่างเหมาะสมก็ตาม ไม่ว่าฉันจะพยายามแค่ไหนฉันก็ไม่สามารถทำให้เขาเห็นข้อบกพร่องที่เห็นได้ชัดซึ่งจะป้องกันไม่ให้เกิดการเปลี่ยนแปลงหรือการขยายตัวของพฤติกรรมโดยไม่ทำลายมันและทุกอย่างที่มันเชื่อมโยงกับพวกเขาอาจจะอยู่ในชั้นเดียวกัน โซลูชันที่ถูกแฮ็กตลอดเวลาจะถูกแฮ็กอยู่ตลอดและคิดว่าการออกแบบที่ไม่ดีจะยังคงอยู่ในแบบที่พวกเขาคิด ฉันใช้เวลาไปกับการดูแลรหัสใหม่ให้มากขึ้นเพราะฉันเขียนด้วยตัวเองฉันเสียสิ่งที่ต้องทำ คู่ของฉันสูญเสียมันไปคืนนี้และทำให้ชัดเจนว่าไม่ว่าอะไรก็ตามไม่ว่าจะเป็นมาตรฐานไม่ว่าจะเป็นเรื่องธรรมดาการปฏิบัติไม่ว่าจะเป็นข้อพิสูจน์ที่หักล้างไม่ได้ก็ตามรหัสของเขาจะยังคงอยู่ในแบบที่เขาทำ แม้ว่าหนังสือทั้งเล่มจะถูกเขียนขึ้นเกี่ยวกับสาเหตุที่คุณต้องการหลีกเลี่ยงการทำอะไรเขาจะปฏิเสธที่จะยอมรับความถูกต้องของพวกเขาโดยอ้างว่าเป็นเพียงความเห็นของใครบางคน ฉันมีความสนใจในโครงการของเรา แต่ฉันไม่แน่ใจว่าฉันจะสามารถทำงานร่วมกับคู่ค้าของฉันได้หรือไม่ ฉันดูเหมือนจะมีสามตัวเลือกให้ฉันเปิด หยุดการดูแลเกี่ยวกับการทำงานของ codebase ที่ผ่านจุดรวบรวมและเพียงจัดการกับการพยายามที่จะรักษาและแยกวิเคราะห์พฤติกรรมที่แทบจะไม่คลานไปมา หวังว่าเมื่อสิ่งต่าง ๆ เริ่มสลายอย่างจริงจังเขาจะเห็นและพยายามทำมากกว่าแค่ใส่ bandaid เหนือการออกแบบที่มีข้อบกพร่องพื้นฐาน ติดตามข้อถกเถียงที่ไม่รู้จบเกี่ยวกับปัญหาที่เกิดขึ้นเมื่อทศวรรษที่แล้วโดยบุคคลที่มีความสามารถมากกว่า หยุดเขียนโปรแกรมในโครงการนี้ทิ้งโค้ดของฉันเกือบ 10,000 บรรทัดและใช้เวลาหลายชั่วโมงในการออกแบบและลองหาโปรเจคใหม่ด้วยตัวเอง ฉันจะใช้วิธีการใดเพื่อตรวจสอบว่าโครงการนี้ดำเนินต่อกับบุคคลนี้ได้หรือไม่ หรือปัจจัยใดที่ควรมีอิทธิพลต่อการตัดสินใจของฉัน เราได้เขียนโค้ดจำนวนมากและฉันไม่ต้องการยอมแพ้เว้นแต่จะจำเป็น

30 code-quality  refactoring  teamwork  maintenance 

คำถามข้างต้นเป็นตัวอย่างนามธรรมของปัญหาทั่วไปที่ฉันพบในรหัสดั้งเดิมหรือปัญหาที่เกิดจากการพยายามแก้ไขปัญหานี้ก่อนหน้านี้ ฉันคิดวิธีการกรอบ NET อย่างน้อยหนึ่งวิธีที่มีจุดประสงค์เพื่อแก้ไขปัญหานี้เช่นเดียวกับEnumerable.OfType<T>วิธีการ แต่ความจริงที่ว่าท้ายที่สุดคุณก็สอบปากคำชนิดของวัตถุที่รันไทม์ไม่ได้อยู่กับฉัน นอกเหนือจากการถามม้าแต่ละตัว "คุณเป็นยูนิคอร์นหรือไม่" วิธีการต่อไปนี้อยู่ในใจ: โยนข้อยกเว้นเมื่อมีความพยายามที่จะทำให้ความยาวของฮอร์นที่ไม่ใช่ของยูนิคอร์น (เปิดเผยการทำงานที่ไม่เหมาะสมสำหรับม้าแต่ละตัว) ส่งคืนค่าเริ่มต้นหรือค่าเวทย์มนตร์สำหรับความยาวของฮอร์นที่ไม่ใช่ของยูนิคอร์น (ต้องใช้การตรวจสอบเริ่มต้นที่ทำตัวกลมกลืนตลอดรหัสใด ๆ ที่ต้องการกระทืบสถิติฮอร์นบนกลุ่มของม้าที่อาจไม่ใช่ยูนิคอร์น) ทำไปด้วยมรดกและสร้างวัตถุแยกต่างหากบนม้าที่บอกคุณว่าม้าเป็นยูนิคอร์นหรือไม่ (ซึ่งอาจผลักปัญหาเดียวกันลงมาที่เลเยอร์) ฉันมีความรู้สึกว่าสิ่งนี้จะได้รับคำตอบที่ดีที่สุดด้วยคำว่า "ไม่ใช่คำตอบ" แต่คุณจะแก้ไขปัญหานี้อย่างไรและหากเป็นเช่นนั้นบริบทของการตัดสินใจของคุณคืออะไร ฉันยังสนใจในข้อมูลเชิงลึกใด ๆ ว่าปัญหานี้ยังคงมีอยู่ในรหัสการทำงานหรือไม่ สิ่งนี้ถูกตั้งค่าสถานะว่าซ้ำซ้อนกับคำถามต่อไปนี้: จะหลีกเลี่ยงการดาวน์สตรีมได้อย่างไร คำตอบสำหรับคำถามนั้นสมมติว่ามีใครอยู่ในความครอบครองของHornMeasurerที่เขาจะต้องทำการวัดทั้งหมด แต่นั่นเป็นการจัดวางรหัสฐานที่ค่อนข้างถูกสร้างขึ้นภายใต้หลักการด้านสิทธิประโยชน์ที่ทุกคนควรมีอิสระในการวัดแตรของม้า ไม่มีกHornMeasurer. คำตอบที่ได้รับการยอมรับจะสะท้อนวิธีการตามข้อยกเว้นที่ระบุไว้ข้างต้น นอกจากนี้ยังมีความสับสนในความคิดเห็นเกี่ยวกับว่าม้าและยูนิคอร์นเป็นม้าทั้งคู่หรือว่าเป็นยูนิคอร์นเป็นสายพันธุ์ที่มีมนต์ขลังของม้า ควรพิจารณาถึงความเป็นไปได้ทั้งสองอย่างหรือไม่?

30 design  object-oriented  functional-programming