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

มีแนวทางใดบ้างในการตัดสินใจว่าคลาสควรอยู่ในชุด / DLL ของตัวเองหรือไม่? ฉันมักจะเห็นโรงเรียนแห่งความคิดสองแห่ง: 1) "การจัดกลุ่ม" ของคลาสทุกคลาสนั้นอยู่ใน DLL ของตัวเองเช่นที่เก็บบริการ DTO โครงสร้างพื้นฐานเป็นต้น 2) ทุกอย่างควรอยู่ใน DLL เดียว แต่แยกออกจาก namespaces / folder เช่นมี "Core" DLL ที่มี namespaces เพิ่มเติมเช่น Core.Repositories, Core.Services, Core.DTO เป็นต้น ที่ทำงานเราเพิ่งรวบรวมทุกอย่างในสภาเดียวที่เรียกว่า "ธุรกิจ" มีบางโฟลเดอร์ แต่ไม่มีการแยกที่แท้จริง - วัตถุทางธุรกิจ (ด้วยตรรกะซึ่งบางอันไม่ควรเป็นคลาส) จะถูกรวมเข้าในโฟลเดอร์ "BusinessObjects" โดยไม่สนใจ สิ่งที่ใช้ในคลาสมากกว่าหนึ่งอยู่ในโฟลเดอร์ "Core" ยูทิลิตี้อยู่ในโฟลเดอร์ "ยูทิลิตี้" โครงสร้างพื้นฐานการเข้าถึงข้อมูลคือโฟลเดอร์ "ข้อมูล" - คุณจะได้รับแนวคิด สำหรับโมดูลใหม่ที่ฉันกำลังทำงานอยู่ฉันต้องการ / …

22 c#  architecture  directory-structure 

ในหนังสือการออกแบบที่แตกต่างกันที่ฉันอ่านบางครั้งการเน้นอย่างมากถูกวางลงบนจำนวนวิธีที่ชั้นเรียนต้องมี (พิจารณาจากภาษา OO เช่น java หรือ C # เป็นต้น) บ่อยครั้งที่ตัวอย่างที่รายงานในหนังสือเหล่านี้มีความประณีตและเรียบง่าย แต่แทบจะไม่ครอบคลุมกรณีที่ "ร้ายแรง" หรือซับซ้อน อย่างไรก็ตามช่วงนี้ดูเหมือนจะอยู่ระหว่าง 5 ถึง 8 ในโครงการฉันได้พัฒนาคลาส "Note" โดยมีคุณสมบัติเป็น attribuse: Title, Desctiption, CreateDate เป็นต้นจากนั้นมีวิธีการพื้นฐานเช่น: getRelations (ถ้าบันทึกถูกกำหนดให้กับเอกสารต่าง ๆ ), getExpiryDate, ect อย่างไรก็ตามการดำเนินการในการพัฒนาแอปพลิเคชันจำเป็นต้องมีฟังก์ชันการทำงานที่มากขึ้นและดังนั้นจึงมีวิธีการมากขึ้น ฉันรู้ว่าชั้นเรียนมีวิธีการน้อยกว่า นี่เป็นข้อได้เปรียบที่ดีในแง่ของความเป็นโมดูลและการนำกลับมาใช้ใหม่รวมถึงการแก้ไขที่ง่ายขึ้น โดยวิธีการถ้าในบริบทของเราไม่มีความต้องการ (หรือแม้กระทั่งความรู้สึก) ในการสร้างคลาสย่อยและฟังก์ชั่นที่จำเป็นทั้งหมดเกี่ยวข้องกับคลาสนั้นเราสามารถแนบวิธีการได้อีกกี่วิธี ฉันยอมรับว่ามีมากกว่า 15 วิธีจากนั้นอาจต้องมีการออกแบบใหม่เล็กน้อย แต่แม้ในกรณีนั้นหากการลบวิธีการหรือมรดกบางอย่างไม่ใช่ตัวเลือกซึ่งจะเป็นวิธีที่เหมาะสมหรือไม่

22 design  programming-practices 

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

22 testing  legacy 

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

22 open-source  licensing  copyright 

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

22 programming-languages  education 

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

22 stack  memory-usage  stackoverflow 

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

22 algorithms  architecture  parallel-programming 

คำถามนี้ถูกโยกย้ายจาก Stack Overflow เพราะสามารถตอบได้ใน Software Engineering Stack Exchange อพยพ 6 ปีที่แล้ว ฉันส่งอีเมลแจ้งเตือนนักพัฒนาของเราว่าการใช้คำว่า 'จะ' ในข้อกำหนดที่ได้รับของคุณไม่ควรทำตามข้อกำหนดด้านการใช้งานของคุณ เมื่อเขียนข้อกำหนดของฟังก์ชันคำว่า 'ต้องใช้' จะใช้เพื่ออธิบายฟังก์ชันที่ข้อกำหนดที่ได้รับจะต้องทำ ที่ได้มา = ความต้องการของระบบจะเป็นความต้องการใช้งาน = ระบบจะต้องทำ requirment มันถูกส่งกลับโดยผู้อาวุโสของเราคนหนึ่งว่านั่นเป็นสิ่งที่ผิดและควรจะใช้ในทุก ๆ ความต้องการ ฉันผิดตรงนี้และควรใช้ทุกความต้องการ ฉันไม่สามารถค้นหาข้อมูลสำรองได้

22 requirements 

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

22 git  refactoring  branching  gitflow 

เหตุใดจึงถูกargvประกาศให้เป็น "ตัวชี้ไปยังตัวชี้ไปยังดัชนีแรกของอาร์เรย์" แทนที่จะเป็น "ตัวชี้ไปยังดัชนีแรกของอาร์เรย์" ( char* argv) เหตุใดจึงต้องใช้แนวคิดของ "ตัวชี้ไปยังตัวชี้"

21 c++  c 

ตามที่Wikipedia คำว่า "bootstrapping" ในบริบทของการเขียนคอมไพเลอร์หมายถึงสิ่งนี้ : ในวิทยาการคอมพิวเตอร์ bootstrapping เป็นกระบวนการของการเขียนคอมไพเลอร์ (หรือแอสเซมเบลอร์) ในภาษาการเขียนโปรแกรมต้นฉบับที่ตั้งใจจะคอมไพล์ การใช้เทคนิคนี้นำไปสู่การคอมไพล์ด้วยตนเองที่โฮสต์ และฉันสามารถเข้าใจวิธีการที่จะทำงาน อย่างไรก็ตามเรื่องราวดูเหมือนจะแตกต่างกันเล็กน้อยสำหรับล่าม ตอนนี้แน่นอนมันเป็นไปได้ที่จะเขียนล่ามด้วยตนเอง นั่นไม่ใช่สิ่งที่ฉันขอ สิ่งที่ฉันขอจริงคือมันเป็นไปได้ที่จะทำให้ตัวเองเป็นเจ้าภาพอิสระล่ามของเดิมล่ามแรก เพื่ออธิบายสิ่งที่ฉันหมายถึงพิจารณาตัวอย่างนี้: คุณเขียนรุ่นล่ามครั้งแรกของคุณในภาษาของXและล่ามเป็นภาษาใหม่ที่คุณกำลังสร้างที่เรียกว่าY คุณใช้คอมไพเลอร์ภาษาXเพื่อสร้างไฟล์ปฏิบัติการ ขณะนี้คุณสามารถตีความไฟล์ที่เขียนในภาษาของคุณใหม่Yใช้ล่ามที่เขียนในภาษาX ทีนี้เท่าที่ฉันเข้าใจเพื่อที่จะสามารถ "บู๊ตสแตรป" ล่ามที่คุณเขียนเป็นภาษาXคุณต้องเขียนล่ามเป็นภาษาYอีกครั้ง แต่นี่คือการจับ: แม้ว่าคุณจะเขียนล่ามทั้งในภาษาYคุณยังจะต้องเดิมล่ามที่คุณเขียนในภาษาX เนื่องจากการเรียกใช้ล่ามในภาษาYคุณจะต้องตีความไฟล์ต้นฉบับ แต่สิ่งที่จะแปลความหมายไฟล์ต้นฉบับ? แน่นอนมันไม่มีอะไรเลยดังนั้นคุณถูกบังคับให้ต้องใช้ล่ามคนแรก ไม่ว่าคุณจะมีล่ามใหม่กี่คนในภาษาYคุณจะต้องใช้ล่ามตัวแรกที่เขียนด้วยXเพื่อตีความล่ามต่อไป สิ่งนี้ดูเหมือนจะเป็นปัญหาเพียงเพราะธรรมชาติของล่าม อย่างไรก็ตามในด้านพลิกนี้บทความวิกิพีเดียล่ามจริงพูดเกี่ยวกับล่ามตัวเองโฮสติ้ง นี่เป็นข้อความที่ตัดตอนมาเล็กน้อยซึ่งมีความเกี่ยวข้อง: Self-interpreter เป็นล่ามภาษาโปรแกรมที่เขียนในภาษาโปรแกรมซึ่งสามารถตีความได้เอง ตัวอย่างคือล่ามพื้นฐานที่เขียนในภาษาเบสิก ตัวแปลภาษาเองเกี่ยวข้องกับคอมไพเลอร์ที่โฮสต์ด้วยตนเอง หากไม่มีคอมไพเลอร์สำหรับภาษาที่จะตีความการสร้างตัวแปลภาษาเองจำเป็นต้องมีการใช้งานภาษาในภาษาโฮสต์ (ซึ่งอาจเป็นภาษาโปรแกรมหรือแอสเซมเบลอร์อื่น) ด้วยการมีล่ามคนแรกเช่นนี้ระบบจะถูกบูตและรุ่นใหม่ของล่ามสามารถพัฒนาในภาษาของตัวเอง มันยังไม่ชัดเจนสำหรับฉันว่าจะทำอย่างไร ดูเหมือนว่าไม่ว่าอะไรก็ตามคุณจะถูกบังคับให้ใช้ล่ามรุ่นแรกที่เขียนด้วยภาษาโฮสต์ ตอนนี้บทความดังกล่าวข้างต้นเชื่อมโยงไปยังบทความอื่นในวิกิพีเดียซึ่งให้ตัวอย่างบางส่วนของควรล่ามตัวเองโฮสติ้ง เมื่อตรวจสอบอย่างใกล้ชิด แต่ดูเหมือนว่า "ล่าม" เป็นส่วนสำคัญของล่ามที่จัดการโฮสต์ด้วยตนเอง (โดยเฉพาะอย่างยิ่งที่พบบ่อยเช่น PyPy หรือ Rubinius) …

21 language-agnostic  compiler  interpreters 

ฉันกำลังประเมิน CMS โอเพนซอร์สที่ชื่อว่า Piranha ( http://piranhacms.org/ ) เพื่อใช้ในโครงการใดโครงการหนึ่งของฉัน ฉันพบรหัสต่อไปนี้น่าสนใจและสับสนเล็กน้อยอย่างน้อยสำหรับฉัน บางอย่างช่วยให้ฉันเข้าใจได้หรือไม่ว่าทำไมห้องเรียนถึงได้รับมรดกจากประเภทเดียวกัน? public abstract class BasePage<T> : Page<T> where T : BasePage<T> { /// <summary> /// Gets/sets the page heading. /// </summary> [Region(SortOrder = 0)] public Regions.PageHeading Heading { get; set; } } ถ้าชั้นBasePage<T>จะถูกกำหนดไว้ทำไมสืบทอดมาจากPage<T> where T: BasePage<T>? มีจุดประสงค์เฉพาะอะไรบ้าง

21 c#  architecture  .net  cms 

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

21 anti-patterns  comments 

ฉันกำลังทดสอบว่าฟังก์ชั่นทำตามที่คาดไว้ในรายการ ดังนั้นฉันต้องการทดสอบ f(null) -> null f(empty) -> empty f(list with one element) -> list with one element f(list with 2+ elements) -> list with the same number of elements, doing what expected วิธีที่ดีที่สุดคืออะไร? การทดสอบทุกกรณีในการทดสอบ (method) เดียวกันภายใต้ชื่อ "WorksAsExpected" วางหนึ่งการทดสอบสำหรับแต่ละกรณีจึงมี "WorksAsExpectedWhenNull" "WorksAsExpectedWhenEmpty" "WorksAsExpectedWhenSingleElement" "WorksAsExpectedWhenMoreElements" อีกทางเลือกหนึ่งที่ฉันไม่ได้คิด :-)

21 unit-testing  tdd 

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

21 c#  c++  object-oriented-design  abstract-class