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

ฉันพยายามทำตามหลักการของDRYอย่างเคร่งครัดในที่ทำงานเสมอ ทุกครั้งที่ฉันทำซ้ำรหัสจากความเกียจคร้านมันกัดอีกครั้งในภายหลังเมื่อฉันต้องการรักษารหัสนั้นในสองแห่ง แต่บ่อยครั้งที่ฉันเขียนวิธีเล็ก ๆ (อาจเป็นรหัส 10 - 15 บรรทัด) ที่ต้องนำมาใช้ซ้ำในสองโครงการที่ไม่สามารถอ้างอิงซึ่งกันและกัน วิธีอาจเป็นสิ่งที่ต้องทำกับระบบเครือข่าย / สาย / MVVM ฯลฯ และเป็นวิธีที่มีประโยชน์โดยทั่วไปไม่เฉพาะเจาะจงกับโครงการที่ตั้งอยู่ในตอนแรก วิธีมาตรฐานในการนำรหัสนี้มาใช้ซ้ำจะเป็นการสร้างโครงการที่เป็นอิสระสำหรับรหัสที่ใช้ซ้ำได้และอ้างอิงโครงการนั้นเมื่อคุณต้องการ ปัญหาเกี่ยวกับสิ่งนี้คือเราจบลงในหนึ่งในสองสถานการณ์ที่ไม่เป็นอุดมคติ: เราจบลงด้วยโครงการเล็ก ๆ นับสิบ / ร้อยคน - แต่ละหลังมีชั้นเรียน / วิธีการเล็ก ๆ น้อย ๆ ซึ่งเราจำเป็นต้องนำมาใช้ซ้ำ มันคุ้มค่าที่จะสร้างรหัสใหม่.DLLเพียงเล็กน้อยหรือไม่? เราจบลงด้วยโครงการเดียวที่รวบรวมวิธีและชั้นเรียนที่ไม่เกี่ยวข้องเพิ่มมากขึ้น วิธีนี้เป็นสิ่งที่ บริษัท ที่ฉันเคยทำงานด้วย พวกเขามีโปรเจ็กต์base.commonที่มีโฟลเดอร์สำหรับสิ่งต่าง ๆ เช่นที่ฉันกล่าวถึงข้างต้น: เครือข่าย, การจัดการสตริง, MVVM ฯลฯ มันมีประโยชน์อย่างเหลือเชื่อ แต่การอ้างอิงมันลากโดยไม่จำเป็นด้วยรหัสที่ไม่เกี่ยวข้องทั้งหมดที่คุณไม่ต้องการ ดังนั้นคำถามของฉันคือ: ทีมซอฟต์แวร์ทำงานอย่างไรดีที่สุดเกี่ยวกับการนำรหัสขนาดเล็กไปมาระหว่างโครงการ ฉันสนใจเป็นพิเศษหากใครก็ตามที่ทำงานใน บริษัท …

102 project-management  code-reuse  projects-and-solutions  dry 

วันนี้ฉันกำลังดูวิดีโอ "พื้นฐานJUnit " และผู้เขียนกล่าวว่าเมื่อทำการทดสอบวิธีการที่กำหนดในโปรแกรมของคุณคุณไม่ควรใช้วิธีการอื่นของคุณเองในกระบวนการ เพื่อที่จะเจาะจงมากขึ้นเขากำลังพูดถึงการทดสอบวิธีการสร้างเรกคอร์ดที่ใช้ชื่อและนามสกุลของอาร์กิวเมนต์และใช้เพื่อสร้างเรกคอร์ดในตารางที่กำหนด แต่เขาอ้างว่าในกระบวนการทดสอบวิธีนี้เขาไม่ควรใช้วิธีDAOอื่น ๆ ของเขาในการสืบค้นฐานข้อมูลเพื่อตรวจสอบผลลัพธ์สุดท้าย (เพื่อตรวจสอบว่าบันทึกถูกสร้างขึ้นจริงด้วยข้อมูลที่ถูกต้อง) เขาอ้างว่าสิ่งนั้นเขาควรเขียนรหัสJDBCเพิ่มเติมเพื่อสืบค้นฐานข้อมูลและตรวจสอบผลลัพธ์ ฉันคิดว่าฉันเข้าใจจิตวิญญาณของการอ้างสิทธิ์ของเขา: คุณไม่ต้องการให้กรณีทดสอบของวิธีใดวิธีหนึ่งขึ้นอยู่กับความถูกต้องของวิธีอื่น ๆ (ในกรณีนี้วิธี DAO) และสิ่งนี้สามารถทำได้โดยการเขียนการตรวจสอบของคุณเองอีกครั้ง / สนับสนุนรหัส (ซึ่งควรจะเฉพาะเจาะจงมากขึ้นและเพ่งความสนใจไปจึงรหัสที่ง่ายขึ้น) อย่างไรก็ตามเสียงในหัวของฉันเริ่มคัดค้านด้วยข้อโต้แย้งเช่นการทำสำเนารหัสความพยายามเพิ่มเติมที่ไม่จำเป็น ฯลฯ ฉันหมายถึงถ้าเราใช้แบตเตอรี่ทดสอบทั้งหมดและเราทดสอบวิธีสาธารณะทั้งหมดของเราอย่างละเอียด (รวมถึงวิธี DAO ในกรณีนี้) ไม่ควร ไม่เป็นไรที่จะใช้วิธีการเหล่านั้นบางอย่างขณะทดสอบวิธีอื่น ๆ หากหนึ่งในนั้นไม่ได้ทำในสิ่งที่มันควรจะเป็นกรณีทดสอบของตัวเองจะล้มเหลวและเราสามารถแก้ไขและเรียกใช้แบตเตอรี่ทดสอบอีกครั้ง ไม่จำเป็นต้องทำสำเนารหัส (แม้ว่ารหัสที่ซ้ำกันจะค่อนข้างง่ายกว่า) หรือสูญเสียความพยายาม ฉันมีความรู้สึกที่แข็งแกร่งเกี่ยวกับเรื่องนี้เนื่องจากแอปพลิเคชันExcel - VBA หลายตัวที่ฉันเขียน (ต้องผ่านการทดสอบหน่วยอย่างถูกต้องด้วยRubberduck สำหรับ VBA ) ซึ่งการใช้คำแนะนำนี้จะหมายถึงการทำงานพิเศษเพิ่มเติมจำนวนมากโดยไม่มีประโยชน์ คุณช่วยแบ่งปันความเข้าใจเกี่ยวกับเรื่องนี้ได้ไหม?

83 programming-practices  unit-testing  code-reuse 

ฉันยังไม่มีประสบการณ์ในการเขียนรหัสคุณภาพสูงดังนั้นฉันจึงอ่านหนังสือเกี่ยวกับปัญหาเช่นClean Codeของ Robert C. Martin และตรวจสอบรหัสของห้องสมุดที่มีชื่อเสียงเพื่อพัฒนาทักษะของฉัน แม้ว่าไลบรารีโอเพนซอร์สจำนวนมากได้รับการดูแลรักษามานานหลายปีซึ่งหมายความว่ามันไม่น่าเป็นไปได้ที่พวกเขาจะไม่ได้อยู่ในเส้นทางที่ถูกต้อง แต่ฉันพบว่าโค้ดในหลาย ๆ โค้ดหลายร้อยบรรทัด ดังนั้นคำถามของฉันคือ: หลักการของโค้ดที่สะอาดเกินไปถูก จำกัด และเราสามารถทำได้โดยไม่ต้องใช้พวกมันในห้องสมุดหลาย ๆ ถ้าไม่เป็นเช่นนั้นห้องสมุดขนาดใหญ่จะได้รับการดูแลอย่างไรโดยไม่คำนึงถึงหลักการเหล่านี้มากมาย? ฉันขอขอบคุณที่ชี้แจงสั้น ๆ ฉันขอโทษถ้าคำถามดูเหมือนว่าโง่จากมือใหม่ แก้ไข ตรวจสอบตัวอย่างนี้ในห้องสมุดButterknife - หนึ่งในห้องสมุดที่มีชื่อเสียงที่สุดในชุมชน Android

80 architecture  code-quality  libraries  clean-code  code-reuse 

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

56 productivity  code-quality  object-oriented  code-reuse 

เมื่ออ่านคำถาม Stack Overflow และรหัสอื่น ๆ ข้อสรุปทั่วไปเกี่ยวกับวิธีการออกแบบคลาสจะปิดลง ซึ่งหมายความว่าโดยเริ่มต้นใน Java และ C # ทุกอย่างเป็นส่วนตัวฟิลด์เป็นที่สิ้นสุด, วิธีการบางอย่างเป็นที่สิ้นสุดและบางครั้งการเรียนเป็นที่สิ้นสุดแม้กระทั่ง แนวคิดเบื้องหลังนี้คือการซ่อนรายละเอียดการใช้งานซึ่งเป็นเหตุผลที่ดีมาก อย่างไรก็ตามด้วยการมีอยู่protectedในภาษา OOP ส่วนใหญ่และความแตกต่างนี้ไม่ทำงาน ทุกครั้งที่ฉันต้องการเพิ่มหรือเปลี่ยนฟังก์ชั่นการเรียนฉันมักจะถูกขัดขวางโดยส่วนตัวและสุดท้ายที่ทุกที่ รายละเอียดการใช้งานที่นี่มีความสำคัญ: คุณกำลังดำเนินการและขยายการดำเนินงาน อย่างไรก็ตามเนื่องจากฉันไม่สามารถเข้าถึงเขตข้อมูลส่วนตัวและสุดท้ายและวิธีการฉันมีสามตัวเลือก: อย่าขยายชั้นเรียนเพียงแก้ไขปัญหาที่นำไปสู่รหัสที่ซับซ้อนมากขึ้น คัดลอกและวางทั้งคลาสการฆ่ารหัสนำมาใช้ใหม่ แยกโครงการ นั่นไม่ใช่ตัวเลือกที่ดี เหตุใดจึงไม่protectedใช้ในโครงการที่เขียนเป็นภาษาที่รองรับ เหตุใดบางโครงการจึงห้ามไม่ให้สืบทอดจากคลาสของพวกเขาอย่างชัดเจน

44 code-reuse 

เมื่อทำงานกับโค้ดฉันต้องเผชิญกับความท้าทายหลายอย่างที่เพื่อนร่วมทีมของฉันทำและฉันได้เขียนฟังก์ชั่นและชั้นเรียนที่มีประโยชน์ หากมีการสื่อสารที่ดีฉันจะได้ยินเกี่ยวกับสิ่งที่ยอดเยี่ยมที่ใครบางคนรวบรวมไว้และอีกหกเดือนต่อมาเมื่อฉันต้องการฉันอาจจำได้และเรียกใช้ฟังก์ชันนั้นประหยัดเวลา หากฉันจำไม่ได้หรือไม่เคยรู้เรื่องนี้ฉันอาจจะประดิษฐ์วงล้อขึ้นใหม่ มีวิธีปฏิบัติที่เฉพาะเจาะจงในการบันทึกสิ่งเหล่านี้หรือไม่? คุณทำให้พวกมันหาง่ายได้อย่างไร? หากทีมของคุณไม่มีเอกสารดังกล่าวคุณจะรู้ได้อย่างไรว่าล้อของคุณมีอยู่แล้ว? แก้ไข: ทั้งหมด แต่หนึ่งในคำตอบที่เกี่ยวข้องกับสถานการณ์ในอุดมคติดังนั้นขอสรุปการแก้ปัญหาเหล่านั้น: เอกสาร & การสื่อสาร; wikis, stand-up meetings เป็นต้นสิ่งเหล่านี้ล้วน แต่เป็นสิ่งที่ยอดเยี่ยม แต่พวกเขาต้องพึ่งพาโปรแกรมเมอร์ที่มีเวลา (และทักษะ) ในการเขียนเอกสารและเข้าร่วมการประชุมและจดบันทึกและจดจำทุกสิ่ง คำตอบที่ได้รับความนิยมมากที่สุดจนถึงปัจจุบัน (Caleb's) เป็นคำตอบเดียวที่โปรแกรมเมอร์สามารถใช้งานได้ซึ่งไม่สามารถจัดทำเอกสารและการประชุมได้ การเขียนโปรแกรมเป็นสิ่งที่โปรแกรมเมอร์ทำและใช่โปรแกรมเมอร์ที่ยอดเยี่ยมสามารถเขียนเอกสารประกอบการทดสอบหน่วย ฯลฯ แต่มาดูกัน - พวกเราส่วนใหญ่ชอบเขียนโปรแกรมเพื่อจัดทำเอกสาร วิธีแก้ปัญหาของเขาคือที่โปรแกรมเมอร์จำรหัสที่ใช้ซ้ำได้และดึงมันออกไปยังคลาสหรือพื้นที่เก็บข้อมูลของตัวเองหรืออะไรก็ตามและโดยความจริงที่ว่ามันถูกแยกออกมันจะกลายเป็นความสามารถในการเรียนรู้ . และนี่คือความสำเร็จโดยการเขียนโปรแกรม ในแบบที่ฉันเห็นมันเป็นแบบนี้: ฉันเพิ่งเขียนสามหน้าที่และมันเกิดขึ้นกับฉันที่คนอื่นควรรู้เกี่ยวกับพวกเขา ฉันสามารถจัดทำเอกสารเขียนบันทึกประกาศในที่ประชุม ฯลฯ - ซึ่งฉันทำได้ แต่ไม่ใช่จุดแข็งของฉัน - หรือ .... ฉันสามารถแยกพวกเขาออกจากชั้นเรียนตั้งชื่อให้ดีทำให้พวกเขาทำงานได้ กล่องดำและติดไว้ที่ไฟล์คลาสอื่น ๆ จากนั้นอีเมลสั้น ๆ ประกาศว่าเป็นเรื่องง่าย นักพัฒนาซอฟต์แวร์คนอื่นสามารถสแกนโค้ดและเข้าใจได้ดีกว่าฟังก์ชั่นแยกที่ใช้ในโค้ดที่พวกเขาไม่เข้าใจ - บริบทนั้นจะถูกลบ …

43 documentation  teamwork  team  code-reuse 

โดยรวมแล้วฉันอยู่ในการเขียนโปรแกรมประมาณ 8 ปีแล้วและดูเหมือนว่าฉันจะต้องพึ่งพาห้องสมุดและตัวอย่างโอเพ่นซอร์สมากขึ้นเรื่อย ๆ (คุณ GitHub! ฉันรู้ว่าในเวลาที่ฉันสามารถเขียนการใช้งานของตัวเอง แต่ฉันชอบที่จะมุ่งเน้นไปที่การออกแบบโดยรวม นี่เป็นเรื่องปกติ (ไม่ใช่สภาพแวดล้อมขององค์กร) หรือไม่ จะเกิดอะไรขึ้นถ้า "การเขียนโปรแกรม" ของฉันไม่มีอะไรมากไปกว่าการติดไลบรารี่ต่าง ๆ เข้าด้วยกัน? ฉันรู้เกี่ยวกับ "ไม่ต้องคิดค้นล้อใหม่" แต่จะเกิดอะไรขึ้นเมื่อคุณไม่ได้ประดิษฐ์ล้อเดียวอีกต่อไป

42 programming-practices  libraries  code-reuse 

ในคำปราศรัยการประชุม goto ในการประชุมระดมความคิดที่กระตุ้นความคิดของ " มูลค่าของคุณค่า " ในเวลา 29 นาทีที่เขาพูดถึงค่าใช้จ่ายในภาษาจาวาและทำให้คำสั่งเช่น เขาหมายถึงอะไร มันเป็นเรื่องจริงเหรอ? ในการค้นหาคำตอบของฉันฉันเจอ: หลักการของความรู้น้อยที่สุด AKA กฎหมายของ Demeterซึ่งสนับสนุนการเชื่อมต่อ API แบบสุญญากาศ Wikipedia ยังแสดงข้อเสียบางประการ วิกฤตเสื้อผ้าของ Kevlin Henney ซึ่งระบุว่าการใช้ไม่ใช่การใช้ซ้ำเป็นเป้าหมายที่เหมาะสม การพูดคุยเรื่อง " Stop Writing Classes " ของ Jack Diederich ซึ่งขัดแย้งกับเรื่องวิศวกรรมโดยทั่วไป เห็นได้ชัดว่าสิ่งใดที่เขียนไม่ดีพอจะไร้ประโยชน์ แต่อินเทอร์เฟซของ API ที่เขียนดีจะป้องกันไม่ให้ใช้รหัสนั้นได้อย่างไร มีตัวอย่างตลอดประวัติศาสตร์ของบางสิ่งบางอย่างที่ทำขึ้นเพื่อจุดประสงค์เดียวที่ถูกใช้เพื่อสิ่งอื่นมากกว่า แต่ในโลกของซอฟต์แวร์ถ้าคุณใช้บางอย่างเพื่อจุดประสงค์ที่ไม่ได้มีไว้สำหรับมันก็มักจะแตก ฉันกำลังมองหาหนึ่งตัวอย่างที่ดีของอินเทอร์เฟซที่ดีที่ป้องกันไม่ให้ใช้รหัสบางอย่างถูกต้อง มีอยู่จริงเหรอ? ฉันไม่สามารถจินตนาการได้

41 java  interfaces  code-reuse  clojure 

เมื่อฉันเริ่มโครงการใหม่ฉันมักจะเริ่มคิดเกี่ยวกับรายละเอียดของการดำเนินการทันที "ฉันจะวาง DataBaseHandler ไว้ที่ไหนฉันควรใช้มันอย่างไรคลาสที่ต้องการใช้มันขยายจาก Abstractclass superclass บางส่วน .. ฉันควรใช้อินเทอร์เฟซหรือไม่ฉันจะใช้อินเทอร์เฟซในระดับใด วิธีในการส่งคำขอและการแยกวิเคราะห์ข้อมูล " ฉันสิ้นสุดการถ่วงเวลานานเพราะฉันต้องการรหัสสำหรับความสามารถในการขยายและการนำกลับมาใช้ใหม่ แต่ฉันรู้สึกว่าแทบจะเป็นไปไม่ได้เลยที่จะคิดถึงอดีตเกี่ยวกับวิธีการนำไปใช้อย่างสมบูรณ์ แล้วถ้าฉันพยายามจะพูดว่า "ขันมันให้เสร็จแล้ว!" ฉันก็ชนกำแพงอิฐอย่างรวดเร็วเพราะรหัสของฉันไม่ได้จัดระเบียบฉันผสมระดับนามธรรมต่าง ๆ เป็นต้น คุณมีเทคนิค / วิธีการอะไรบ้างในการเปิดตัวโครงการใหม่ในขณะที่ตั้งค่าโครงสร้างแบบลอจิคัล / แบบแยกส่วนที่จะขยายได้ดี - -แก้ไข - - นี่เป็นประเภทของคำถามที่ตอบรับยากแล้ว แต่ต้องการได้รับคำติชมเพิ่มเติมดูว่ามีฉันทามติบ้างไหม TDD ฟังดูเจ๋งจริงๆและตรงไปตรงมาฉันหมายถึงการเพิ่มความเร็วในการใช้ JUnit ฯลฯ ในเวลาเดียวกันแฟน ๆ ของ TDD คิดอย่างไรเกี่ยวกับความจริงที่ว่าจุดที่ถูกต้องตามกฎหมายที่เกี่ยวข้องกับการแก้ไข TDD ของฉัน ปัญหาเฉพาะคือ TDD ไม่ได้ตอบคำถามการออกแบบ แน่นอนว่าฉันเห็นด้วยกับ TDD จะช่วยฉันกำหนดสิ่งที่ฉันต้องการจะทำและจากนั้นฉันสามารถค่อยๆทำตามวิธีได้ แต่มีรูปแบบ / โครงสร้างการออกแบบโดยรวมที่แตกต่างกันมากมายที่ทุกคนสามารถผ่านการทดสอบหน่วยได้ นั่นเป็นเพียงแค่มันทดสอบหน่วยเดียว …

37 project-management  design-patterns  code-quality  paradigms  code-reuse 

ฉันเคยเห็นหลายโพสต์เกี่ยวกับการเขียนแอปพลิเคชั่นที่ไม่ดีประสบการณ์ของผู้คนที่มีต่อมันที่นี่ในโปรแกรมเมอร์และบทความที่Joel Spolsky เตรียมไว้ในหัวข้อ แต่ไม่มีหลักฐานหรือกรณีศึกษาที่ยาก นอกเหนือจากสองตัวอย่างที่โจเอลให้และโพสต์อื่น ๆ ที่นี่คุณจะทำอย่างไรกับโค้ดเบสที่ไม่ดีและคุณจะตัดสินใจอย่างไรว่าจะทำอย่างไรโดยอ้างอิงจากการศึกษาจริง ในกรณีนี้มีลูกค้าสองคนที่ฉันรู้ว่าทั้งคู่มีรหัสเดิม พวกเขาเดินกะเผลกไปพร้อมกับมันเพราะอย่างหนึ่งที่พวกเขาค้นพบการเขียนซ้ำเป็นหายนะมันมีราคาแพงและไม่ได้ทำงานเพื่อปรับปรุงรหัสมากนัก ลูกค้ารายนั้นมีตรรกะทางธุรกิจที่ซับซ้อนมากเนื่องจากพบผู้เขียนใหม่ได้อย่างรวดเร็ว ในทั้งสองกรณีนี้เป็นแอปพลิเคชั่นที่สำคัญต่อภารกิจซึ่งสร้างรายได้มากมายให้กับ บริษัท สิ่งที่พยายามเขียนใหม่รู้สึกว่าพวกเขาจะชนกำแพงอิฐหากซอฟต์แวร์ดั้งเดิมไม่ได้รับการอัพเกรดในบางจุดในอนาคต สำหรับฉันแล้วความเสี่ยงประเภทนี้รับประกันการวิจัยและการวิเคราะห์เพื่อให้มั่นใจว่าเส้นทางที่ประสบความสำเร็จ มีกรณีศึกษาจริงที่ตรวจสอบเรื่องนี้หรือไม่? ฉันไม่ต้องการทดลองเขียนบทใหม่โดยไม่ทราบวิธีปฏิบัติที่ดีที่สุดข้อผิดพลาดและความสำเร็จจากการศึกษาจริง ควันหลง: โอเคหลังจากค้นหาเพิ่มเติมฉันได้พบสามบทความที่น่าสนใจเกี่ยวกับกรณีศึกษา: เขียนหรือนำมาใช้ใหม่ พวกเขาทำการศึกษาเกี่ยวกับแอป Cobol ที่ถูกแปลงเป็น Java อื่น ๆ ที่อยู่ในซอฟท์แว Reuse: นักพัฒนาประสบการณ์และการรับรู้ การใช้ซ้ำหรือเขียนซ้ำการศึกษาค่าใช้จ่ายในการบำรุงรักษาอีกครั้งกับการเขียนซ้ำ ฉันเพิ่งพบบทความอื่นในเรื่อง: The Great Rewrite ดูเหมือนว่าผู้เขียนจะตีประเด็นสำคัญบางอย่าง นอกจากนี้ยังมีแนวคิดของการสร้างต้นแบบโดยใช้เทคโนโลยีสแต็คใหม่ที่เสนอและการวัดว่า devs หยิบมันได้รวดเร็วแค่ไหน ทั้งหมดนี้เป็นเหมือนโหมโรงของการเขียนซึ่งฉันคิดว่าเป็นความคิดที่ยอดเยี่ยม!

36 source-code  planning  code-reuse  rewrite 

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

32 libraries  personal-projects  code-reuse 

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

31 licensing  code-reuse 

การใช้รหัสซ้ำเป็นปัญหา ฉันคิดเกี่ยวกับคำถามนี้ในการส่งมอบซอฟต์แวร์และผมเก็บไว้กลับไปที่ปัญหาของการเข้ามาทำซ้ำและ / หรือการทำซ้ำ มันสำคัญเพราะถ้าคุณไม่ทำซ้ำโครงการมันจะยากขึ้นในการปรับปรุงกระบวนการที่คุณใช้ในการสร้างโครงการ วิศวกรรมเกี่ยวข้องกับการปรับปรุงกระบวนการที่เกี่ยวข้องกับการออกแบบและการก่อสร้างอย่างต่อเนื่องเพื่อผลิตโครงการที่มีคุณภาพสูงขึ้น ซอฟต์แวร์สามารถพึ่งพาอย่างหนักเมื่อนำมาใช้ใหม่เนื่องจากรูปแบบดิจิทัล แทนที่จะเขียนโมดูลเราเพียงเรียกมันอีกครั้งหรือคัดลอกไปยังระบบอื่น ตัวอย่างบางส่วนคือการรับรองความถูกต้อง / เข้าสู่ระบบหรืออาจเป็นฟังก์ชั่นการบันทึก มีตัวอย่างมากมายที่เป็นที่รู้จักกันดีสำหรับประเภทเหล่านั้นและภูมิปัญญาดั้งเดิมคือการนำสิ่งที่มีอยู่กลับมาใช้ใหม่ การเปรียบเทียบบางสาขากับสาขาอื่น การก่อสร้าง ในทางตรงกันข้ามการก่อสร้างระบบทางกายภาพ (อาคารสะพาน) ไม่ได้อยู่ใกล้แค่นำมาใช้ซ้ำ เป็นความจริงที่ว่าพิมพ์เขียวของบ้านสามารถนำกลับมาใช้ซ้ำได้หลายครั้งเพื่อสร้างสำเนาบ้านเดียวกัน แต่การก่อสร้างจะต้องดำเนินการทุกครั้ง ตัดและวางไม่ทำงานอย่างนั้นในโลกอะนาล็อก พิมพ์เขียว Bridge เป็นการนำกลับมาใช้ใหม่ได้น้อยกว่าเนื่องจากสภาพของไซต์จะแตกต่างกันไป ผู้สร้างต้นแบบเป็นผู้เชี่ยวชาญที่ได้รับการยอมรับว่ามีการออกแบบและ / หรือสร้างสิ่งของหลายสิบหลายร้อยหรือหลายพันรายการ ยกตัวอย่างเช่นFrank Lloyd Wrightdesigned more than 1,000 structures and completed 532 worksโลกสถาปนิกที่มีชื่อเสียงและนักออกแบบ เปรียบเทียบกับAnders Hejlsbergผู้ออกแบบ“ just” ห้าภาษา (Turbo Pascal; Delphi; J ++; C #; Typescript) เป็นการเปรียบเทียบที่ไม่ยุติธรรมเนื่องจากหลายโดเมนแตกต่างกัน …

25 development-process  code-reuse 

ฉันมีหลายคลาสที่สืบทอดมาจากคลาสพื้นฐานทั่วไป Tชั้นฐานมีการเก็บรวบรวมวัตถุหลายของชนิด แต่ละคลาสเด็กต้องสามารถคำนวณค่าที่สอดแทรกจากการรวบรวมวัตถุ แต่เนื่องจากคลาสย่อยใช้ชนิดที่แตกต่างกันการคำนวณจึงแตกต่างกันเล็กน้อยจากคลาสหนึ่งไปอีกชั้น จนถึงตอนนี้ฉันได้คัดลอก / วางรหัสของฉันจากชั้นหนึ่งไปอีกชั้นหนึ่งและทำการแก้ไขเล็กน้อยกับแต่ละรายการ แต่ตอนนี้ฉันกำลังพยายามลบรหัสที่ซ้ำกันและแทนที่ด้วยวิธีการแก้ไขทั่วไปในคลาสพื้นฐานของฉัน อย่างไรก็ตามนั่นเป็นการพิสูจน์ว่าเป็นเรื่องยากมากและวิธีแก้ปัญหาทั้งหมดที่ฉันคิดว่าดูเหมือนซับซ้อนเกินไป ฉันเริ่มคิดว่าหลักการ DRY ไม่ได้นำไปใช้มากในสถานการณ์แบบนี้ แต่ฟังดูเหมือนเป็นการดูหมิ่น ความซับซ้อนเท่าไหร่เมื่อพยายามลบการทำสำเนารหัสมากเกินไป? แก้ไข: ทางออกที่ดีที่สุดที่ฉันสามารถทำได้คือ: ชั้นฐาน: protected T GetInterpolated(int frame) { var index = SortedFrames.BinarySearch(frame); if (index >= 0) return Data[index]; index = ~index; if (index == 0) return Data[index]; if (index >= Data.Count) return Data[Data.Count - 1]; return …

24 c#  code-quality  complexity  code-reuse  dry 

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

22 legal  code-reuse