คำถามติดแท็ก code-reuse

ฉันมักจะได้ยินว่ามันบอกว่าวัตถุไม่ได้ส่งในแง่ของการใช้รหัสซ้ำ คุณเห็นด้วยไหม? หากคุณเชื่อว่าพวกเขาไม่ได้ทำไมไม่?

17 object-oriented  code-reuse 

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

16 c  code-quality  code-reuse 

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

16 code-reuse 

สิ่งหนึ่งที่ทำงานใน Haskell และ F # สอนให้ฉันคือคนที่อยู่ในมหาวิทยาลัยอย่างชาญฉลาดกว่าฉันอาจจะพบสิ่งที่เป็นนามธรรมสำหรับสิ่งที่ฉันกำลังทำอยู่ ในทำนองเดียวกันใน C # และการเขียนโปรแกรมเชิงวัตถุอาจมีห้องสมุดสำหรับ "มัน" ไม่ว่าฉันจะทำอะไรก็ตาม มีการเน้นย้ำว่าการนำเอา abstractions มาใช้ในการเขียนโปรแกรมซึ่งบ่อยครั้งฉันรู้สึกว่าลำบากใจระหว่าง: 1) แค่เขียนโค้ดบางอย่างที่สั้นและสกปรกด้วยตัวเองหรือ 2) ใช้เวลาในการค้นหาไลบรารี่ / โซลูชันที่แข็งแกร่งกว่า เช่นเดียวกับเมื่อเร็ว ๆ นี้หนึ่งในผู้เขียนที่นี่เขียนขึ้น (de) serializer สำหรับไฟล์ CSV และฉันไม่สามารถช่วย แต่คิดว่าบางสิ่งบางอย่างเช่นนั้นอาจเป็นเรื่องง่ายมากที่จะหาออนไลน์ถ้ามันไม่ได้มาพร้อมกับมาตรฐาน. NET APIs ผมไม่ตำหนิเขา แต่หลายครั้งการทำงานใน .NET ฉันได้ปะกันแก้ปัญหาขึ้นอยู่กับสิ่งที่ฉันรู้เท่านั้นที่จะรู้ว่ามีบางอย่างที่เรียกวิธีการหรือวัตถุหรือสิ่งที่ มักจะอยู่ในห้องสมุดเดียวกันที่ทำในสิ่งที่ ฉันต้องการและฉันก็ไม่รู้เกี่ยวกับมัน นี่เป็นเพียงสัญลักษณ์ของการไม่มีประสบการณ์หรือมีองค์ประกอบของการแลกเปลี่ยนระหว่างการเขียนใหม่และเก่าซ้ำ? สิ่งที่ฉันเกลียดที่สุดคือเมื่อฉันวิ่งข้ามทางออกที่ฉันรู้และลืมไปแล้ว ฉันรู้สึกเหมือนว่าคน ๆ หนึ่งไม่สามารถแยกแยะรหัสที่เต็มไปด้วยภาษาส่วนใหญ่ในทุกวันนี้

16 libraries  code-reuse 

ตัวอย่างเช่นสมมติว่าคุณกำลังเขียนแอปในJava ของแอปสื่อสารกับเซิร์ฟเวอร์ API เขียนในหลาม เซิร์ฟเวอร์ Python สื่อสารกับฐานข้อมูลSQL นอกจากนี้คุณยังมีเว็บไซต์ของแอปเขียนในJavaScript ด้วย 4 ภาษาที่แตกต่างกันมันง่ายที่จะจบลงด้วยการทำซ้ำโครงสร้างข้อมูลเดิม 4 ครั้ง ตัวอย่างเช่นUserประเภทอาจมีลักษณะเช่นนี้ (pseudocode): type User { integer id; string name; timestamp birthday; } Userส่วนหนึ่งของโครงการทุกคนจะต้องชนิดของการแสดงบางอย่างสำหรับ ส่วนของ Java และ Python ต้องการclassการประกาศสองแบบที่ต่างกัน ฐานข้อมูลจะต้องมีUserการประกาศตาราง และเว็บไซต์ส่วนหน้าจะต้องเป็นตัวแทนUserด้วย การทำซ้ำประเภทนี้ 4 ครั้งแตกต่างกันจริงๆแบ่งห้ามทำซ้ำ-Yourselfหลักการ นอกจากนี้ยังมีปัญหาที่หากUserมีการเปลี่ยนแปลงประเภทการเปลี่ยนแปลงเหล่านี้จำเป็นต้องทำซ้ำในทุกส่วนของโครงการ ฉันรู้ว่าห้องสมุดprotobufของ Google นำเสนอวิธีการแก้ปัญหาที่คุณเขียนโครงสร้างข้อมูลโดยใช้ไวยากรณ์พิเศษจากนั้นห้องสมุดจะสร้างการประกาศโครงสร้างสำหรับคุณในภาษาการเขียนโปรแกรมหลายภาษา แต่สิ่งนี้ยังไม่ได้จัดการกับปัญหาของการต้องตรวจสอบตรรกะการตรวจสอบซ้ำสำหรับประเภทของคุณ ไม่มีใครมีคำแนะนำหรือลิงค์ไปยังหนังสือ / บล็อกโพสต์เกี่ยวกับเรื่องนี้หรือไม่?

12 design-patterns  object-oriented-design  code-reuse 

ฉันมีชั้นเรียนที่ใช้ในการประมวลผลการชำระเงินของลูกค้า ทั้งหมดยกเว้นหนึ่งในวิธีการของคลาสนี้จะเหมือนกันสำหรับลูกค้าทุกคนยกเว้นวิธีที่คำนวณ (ตัวอย่าง) จำนวนผู้ใช้ของลูกค้าที่ค้างชำระ สิ่งนี้อาจแตกต่างกันอย่างมากจากลูกค้าไปยังลูกค้าและไม่มีวิธีง่ายๆในการจับตรรกะของการคำนวณในบางสิ่งบางอย่างเช่นไฟล์คุณสมบัติเนื่องจากอาจมีปัจจัยที่กำหนดเองจำนวนเท่าใดก็ได้ ฉันสามารถเขียนรหัสน่าเกลียดที่เปลี่ยนตาม customerID: switch(customerID) { case 101: .. do calculations for customer 101 case 102: .. do calculations for customer 102 case 103: .. do calculations for customer 103 etc } แต่สิ่งนี้ต้องการการสร้างคลาสใหม่ทุกครั้งที่เราได้ลูกค้าใหม่ อะไรคือวิธีที่ดีกว่า [แก้ไข] บทความ "ซ้ำกัน" แตกต่างอย่างสิ้นเชิง ฉันไม่ได้ถามว่าจะหลีกเลี่ยงคำสั่ง switch ได้อย่างไรฉันกำลังขอการออกแบบที่ทันสมัยที่ใช้กับกรณีนี้ได้ดีที่สุด - ซึ่งฉันสามารถแก้ไขได้ด้วยคำสั่ง switch หากฉันต้องการเขียนรหัสไดโนเสาร์ ตัวอย่างที่ให้ไว้มีทั่วไปและไม่เป็นประโยชน์เนื่องจากพวกเขาบอกว่า "เฮ้สวิตช์ทำงานได้ค่อนข้างดีในบางกรณีไม่ใช่ในบางกรณี" …

12 design-patterns  clean-code  code-reuse 

ฉันทำงานกับระบบธุรกรรมทางการเงินขนาดใหญ่สำหรับธนาคารที่ดูแลเงินบำนาญและการลงทุน หลังจากการเปลี่ยนแปลงคุณสมบัติ 15 ปีค่าใช้จ่ายในการทดสอบการถดถอยแบบแมนนวลก็เพิ่มขึ้นเป็น $ 200K ต่อการเปิดตัว (10M LOC ทำธุรกรรม $ 10M ต่อวัน) ระบบนี้ยังเชื่อมต่อกับ 19 ระบบอื่น ๆ ทั่ว บริษัท ที่ย้ายข้อมูลจำนวนมาก ระบบนี้ถูกนำไปใช้ใน Java อย่างไรก็ตามสิ่งที่เราสังเกตคือยิ่งเราใช้ค่าใช้จ่ายในการทดสอบการถดถอยมากขึ้น (เหตุผลที่คุณต้อง "ทดสอบรหัสที่คุณแตะ" - และรหัสที่ใช้ซ้ำ / แชร์จะส่งผลกระทบต่อสถานที่หลายแห่งเมื่อมีการแตะต้องดังนั้นแม้จะมี 'DRY - อย่าทำซ้ำตัวเอง' - นั่นคืออย่าคัดลอกและวางรหัส - เราสังเกตสิ่งจูงใจทางการเงินเพื่อคัดลอกและวางรหัสนี่คือการลดค่าใช้จ่ายในการทดสอบการถดถอยเนื่องจากเราไม่ต้องการแก้ไขรหัสที่สามารถแชร์ได้เพราะจะทำให้เกิดผลกระทบการทดสอบการถดถอยครั้งใหญ่) คำถามของฉันคือมีหลักการวิศวกรรมซอฟต์แวร์ที่อธิบายความสัมพันธ์ระหว่างต้นทุนการทดสอบซ้ำและการถดถอยซ้ำหรือไม่ เหตุผลที่ฉันถามคำถามนี้คือเนื้อหามีประโยชน์ต้นทุนในการย่อยสลายระบบเป็นส่วนเล็ก ๆ ที่จะทดสอบ สมมติฐาน: 'การทดสอบการถดถอย' หมายถึง 'การทดสอบการยอมรับ' - นั่นคืออีกกลุ่มใช้เวลาในการเขียนการทดสอบแบบเก่าและนำมาใช้ซ้ำกับระบบในนามของธุรกิจรวมถึงการตั้งค่าสภาพแวดล้อมและข้อมูล ฉันรู้ว่าปฏิกิริยาการกระตุกเข่าต่อค่าใช้จ่ายในการทดสอบการถดถอยครั้งใหญ่คือ 'การทดสอบอัตโนมัติมากขึ้น' นี่เป็นหลักการที่ดี ในสภาพแวดล้อมนี้มีความท้าทายสองประการ …

12 code-reuse  acceptance-testing  estimation 

ฉันพยายามปฏิบัติตาม Single Responsibility Principle (SRP) และไม่ใช้ Code ซ้ำ อย่างไรก็ตามมักจะมีสถานที่ที่มีการทำซ้ำรหัสที่ไม่มีอะไรมากไปกว่าบล็อคโค้ดของการเรียกใช้ที่สามารถต้านทานการแตกออกเป็นอย่างน้อยแปลความหมายเต็มวิธีการชื่อ: DoAction1(); DoAction2(); if (value) DoAction3(); DoAction4(); เป็นวิธีที่ดีที่สุดในการแยกรหัสดังกล่าวเป็นวิธีการและวิธีการตั้งชื่อมันได้อย่างไร

11 refactoring  readability  single-responsibility  code-reuse 

ในหนังสือ O'Reilly ใน Scala ฉันอ่านว่าการวางสำเนาของรหัสสร้างขึ้น: ... สร้างประเด็นของรหัสบวม, การบำรุงรักษาและลาด , ฉันไม่เห็นคำจำกัดความที่ชัดเจนของคำว่าเอียงในบริบท ฉันตระหนักถึงปัญหาของการคัดลอกวาง แต่ฉันไม่สามารถทำให้พอดีกับคำว่า 'เอียง' เนื่องจากสิ่งนี้ถูกใช้ในหนังสือ O'Reilly ฉันเดาว่ามันเป็นคำที่ใช้ในการเขียนโปรแกรมอย่างแท้จริง ตัวชี้ใด ๆ

11 terminology  code-reuse 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว ฉันได้อ่านบาง เอกสารจากช่วงต้นยุค 90 ที่เกี่ยวกับกระทรวงกลาโหมสหรัฐฯคิดริเริ่มนำมาใช้ซอฟต์แวร์ที่เรียกว่าซอฟต์แวร์ระบบการป้องกันการใช้ซ้ำ (DSRs) การกล่าวถึงครั้งล่าสุดที่ฉันพบได้คือในกระดาษจากปี 2000 - การสำรวจที่เก็บซอฟท์แวร์นำกลับมาใช้ใหม่ ระบบจัดเก็บซอฟต์แวร์ป้องกัน (DSRS) DSRS เป็นที่เก็บข้อมูลอัตโนมัติสำหรับการจัดเก็บและการเรียกคืนซอฟต์แวร์สินทรัพย์ที่ใช้ซ้ำได้ (RSAs) [14] ตอนนี้ซอฟต์แวร์ DSRS จะจัดการสินค้าคงเหลือของสินทรัพย์ที่นำกลับมาใช้ใหม่ได้ที่ศูนย์สนับสนุนการใช้ซ้ำซอฟต์แวร์เจ็ดแห่ง (SRSC) DSRS ทำหน้าที่เป็นจุดรวบรวมศูนย์กลางสำหรับ RSAs ที่มีคุณภาพและอำนวยความสะดวกในการนำซอฟต์แวร์กลับมาใช้ใหม่โดยมอบโอกาสให้นักพัฒนาในการจับคู่ความต้องการกับผลิตภัณฑ์ซอฟต์แวร์ที่มีอยู่ บัญชี DSRS มีให้สำหรับพนักงานของรัฐและบุคลากรผู้รับเหมาที่กำลังสนับสนุนโครงการของรัฐบาล ... ... ชุมชนซอฟต์แวร์ DoD กำลังพยายามที่จะเปลี่ยนรูปแบบวิศวกรรมซอฟต์แวร์จากวัฏจักรซอฟต์แวร์ปัจจุบันไปเป็นกระบวนการที่ขับเคลื่อนด้วยโดเมนเฉพาะสถาปัตยกรรมที่ยึดตามพื้นที่เก็บข้อมูลช่วยในการสร้างซอฟต์แวร์ [15] ในสภาพแวดล้อมที่เปลี่ยนแปลงนี้ DSRS มีศักยภาพสูงสุดในการเป็นพื้นที่เก็บข้อมูลที่นำมาใช้ซ้ำของ DoD เนื่องจากเป็นพื้นที่เก็บข้อมูลที่ใช้งานได้เฉพาะที่มีอยู่แล้วเท่านั้นที่มีอยู่ในสถานที่ปฏิบัติงานร่วมกันหลายแห่งทั่ว DoD ที่ตั้ง DSRS ทั้งเจ็ดแห่งรองรับผู้ใช้งานเกือบ 1,000 รายและแสดงรายการสินทรัพย์ที่นำกลับมาใช้ใหม่ได้เกือบ …

11 code-reuse  government 

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

10 refactoring  code-reuse 

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

10 legal  code-reuse 

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

9 object-oriented-design  class-design  abstraction  code-reuse  dry