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

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน3 ปีที่ผ่านมา ฉันอธิบายให้นักเรียนฟังว่าการทดสอบที่เท่ากันไม่น่าเชื่อถือสำหรับตัวแปรลอยตัว แต่ใช้ได้สำหรับจำนวนเต็ม หนังสือที่ฉันใช้บอกว่าง่ายต่อการอ่าน> และ <กว่า> = และ <= ฉันเห็นด้วยบ้าง แต่ใน For For? ไม่ชัดเจนว่าการวนซ้ำระบุค่าเริ่มต้นและสิ้นสุดหรือไม่ ฉันไม่มีสิ่งที่ผู้เขียนตำราเรียนถูกต้องหรือไม่? อีกตัวอย่างหนึ่งคือในการทดสอบช่วงเช่น: ถ้าคะแนน> 89 grade = 'A' อื่นถ้าคะแนน> 79 grade = 'B' ... ทำไมไม่พูดเพียงว่า: if score> = 90?

15 loops 

ฉันกำลังสร้างแอปพลิเคชันอยู่สองสามเดือนและฉันก็ตระหนักถึงรูปแบบที่ปรากฏ: logger.error(ERROR_MSG); throw new Exception(ERROR_MSG); หรือเมื่อจับ: try { // ...block that can throw something } catch (Exception e) { logger.error(ERROR_MSG, e); throw new MyException(ERROR_MSG, e); } ดังนั้นเมื่อใดก็ตามที่ฉันโยนหรือจับข้อยกเว้นฉันจะเข้าสู่ระบบ อันที่จริงแล้วนั่นเป็นการบันทึกเกือบทั้งหมดที่ฉันทำในแอปพลิเคชัน ดังนั้นในฐานะโปรแกรมเมอร์ฉันหลีกเลี่ยงการทำซ้ำ ดังนั้นฉันตัดสินใจย้ายตัวบันทึกไปยังการสร้างข้อยกเว้นดังนั้นเมื่อใดก็ตามที่ฉันกำลังสร้างข้อยกเว้นสิ่งต่าง ๆ จะถูกบันทึกไว้ แน่นอนฉันสามารถสร้าง ExceptionHelper ซึ่งทำให้เกิดข้อยกเว้นสำหรับฉันได้ แต่นั่นจะทำให้รหัสของฉันยากต่อการตีความและยิ่งกว่านั้นคอมไพเลอร์ก็ไม่สามารถจัดการกับมันได้โดยไม่เข้าใจว่าจะมีการโทรหาสมาชิกคนนั้น โยนทันที ดังนั้นนี่เป็นรูปแบบการต่อต้านหรือไม่ ถ้าเป็นเช่นนั้นทำไม

15 exceptions  logging 

ในขณะที่ออกแบบไลบรารี C ++ 'จริงจัง' ครั้งแรกของฉันฉันถามตัวเอง: มันเป็นสไตล์ที่ดีหรือไม่ที่จะได้รับการยกเว้นจากสิ่งstd::exceptionนั้น แม้หลังจากอ่านเสร็จ การออกแบบคลาสยกเว้น ข้อยกเว้น 'จำนวนที่ดี' ที่จะนำไปใช้กับห้องสมุดของฉันคืออะไร ฉันยังไม่แน่ใจ เพราะนอกเหนือจากการปฏิบัติทั่วไป (แต่อาจจะไม่ดี) ฉันจะถือว่าในฐานะผู้ใช้ห้องสมุดว่าฟังก์ชั่นห้องสมุดจะstd::exceptionแสดงเฉพาะเมื่อฟังก์ชั่นไลบรารีมาตรฐานล้มเหลวในการใช้งานไลบรารีและมันไม่สามารถทำอะไรได้เลย แต่ยังคงเมื่อเขียนรหัสโปรแกรมสำหรับฉันมันสะดวกมากและยัง IMHO std::runtime_errorดูดีเพียงแค่โยน ผู้ใช้ของฉันยังสามารถพึ่งพาส่วนต่อประสานขั้นต่ำที่กำหนดเช่นwhat()รหัสหรือ และตัวอย่างเช่นผู้ใช้ของฉันให้ข้อโต้แย้งที่ผิดพลาดสิ่งที่จะสะดวกกว่าการโยน a std::invalid_argumentใช่มั้ย ดังนั้นรวมกับการใช้งานยังร่วมกันของมาตรฐาน :: ข้อยกเว้นที่ฉันเห็นในรหัสผู้อื่น: ทำไมไม่ไปให้ดียิ่งขึ้นและได้รับมาจากชั้นยกเว้นของคุณเอง (เช่น lib_foo_exception) std::exceptionและจาก คิด?

15 c++  exceptions 

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

15 object-oriented  architecture  functional-programming 

ฉันกำลังเขียนแอปพลิเคชัน OOP ขนาดกลางใน C ++ เป็นวิธีฝึกหลักการ OOP ฉันมีหลายคลาสในโครงการของฉันและบางส่วนจำเป็นต้องเข้าถึงพารามิเตอร์การกำหนดค่าใช้งาน พารามิเตอร์เหล่านี้อ่านจากแหล่งต่าง ๆ ในระหว่างการเริ่มต้นแอปพลิเคชัน บางไฟล์ถูกอ่านจากไฟล์ปรับแต่งในผู้ใช้ที่บ้านบางคนเป็นอาร์กิวเมนต์บรรทัดคำสั่ง (argv) ConfigBlockดังนั้นผมจึงสร้างชั้นเรียน คลาสนี้อ่านแหล่งพารามิเตอร์ทั้งหมดและเก็บไว้ในโครงสร้างข้อมูลที่เหมาะสม ตัวอย่างคือชื่อพา ธ และชื่อไฟล์ที่ผู้ใช้สามารถเปลี่ยนได้ในไฟล์กำหนดค่าหรือ - --verbose CLI flag จากนั้นหนึ่งสามารถโทรConfigBlock.GetVerboseLevel()เพื่ออ่านพารามิเตอร์เฉพาะนี้ คำถามของฉัน: เป็นการดีหรือไม่ที่จะรวบรวมข้อมูลการกำหนดค่ารันไทม์ทั้งหมดในชั้นเดียว? จากนั้นชั้นเรียนของฉันต้องการเข้าถึงพารามิเตอร์เหล่านี้ทั้งหมด ฉันสามารถคิดหลายวิธีในการบรรลุเป้าหมายนี้ แต่ฉันไม่แน่ใจว่าควรใช้วิธีใด คอนสตรัคเตอร์ของคลาสสามารถอ้างอิงถึง ConfigBlock ของฉันได้ public: MyGreatClass(ConfigBlock &config); หรือพวกเขาเพียงแค่รวมส่วนหัว "CodingBlock.h" ซึ่งมีคำจำกัดความของ CodingBlock ของฉัน: extern CodingBlock MyCodingBlock; จากนั้นไฟล์คลาส. cpp เท่านั้นที่ต้องรวมและใช้สิ่งที่ ConfigBlock ไฟล์. h ไม่แนะนำอินเทอร์เฟซนี้กับผู้ใช้ของคลาส อย่างไรก็ตามอินเทอร์เฟซสำหรับ …

15 design-patterns  object-oriented  c++ 

ทำไมจึงเป็นประโยชน์ในการใช้รูปแบบกลยุทธ์หากคุณสามารถเขียนโค้ดของคุณใน if / then cases? ตัวอย่างเช่น: ฉันมีคลาส TaxPayer และหนึ่งในวิธีการของมันจะคำนวณภาษีโดยใช้อัลกอริทึมที่แตกต่างกัน เหตุใดจึงไม่มีกรณีและกรณีและคิดว่าอัลกอริธึมที่จะใช้ในวิธีการนั้นแทนที่จะใช้รูปแบบกลยุทธ์หรือไม่ นอกจากนี้ทำไมคุณไม่สามารถใช้วิธีแยกต่างหากสำหรับแต่ละอัลกอริทึมในคลาส TaxPayer ได้ นอกจากนี้มันหมายความว่าอัลกอริทึมที่จะเปลี่ยนที่รันไทม์?

15 design  design-patterns  object-oriented-design  patterns-and-practices  strategy 

ฉันกำลังอ่าน "การโปรแกรม C ของ King KN" และพบข้อความต่อไปนี้: เราพูดถึงการใช้นิพจน์sizeof(a)/sizeof(a[0])เพื่อคำนวณจำนวนองค์ประกอบในอาร์เรย์ การแสดงออกsizeof(a)/sizeof(t)ที่ t คือประเภทขององค์ประกอบก็จะทำงานได้เช่นกัน แต่ก็ถือว่าเป็นเทคนิคที่ด้อยกว่า ทำไมจึงถือว่าเป็นเทคนิคที่ด้อยกว่า

15 c  array 

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

15 unit-testing  testing 

ฉันกำลังทำงานเกี่ยวกับการออกแบบแอปพลิเคชันที่ประกอบด้วยสามส่วน: เธรดเดียวที่เฝ้าดูเหตุการณ์บางอย่างที่เกิดขึ้น (การสร้างไฟล์คำขอภายนอก ฯลฯ ) เธรดผู้ปฏิบัติงาน N ที่ตอบสนองต่อเหตุการณ์เหล่านี้โดยการประมวลผล (ผู้ปฏิบัติงานแต่ละกระบวนการและใช้เหตุการณ์เดียวและการประมวลผลอาจใช้เวลาแปรผัน) คอนโทรลเลอร์ที่จัดการเธรดเหล่านั้นและจัดการข้อผิดพลาด (การรีสตาร์ทเธรดการบันทึกผลลัพธ์) แม้ว่านี่จะค่อนข้างพื้นฐานและไม่ยากที่จะนำมาใช้ แต่ฉันก็สงสัยว่ามันจะเป็นวิธีที่ "ถูกต้อง" (ในกรณีที่เป็นรูปธรรมนี้ใน Java แต่คำตอบที่เป็นนามธรรมก็สูงขึ้นเช่นกัน) กลยุทธ์ทั้งสองมาถึงใจ: ผู้สังเกตการณ์ / สังเกตได้:ผู้สังเกตการณ์จะเฝ้าสังเกตด้ายดู ในกรณีที่มีเหตุการณ์เกิดขึ้นคอนโทรลเลอร์จะได้รับแจ้งและสามารถมอบหมายงานใหม่ให้กับเธรดอิสระจากกลุ่มเธรดแคชที่ใช้ซ้ำได้ (หรือรอและแคชงานในคิว FIFO หากเธรดทั้งหมดไม่ว่างในขณะนี้) เธรดผู้ปฏิบัติงานใช้ Callable และส่งคืนผลลัพธ์ที่สำเร็จพร้อมกับผลลัพธ์ (หรือค่าบูลีน) หรือส่งคืนพร้อมข้อผิดพลาดในกรณีนี้ผู้ควบคุมอาจตัดสินใจว่าจะทำอย่างไร (ขึ้นอยู่กับลักษณะของข้อผิดพลาดที่เกิดขึ้น) ผู้ผลิต / ผู้บริโภค : เธรดการเฝ้าดูที่ใช้ร่วมกัน BlockingQueue กับตัวควบคุม (เหตุการณ์คิว) และตัวควบคุมที่ใช้ร่วมกันสองกับคนงานทั้งหมด (งานคิวและผลคิว) ในกรณีที่เกิดเหตุการณ์ด้ายเฝ้าดูทำให้วัตถุงานในคิวเหตุการณ์ คอนโทรลเลอร์ใช้งานใหม่จาก event-queue ตรวจสอบและวางไว้ใน task-queue ผู้ปฏิบัติงานแต่ละคนรองานใหม่และรับ / ใช้งานจากคิวงาน (มาก่อนได้รับก่อนจัดการโดยคิวเอง) …

15 java  architecture  concurrency  observer-pattern  producer-consumer 

คำถาม : เป็นวิธีที่เหมาะสมในการแก้ไขข้อผิดพลาดที่คิดว่าผู้ใช้ปลายทางเป็นคุณสมบัติคืออะไร? การทำอย่างละเอียด : ฉันคาดเดาว่าหากมีผู้ใช้จำนวนมากคาดหวังว่ามันจะเป็นฟีเจอร์มันควรจะอยู่ที่ "ไม่ได้ผสม" หรือ "คงที่" เพื่อให้มีเสถียรภาพมากขึ้นหรือไม่ อย่างไรก็ตามจะเกิดอะไรขึ้นถ้าผู้ใช้จำนวนน้อยมากคาดหวังว่ามันจะเป็นคุณสมบัติ ... พูด 0.1% หรือ 1% และข้อผิดพลาดนี้จะต้องได้รับการแก้ไข ในทางทฤษฎีเนื่องจากนี่เป็นการแก้ไขบั๊กเล็กน้อยจึงสามารถมีคุณสมบัติเป็น PATCH โดยพิจารณาจากการกำหนดเวอร์ชันแบบ semantic: xyZ อย่างไรก็ตามเนื่องจากความเข้ากันได้แบบย้อนกลับ มันจะยังคงมีคุณสมบัติเป็นแพทช์ (เพราะมันไม่ได้มีวัตถุประสงค์เพื่อเป็นคุณสมบัติ) ตราบใดที่มันเป็นเอกสาร? แก้ไข: ในกรณีเฉพาะนี้มันเป็นข้อผิดพลาดใน API ของห้องสมุดที่ใช้ภายในที่นักพัฒนาอื่นใช้

15 versioning  bug  features  semantic-versioning 

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

15 licensing  gpl 

ฉันค่อนข้างใหม่สำหรับ TDD และฉันมีปัญหาในการสร้างการทดสอบครั้งแรกของฉันเมื่อมันมาก่อนรหัสการติดตั้งใด ๆ หากไม่มีกรอบในการติดตั้งโค้ดฉันมีอิสระที่จะเขียนการทดสอบครั้งแรกของฉันได้ แต่ฉันต้องการ แต่มันก็ดูจะเสียไปโดยวิธีการคิดแบบ Java / OO ของฉันเสมอ ตัวอย่างเช่นในGithub ConwaysGameOfLifeของฉันตัวอย่างการทดสอบครั้งแรกที่ฉันเขียน (rule1_zeroNeighbours) ฉันเริ่มต้นด้วยการสร้างวัตถุ GameOfLife ที่ยังไม่ได้ใช้งาน เรียกว่าชุดวิธีการที่ไม่มีอยู่วิธีการขั้นตอนที่ไม่มีอยู่วิธีรับที่ไม่มีอยู่แล้วใช้การยืนยัน การทดสอบพัฒนาขึ้นเมื่อฉันเขียนการทดสอบและปรับโครงสร้างใหม่ แต่เดิมแล้วมันมีลักษณะดังนี้: @Test public void rule1_zeroNeighbours() { GameOfLife gameOfLife = new GameOfLife(); gameOfLife.set(1, 1, true); gameOfLife.step(); assertEquals(false, gameOfLife.get(1, 1)); } สิ่งนี้รู้สึกแปลก ๆ เนื่องจากฉันถูกบังคับให้ออกแบบการนำไปใช้ตามวิธีที่ฉันตัดสินใจในช่วงแรกนี้เพื่อเขียนการทดสอบครั้งแรก ในวิธีที่คุณเข้าใจ TDD มันโอเคไหม? ฉันดูเหมือนจะปฏิบัติตามหลักการ TDD / XP ในการทดสอบและการใช้งานของฉันที่พัฒนาตลอดเวลาด้วยการปรับโครงสร้างใหม่และดังนั้นหากการออกแบบเริ่มต้นนี้ได้พิสูจน์แล้วว่าไร้ประโยชน์มันจะเปิดให้มีการเปลี่ยนแปลง แต่รู้สึกว่าฉันกำลังบังคับทิศทาง …

15 java  testing  tdd  extreme-programming 

ในภาษาเชิงวัตถุที่สนับสนุนพารามิเตอร์ประเภททั่วไป (เรียกอีกอย่างว่าคลาสเทมเพลตและตัวแปรหลายรูปแบบ แต่แน่นอนว่าชื่อแต่ละชื่อมีความหมายที่แตกต่างกัน) มันมักจะเป็นไปได้ที่จะระบุข้อ จำกัด ประเภทในพารามิเตอร์ประเภทเช่นนั้น จากประเภทอื่น ตัวอย่างเช่นนี่คือไวยากรณ์ใน C #: //for classes: class ExampleClass<T> where T : I1 { } //for methods: S ExampleMethod<S>(S value) where S : I2 { ... } อะไรคือเหตุผลที่ใช้ประเภทอินเตอร์เฟสจริงมากกว่าชนิดที่ จำกัด โดยอินเตอร์เฟสเหล่านั้น ตัวอย่างเช่นอะไรคือเหตุผลในการสร้างวิธีการเซ็นชื่อI2 ExampleMethod(I2 value)?

15 object-oriented  type-systems  generics 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน4 ปีที่แล้ว สมมติว่าฉันได้เผยแพร่โค้ดบางส่วนแล้วและได้ยกเลิกการสนใจลิขสิทธิ์ทั้งหมดไปยังโค้ดนั้นด้วยสิทธิ์ใช้งานที่อนุญาตอย่างมาก (เช่นไม่มีใบอนุญาต ) บริษัท สามารถนำรหัสของฉันออกเผยแพร่ภายใต้สิทธิ์ใช้งานที่เป็นกรรมสิทธิ์จากนั้นฟ้องฉันเพราะละเมิดสัญญาอนุญาตใหม่ได้หรือไม่

15 licensing  distribution 

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว ฉันถูกต้องหรือไม่ที่จะสันนิษฐานว่าผู้ใช้ปลายทางส่วนใหญ่ใช้เวอร์ชันเก่ากว่า Java 8? เนื่องจากฉันไม่ต้องการบังคับให้คนอัปเกรดเพื่อใช้แอปพลิเคชันของฉันฉันควรวางแผนให้ใช้ Java 7 หรือ 6 ตั้งแต่เริ่มต้นถึงแม้ว่าจะหมายความว่าฉันไม่สามารถใช้ประโยชน์จากเวอร์ชั่นใหม่สำหรับตัวเองได้ ในฐานะนักพัฒนา

15 java  architecture  backward-compatibility