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

เมื่อเร็ว ๆ นี้ฉันชอบทำแผนที่ความสัมพันธ์ 1-1 โดยใช้คำสั่งDictionariesแทน Switchฉันคิดว่ามันจะเร็วขึ้นเล็กน้อยในการเขียนและง่ายต่อการประมวลผลทางจิตใจ น่าเสียดายที่เมื่อทำการแมปกับอินสแตนซ์ใหม่ของวัตถุฉันไม่ต้องการกำหนดเช่นนี้: var fooDict = new Dictionary<int, IBigObject>() { { 0, new Foo() }, // Creates an instance of Foo { 1, new Bar() }, // Creates an instance of Bar { 2, new Baz() } // Creates an instance of Baz } var quux …

12 c#  coding-style 

ฉันกำลังศึกษาเกี่ยวกับฟังก์ชั่นวนซ้ำและเห็นได้ชัดว่าพวกมันเป็นฟังก์ชันที่เรียกตัวเองและไม่ใช้การวนซ้ำ / วนซ้ำ อย่างไรก็ตามในขณะที่ท่องเว็บเพื่อดูตัวอย่าง (ปัญหา 8-queens-recursive) ฉันพบฟังก์ชันนี้: private boolean placeQueen(int rows, int queens, int n) { boolean result = false; if (row < n) { while ((queens[row] < n - 1) && !result) { queens[row]++; if (verify(row,queens,n)) { ok = placeQueen(row + 1,queens,n); } } if (!result) { queens[row] = …

12 java  recursion 

มีคำที่ดีที่คล้ายกัน แต่แตกต่างจาก "คัดค้าน" เพื่อหมายความว่าวิธีการหรือ API อยู่ในรหัสฐาน แต่ไม่ควรใช้เนื่องจากการใช้งานไม่สมบูรณ์หรือมีแนวโน้มที่จะเปลี่ยนแปลง? (ใช่ฉันรู้วิธีการเหล่านั้นไม่ควรเปิดเผยต่อสาธารณชน yada yada yada ฉันไม่ได้สร้างสถานการณ์ของฉันฉันแค่พยายามทำให้ดีที่สุดเท่าที่จะทำได้) ผู้คนแนะนำอะไร ทดลองไม่สมบูรณ์มีอะไรอีกหรือ หากฉันกำลังสร้างเอกสาร javadoc สำหรับ API นี้ที่ยังอยู่ในฟลักซ์ฉันควรใช้แท็ก @deprecated หรือมีข้อตกลงที่ดีกว่า สำหรับฉัน @deprecated แสดงว่า API นี้เก่าและมีกลไกที่ต้องการที่ใหม่กว่าพร้อมใช้งาน ในสถานการณ์ของฉันไม่มีทางเลือก แต่วิธีการบางอย่างใน API ยังไม่เสร็จสิ้นและไม่ควรใช้ ณ จุดนี้ฉันไม่สามารถทำให้พวกเขาเป็นส่วนตัว แต่ฉันต้องการที่จะใส่คำเตือนที่ชัดเจนในเอกสาร

12 documentation  terminology  api  documentation-generation  javadocs 

ฉันกำลังพัฒนาแอพที่จะใช้ในการเปิดและปิดวาล์วในสภาพแวดล้อมอุตสาหกรรมและกำลังคิดถึงบางสิ่งที่เรียบง่ายเช่นนี้: - public static void ValveController { public static void OpenValve(string valveName) { // Implementation to open the valve } public static void CloseValve(string valveName) { // Implementation to close the valve } } (การนำไปใช้นั้นจะเขียนข้อมูลสองสามไบต์ไปยังพอร์ตอนุกรมเพื่อควบคุมวาล์ว - "ที่อยู่" ซึ่งได้มาจากชื่อของวาล์วและ "1" หรือ "0" เพื่อเปิดหรือปิดวาล์ว) นักพัฒนาอีกคนถามว่าเราควรสร้างคลาสแยกต่างหากสำหรับแต่ละวาล์วทางกายภาพซึ่งมีอยู่เป็นสิบหรือไม่ ฉันยอมรับว่ามันจะดีกว่าที่จะเขียนโค้ดเหมือนPlasmaValve.Open()มากกว่าValveController.OpenValve("plasma")แต่นี่เป็น overkill หรือไม่ นอกจากนี้ฉันยังสงสัยว่าวิธีที่ดีที่สุดในการจัดการกับการออกแบบโดยคำนึงถึงความต้องการในอนาคตของสมมุติสองสามข้อ: - เราได้รับการร้องขอให้สนับสนุนวาล์วชนิดใหม่ที่ต้องการค่าต่าง ๆ …

12 design  design-patterns  object-oriented 

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

12 git  branching 

ฉันมีโปรเจ็กต์ java ขนาดใหญ่และเราใช้ maven สำหรับวงรอบการสร้างของเรา โครงการนี้มีการใช้อย่างกว้างขวาง - ในโครงการอื่น ๆ ในแอปพลิเคชั่นต่าง ๆ ซึ่งบางส่วนอยู่ในนั้นและบางส่วนอยู่ที่อื่น ... พูดตามตรงแล้วมันเป็นระเบียบนิดหน่อย วัตถุประสงค์) และฉันต้องการทำความสะอาดสักหน่อย นอกจากนี้ยังไม่ผ่านการทดสอบอย่างสมบูรณ์ (มีการเพิ่มบิตจำนวนมากโดยไม่มีหน่วยที่เหมาะสมและการทดสอบการรวม) และมีการทดสอบบางอย่างที่ใช้เวลานานในการรันหรือไม่ผ่านจริง ... (uh-oh) - ดังนั้น การทดสอบจะถูกปิดในวงจรสร้าง maven (อีกครั้ง uh-oh) ฉันกำลังคิดที่จะแยกโครงการขนาดใหญ่นี้ออกเป็นโครงการขนาดเล็กโดยเฉพาะเช่นโครงการย่อย 'สุดท้าย' (หรือโครงการย่อยหลายโครงการ) จะรับโครงการย่อยต่าง ๆ ที่มันต้องการ ความคิดของฉันเป็นดังนี้: ถ้าฉันแยกโครงการใหญ่ออกเป็นโครงการย่อยต่าง ๆ นี่จะทำให้ชัดเจนว่าความรับผิดชอบของแต่ละโครงการคืออะไร โดยแยกเป็นโครงการย่อยฉันสามารถล้างการทดสอบของแต่ละโครงการย่อยทีละรายการและเปิดการทดสอบสำหรับโครงการย่อยนั้นในวงจรการสร้าง maven ฉันกังวลเล็กน้อยเกี่ยวกับผลกระทบที่อาจเกิดขึ้นกับเวลาสร้าง การวางโครงสร้างในโครงการขนาดใหญ่ (เช่นเป็นโครงการย่อยขนาดเล็ก) จะทำให้คอมไพเลอร์ช้าลงหรือไม่ นอกจากนี้ฉันมีข้อกังวลเล็กน้อยเกี่ยวกับผลกระทบที่อาจเกิดขึ้นกับการแก้ไขเวลาใน IDEs (เราใช้ Intellij เป็นหลัก) Intellij ดูเหมือนว่าจะสร้างแต่ละโครงการผ่านแผนผังการพึ่งพา …

12 java  project-structure  maven 

ในการส่งมอบซอฟต์แวร์ทุกรุ่นเราต้องเขียนบันทึกย่อประจำรุ่น ตัวอย่างเช่นต่อไปนี้เป็นคำศัพท์ที่ฉันเพิ่มเมื่อฉันเขียนบันทึกย่อประจำรุ่น: วันวางจำหน่าย แก้ไขข้อผิดพลาด เพียงพอหรือมีอะไรอีกหรือไม่

12 release 

มีความเชื่อมั่นมากมายที่การวัดความมุ่งมั่นนั้นไม่เหมาะสม มีการศึกษาใด ๆ ที่พยายามวาดในแหล่งข้อมูลมากกว่าที่กระทำ - เช่น: รูปแบบการเรียกดู งาน IDE (กระทำล่วงหน้า) เวลาว่าง มัลติทาสกิ้ง ฉันไม่สามารถคิดวิธีง่ายๆในการทำมาตรการเหล่านี้ แต่ฉันสงสัยว่ามีการศึกษาใด ๆ เกิดขึ้นหรือไม่ ในบันทึกส่วนตัวฉันเชื่อว่าการไตร่ตรองเกี่ยวกับ 'ตัวชี้วัด' ของตัวเองอาจมีค่าโดยไม่คำนึงถึง (หรือในกรณีที่ไม่มี) การใช้สิ่งเหล่านี้เพื่อการแสดงที่มีประสิทธิภาพ IE เป็นวิธีที่ไม่ลำเอียงในการสะท้อนพฤติกรรมของคุณ แต่นี่เป็นเรื่องการอภิปรายนอกเหนือจากคำถามและคำตอบ

12 self-improvement  productivity  coding-style 

ฉันกำลังจะเริ่มโครงการจำลองสถานการณ์ / การสร้างแบบจำลอง ฉันรู้อยู่แล้วว่า OOP ใช้สำหรับโครงการประเภทนี้ อย่างไรก็ตามการเรียน Haskell ทำให้ฉันพิจารณาใช้กระบวนทัศน์ของ FP สำหรับการสร้างแบบจำลองระบบของส่วนประกอบ ให้ฉันทำอย่างละเอียด: สมมติว่าฉันมีองค์ประกอบประเภท A ซึ่งมีลักษณะเป็นชุดข้อมูล (พารามิเตอร์เช่นอุณหภูมิหรือความดัน PDE และเงื่อนไขขอบเขต ฯลฯ ) และส่วนประกอบประเภท B ซึ่งมีชุดข้อมูลแตกต่างกัน (แตกต่างกัน หรือพารามิเตอร์เดียวกัน PDE และเงื่อนไขขอบเขตที่แตกต่างกัน) สมมติว่าฟังก์ชั่น / วิธีการที่จะนำไปใช้กับแต่ละองค์ประกอบเหมือนกัน (ตัวอย่างวิธี Galerkin) สถานะที่ไม่แน่นอนของวัตถุจะถูกใช้สำหรับพารามิเตอร์ที่ไม่คงที่ ถ้าฉันจะใช้วิธีการของ OOP ฉันจะสร้างวัตถุสองชนิดที่จะห่อหุ้มข้อมูลของแต่ละประเภทวิธีการในการแก้ไข PDE (การสืบทอดจะใช้ที่นี่เพื่อนำโค้ดกลับมาใช้ใหม่) และวิธีแก้ปัญหากับ PDE ในทางตรงกันข้ามถ้าฉันจะใช้วิธีการ FP แต่ละองค์ประกอบจะถูกแบ่งออกเป็นส่วนข้อมูลและฟังก์ชั่นที่จะดำเนินการกับข้อมูลเพื่อให้ได้โซลูชั่นสำหรับ PDE พารามิเตอร์ที่ไม่คงที่จะถูกส่งผ่านเป็นฟังก์ชั่นของอย่างอื่น (เวลาเช่น) หรือแสดงโดยความไม่แน่นอนบางอย่าง (การเลียนแบบความไม่แน่นอน ฯลฯ ) …

12 c++  object-oriented  functional-programming  haskell  modeling 

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

12 mobile  server-side 

ฉันคิดว่านี่อาจเป็นคุณสมบัติภาษาที่มีประโยชน์และสงสัยว่ามีภาษาใดรองรับอยู่หรือไม่ ความคิดคือถ้าคุณมี: class C virtual F statement1 statement2 และ class D inherits C override F statement1 statement2 C.F() จะมีคำหลักที่ใช้กับ CF () ซึ่งการลบบรรทัดสุดท้ายของรหัสด้านบนจะทำให้เกิดข้อผิดพลาดของคอมไพเลอร์เพราะมันบอกว่า "วิธีนี้สามารถถูกแทนที่ได้ แต่การใช้งานที่นี่ต้องทำงานไม่ว่าอะไรก็ตาม"

12 programming-languages 

เมื่อกำหนดแฟรกเมนต์สตริงให้ฉันต้องการค้นหาสตริงเดี่ยวสั้นที่สุดเท่าที่จะเป็นไปได้ ("เอาต์พุตสตริง") ที่มีแฟรกเมนต์ทั้งหมด แฟรกเมนต์สามารถทับซ้อนกันในสตริงเอาต์พุต ตัวอย่าง: สำหรับแฟรกเมนต์สตริง: BCDA AGF ABC สตริงเอาต์พุตต่อไปนี้มีแฟรกเมนต์ทั้งหมดและสร้างขึ้นโดยการต่อท้ายแบบไร้เดียงสา: BCDAAGFABC อย่างไรก็ตามสตริงเอาต์พุตนี้ดีกว่า (สั้นกว่า) เนื่องจากมีการซ้อนทับกัน: ABCDAGF ^ ABC ^ BCDA ^ AGF ฉันกำลังมองหาอัลกอริทึมสำหรับปัญหานี้ ไม่สำคัญอย่างยิ่งที่จะต้องค้นหาสตริงเอาต์พุตที่สั้นที่สุด แต่ยิ่งสั้นยิ่งดี ฉันกำลังมองหาอัลกอริทึมที่ดีกว่าแบบไร้เดียงสาที่ชัดเจนซึ่งจะลองต่อท้ายพีชคณิตของอินพุตทั้งหมดและลบการทับซ้อน (ซึ่งดูเหมือนจะเป็น NP-Complete) ฉันเริ่มทำงานกับวิธีแก้ปัญหาและมันพิสูจน์ได้ว่าน่าสนใจมาก ฉันต้องการที่จะเห็นสิ่งที่คนอื่นอาจเกิดขึ้น ฉันจะเพิ่มความคืบหน้าในการทำงานกับคำถามนี้ในอีกสักครู่

12 algorithms  strings 

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

12 scrum  product-backlog 

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

12 agile  dynamic-typing  static-typing 

เป็นการยากที่จะบอกสิ่งที่ถูกถามที่นี่ คำถามนี้คลุมเครือคลุมเครือไม่สมบูรณ์กว้างเกินไปหรือโวหารและไม่สามารถตอบได้อย่างสมเหตุสมผลในรูปแบบปัจจุบัน สำหรับความช่วยเหลือในการทำความเข้าใจคำถามนี้เพื่อที่จะสามารถเปิด, ไปที่ศูนย์ช่วยเหลือ ปิดให้บริการใน7 ปีที่ผ่านมา ฉันเห็นที่นี่ในโปรแกรมเมอร์คำตอบสำหรับคำถามนี้: การคิดเกี่ยวกับรูปแบบการออกแบบและการปฏิบัติของ OOP เปลี่ยนไปอย่างไรในภาษาที่มีการเปลี่ยนแปลงและมีชีวิตชีวา มีผมพบว่าเชื่อมโยงไปยังบทความที่มีชื่อตรงไปตรงมา: รูปแบบการออกแบบที่ขาดหายไปคุณสมบัติภาษา แต่ที่ฉันพบตัวอย่างที่ฉันดูเหมือนลวงมากและที่สามารถตรวจสอบกับประสบการณ์ที่ได้รับมีสิ่งจูงใจเช่น: PaulGraham กล่าวว่า "Peter Norvig พบว่า 16 จาก 23 รูปแบบในรูปแบบการออกแบบนั้น 'มองไม่เห็นหรือเรียบง่าย' ใน Lisp" หรือประโยคอื่นที่ยืนยันสิ่งที่ฉันเห็นเมื่อเร็ว ๆ นี้กับผู้ที่พยายามจำลองชั้นเรียนใน JavaScript: แน่นอนว่าไม่มีใครเคยพูดถึงรูปแบบ "ฟังก์ชั่น" หรือรูปแบบ "ชั้นเรียน" หรือสิ่งอื่น ๆ อีกมากมายที่เราให้สิทธิ์เพราะภาษาส่วนใหญ่ให้พวกเขาเป็นคุณสมบัติในตัว OTOH โปรแกรมเมอร์ในภาษา PrototypeOrientedLanguage หรือไม่? อาจสะดวกในการจำลองคลาสด้วยต้นแบบ ... นอกจากนี้ผมยังคำนึงถึงว่ารูปแบบการออกแบบเป็นเครื่องมือติดต่อสื่อสาร เพราะแม้จะมีประสบการณ์ จำกัด ในการสร้างแอปพลิเคชันฉันก็สามารถเห็นได้ว่าเป็นรูปแบบการต่อต้าน ( ไม่มีประสิทธิภาพและ / หรือการต่อต้าน …

12 programming-languages  design-patterns