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

Builder Patternตัวอย่างมากมายทำให้Builderคลาสภายในของวัตถุที่สร้างขึ้น ทำให้รู้สึกบางอย่างเพราะมันบ่งบอกถึงสิ่งที่Builderสร้าง อย่างไรก็ตามในภาษาที่พิมพ์แบบคงที่เรารู้ว่าสิ่งที่Builderสร้าง ในทางตรงกันข้ามถ้าBuilderเป็นระดับชั้นที่คุณควรจะรู้ว่าสิ่งที่ชั้นสร้างโดยไม่ได้มองภายในของBuilderBuilder นอกจากนี้การมีตัวสร้างเป็นคลาสภายในจะลดจำนวนของการนำเข้าเนื่องจากสามารถอ้างอิงโดยคลาสภายนอก - หากคุณสนใจสิ่งนั้น แล้วมีตัวอย่างการปฏิบัติที่Builderอยู่ในแพคเกจเดียวกัน StringBuilderแต่ไม่ได้เป็นระดับชั้นเช่น คุณรู้ว่าBuilder ควรสร้างStringเพราะมันมีชื่อดังนั้น ที่ถูกกล่าวว่าเหตุผลที่ดีเท่านั้นที่ฉันสามารถคิดในการสร้างBuilderชั้นในคือคุณรู้ว่าสิ่งที่ชั้น ' Builderคือโดยไม่ทราบชื่อของมันหรืออาศัยการประชุมการตั้งชื่อ ตัวอย่างเช่นถ้าStringBuilderเป็นชั้นในของStringฉันอาจจะรู้ว่ามันมีอยู่เร็วกว่าที่ฉันทำ (เก็งกำไร) มีเหตุผลอื่นที่จะทำให้Builderชั้นในหรือไม่เพียงแค่ลงไปที่การตั้งค่าและพิธีกรรม?

24 java  design-patterns  object-oriented 

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

24 database  sql  nosql  scalability 

สิ่งนี้ได้ดักฟังฉันมาระยะหนึ่งแล้ว เวลาส่วนใหญ่เมื่อมันมาถึงการจัดเก็บข้อมูลในโครงสร้างเช่นแฮชเทเบิลโปรแกรมเมอร์หนังสือและบทความยืนยันว่าองค์ประกอบการจัดทำดัชนีในโครงสร้างดังกล่าวโดยค่าสตริงถือว่าเป็นการปฏิบัติที่ไม่ดี ถึงกระนั้นฉันยังไม่พบแหล่งข้อมูลดังกล่าวเพียงแหล่งเดียวเพื่ออธิบายว่าทำไมจึงถือว่าเป็นการปฏิบัติที่ไม่ดี มันขึ้นอยู่กับภาษาการเขียนโปรแกรมหรือไม่? ในกรอบพื้นฐาน? เกี่ยวกับการใช้งานหรือไม่ ยกตัวอย่างง่ายๆสองอย่างถ้าช่วยได้: ตารางคล้าย SQL ที่แถวถูกทำดัชนีโดยคีย์หลักของสตริง . NET Dictionary ที่มีรหัสเป็น Strings

24 programming-practices  data-structures  database-design 

ฉันแค่ต้องเปลี่ยน ORM ออกมาและมันก็เป็นงานที่ค่อนข้างน่ากลัวเพราะตรรกะของแบบสอบถามนั้นรั่วไปทุกที่ หากฉันจำเป็นต้องพัฒนาแอปพลิเคชันใหม่การตั้งค่าส่วนตัวของฉันก็คือการสรุปแคปเจอร์ตรรกะทั้งหมด (ใช้ ORM) เพื่อป้องกันการเปลี่ยนแปลงในอนาคต รูปแบบพื้นที่เก็บข้อมูลค่อนข้างลำบากในการใช้รหัสและบำรุงรักษาดังนั้นฉันจึงสงสัยว่ามีรูปแบบอื่นใดที่สามารถแก้ปัญหาได้หรือไม่ ฉันสามารถคาดการณ์การโพสต์เกี่ยวกับการไม่เพิ่มความซับซ้อนเป็นพิเศษก่อนที่จะจำเป็นต้องมีความคล่องตัว ฯลฯ แต่ฉันแค่สนใจเกี่ยวกับรูปแบบที่มีอยู่ในการแก้ปัญหาที่คล้ายกันในวิธีที่ง่ายขึ้น ความคิดแรกของฉันคือการมีพื้นที่เก็บข้อมูลประเภททั่วไปซึ่งฉันเพิ่มวิธีการที่จำเป็นในการเรียนที่เก็บประเภทเฉพาะผ่านวิธีการขยาย แต่การทดสอบหน่วยวิธีการคงที่เจ็บปวดอย่างมาก IE: public static class PersonExtensions { public static IEnumerable<Person> GetRetiredPeople(this IRepository<Person> personRep) { // logic } }

24 .net  architecture 

เรากำลังใช้งานอะแดปเตอร์สำหรับ Jaxen (ไลบรารี XPath สำหรับ Java) ที่ช่วยให้เราใช้ XPath เพื่อเข้าถึงโมเดลข้อมูลของแอปพลิเคชันของเรา สิ่งนี้ทำได้โดยการใช้คลาสที่จับคู่สตริง (ส่งถึงเราจาก Jaxen) ไปยังองค์ประกอบของโมเดลข้อมูลของเรา เราประเมินว่าเราต้องการประมาณ 100 คลาสโดยมีการเปรียบเทียบสตริงมากกว่า 1,000 รายการ ฉันคิดว่าวิธีที่ดีที่สุดในการทำเช่นนี้คือง่ายถ้าคำสั่ง / else พร้อมสตริงที่เขียนลงในโค้ดโดยตรงแทนที่จะกำหนดแต่ละสตริงเป็นค่าคงที่ ตัวอย่างเช่น: public Object getNode(String name) { if ("name".equals(name)) { return contact.getFullName(); } else if ("title".equals(name)) { return contact.getTitle(); } else if ("first_name".equals(name)) { return contact.getFirstName(); } else if …

24 java  coding-style  strings 

ในบทความนี้ผู้เขียนอ้างว่า บางครั้งจำเป็นต้องเปิดเผยการดำเนินการใน API ที่โดยทั่วไปจะไม่สงบ และนั่น หาก API มีการดำเนินการมากเกินไปนั่นเป็นข้อบ่งชี้ว่ามันได้รับการออกแบบด้วยมุมมอง RPC แทนที่จะใช้หลักการ RESTful หรือ API ที่เป็นปัญหานั้นเหมาะสมสำหรับรุ่นประเภท RPC โดยธรรมชาติ สิ่งนี้สะท้อนถึงสิ่งที่ฉันได้อ่านและได้ยินที่อื่นเช่นกัน อย่างไรก็ตามฉันพบว่ามันค่อนข้างสับสนและฉันต้องการทำความเข้าใจเกี่ยวกับเรื่องนี้ให้ดีขึ้น ตัวอย่างฉัน: การปิด VM ผ่านอินเตอร์เฟส REST ฉันคิดว่ามีสองวิธีที่แตกต่างกันในการสร้างแบบจำลองการปิดระบบของ VM แต่ละวิธีอาจมีรูปแบบต่างกันเล็กน้อย แต่เราจะมุ่งเน้นไปที่ความแตกต่างพื้นฐานที่สุดในตอนนี้ 1. แก้ไขคุณสมบัติสถานะของทรัพยากร PATCH /api/virtualmachines/42 Content-Type:application/json { "state": "shutting down" } (หรืออีกวิธีหนึ่งPUTบนทรัพยากรย่อย/api/virtualmachines/42/state) VM จะปิดระบบในพื้นหลังและในเวลาต่อมาขึ้นอยู่กับว่าการปิดเครื่องจะสำเร็จหรือไม่สถานะอาจได้รับการปรับปรุงภายในด้วย "ปิด" 2. ใส่หรือโพสต์บนคุณสมบัติการกระทำของทรัพยากร PUT /api/virtualmachines/42/actions Content-Type:application/json { "type": "shutdown" } …

24 rest  domain-driven-design  api-design  cqrs 

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

23 terminology  boolean 

ทั้งคู่ดูเหมือนเครือข่าย MPI ที่สื่อสารกันแบบขนานของกระบวนการ ฉันระบุนักแสดงด้วยบริการ นักแสดงมีพลังมากขึ้น (คุณสามารถสร้างและฆ่าขณะหายใจขณะที่เครือข่ายบริการคงที่มากกว่า) หรืออะไร

23 terminology  microservices  actor-model 

ฉันมีเว็บแอพพลิเคชั่น ฉันไม่เชื่อว่าเทคโนโลยีเป็นสิ่งสำคัญ โครงสร้างเป็นแอปพลิเคชันระดับ N ซึ่งแสดงในภาพทางด้านซ้าย มี 3 ชั้น UI (รูปแบบ MVC), Business Logic Layer (BLL) และ Data Access Layer (DAL) ปัญหาที่ฉันมีคือ BLL ของฉันมีขนาดใหญ่มากเนื่องจากมีตรรกะและเส้นทางผ่านการเรียกแอปพลิเคชันกิจกรรม โฟลว์ทั่วไปผ่านแอ็พพลิเคชันอาจเป็น: มีเหตุการณ์เกิดขึ้นใน UI ข้ามไปที่เมธอดใน BLL ดำเนินการกับลอจิก (อาจอยู่ในหลายส่วนของ BLL) ในที่สุดถึง DAL กลับไปที่ BLL (ซึ่งเป็นไปได้ว่ามีตรรกะมากกว่า) จากนั้นส่งคืนค่าบางค่าไปยัง UI BLL ในตัวอย่างนี้ยุ่งมากและฉันคิดว่าจะแยกออก ฉันมีตรรกะและวัตถุที่รวมกันซึ่งฉันไม่ชอบ เวอร์ชั่นด้านขวาคือความพยายามของฉัน เหตุผลยังคงเป็นวิธีการประยุกต์ไหลระหว่าง UI และ DAL แต่มีแนวโน้มที่คุณสมบัติไม่ ... เพียงวิธีการ (ส่วนใหญ่ของการเรียนในชั้นนี้อาจเป็นไปได้ที่จะเป็นแบบคงที่ที่พวกเขาไม่จัดเก็บใด …

23 object-oriented  architecture 

ฉันกำลังอ่านหนังสือแนะนำการเขียนโปรแกรมเบื้องต้นและจะแสดงตัวอย่างง่าย ๆ ใน pseudocode: Start input myNumber set myAnswer = myNumber * 2 output myAnswer Stop ทำไมเราไม่ละเว้นการสร้างตัวแปรอื่นที่เรียกว่าmyAnswerและเพียงแค่ใส่การดำเนินการลงในคำสั่งเอาต์พุตเช่นนี้: Start input myNumber output myNumber * 2 Stop ทำไมอดีตถึงถูกต้องและไม่หลัง

23 pseudocode  structured-programming 

ฉันต้องการเพิ่มข้อผิดพลาดในการจัดการ: var firstVariable = 1; var secondVariable = firstVariable; ด้านล่างจะไม่รวบรวม: try { var firstVariable = 1; } catch {} try { var secondVariable = firstVariable; } catch {} เหตุใดจึงจำเป็นสำหรับ try catch block ที่จะส่งผลต่อขอบเขตของตัวแปรเช่นเดียวกับบล็อคโค้ดอื่น ๆ เห็นแก่ความสอดคล้องกันมันจะสมเหตุสมผลหรือไม่ที่เราจะสามารถห่อโค้ดของเราด้วยการจัดการข้อผิดพลาดโดยไม่จำเป็นต้อง refactor

23 c#  .net  error-handling  language-features 

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

23 documentation 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัพเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน3 ปีที่ผ่านมา กรอบ Redux สนับสนุนกระบวนทัศน์ของฟังก์ชันบริสุทธิ์ / ไม่เปลี่ยนรูปแบบซึ่งส่งเสริมการสร้างสถานะใหม่จากสถานะก่อนหน้าในแง่ของการกระทำในปัจจุบัน การบังคับใช้กระบวนทัศน์นี้ไม่อาจปฏิเสธได้ ข้อกังวลหลักของฉันคือเนื่องจาก Redux reducers ส่งคืนสถานะใหม่ที่สดใหม่จากสถานะก่อนหน้าสำหรับการกระทำทุกครั้งที่เรียกใช้หน่วยความจำขนาดใหญ่ที่ระบายออก (เพื่อไม่ให้สับสนกับการรั่วไหลของหน่วยความจำ) จะกลายเป็นเรื่องธรรมดา . เมื่อพิจารณาว่าแอปพลิเคชัน Javascript ทำงานตามปกติในเบราว์เซอร์ในอุปกรณ์ของผู้ใช้โดยเฉลี่ยซึ่งอาจใช้งานแอพพลิเคชั่นเฉพาะอุปกรณ์อื่น ๆ รวมถึงแท็บและหน้าต่างเบราว์เซอร์อื่น ๆ อีกมากมายความจำเป็นในการอนุรักษ์หน่วยความจำ มีใครเปรียบเทียบการใช้หน่วยความจำของแอพพลิเคชัน Redux กับสถาปัตยกรรม Flux แบบดั้งเดิมบ้างไหม ถ้าเป็นเช่นนั้นพวกเขาสามารถแบ่งปันสิ่งที่ค้นพบของพวกเขา?

23 memory  immutability  memory-usage  reactjs 

เมื่อใช้ Java8 สตรีม api ใหม่เพื่อค้นหาองค์ประกอบเฉพาะในคอลเลกชันฉันเขียนโค้ดดังนี้: String theFirstString = myCollection.stream() .findFirst() .get(); ที่นี่ IntelliJ เตือนว่า get () ถูกเรียกโดยไม่ตรวจสอบ isPresent () ก่อน อย่างไรก็ตามรหัสนี้: String theFirstString = myCollection.iterator().next(); ... ไม่ได้เตือนใด ๆ มีความแตกต่างอย่างลึกซึ้งระหว่างสองเทคนิคนี้หรือไม่ที่ทำให้การสตรีมเข้าหา "อันตราย" มากกว่านี้ในบางด้านนั่นเป็นสิ่งสำคัญที่จะไม่ต้องโทรหารับ () โดยไม่ต้องเรียก isPresent () ก่อน Googling ไปรอบ ๆ ฉันพบบทความที่พูดถึงว่าโปรแกรมเมอร์ไม่ใส่ใจกับตัวเลือก <> และคิดว่าพวกเขาสามารถโทรหา get () ได้ทุกเมื่อ สิ่งที่ฉันชอบที่จะได้รับข้อยกเว้นโยนฉันที่ใกล้ที่สุดกับสถานที่ที่รหัสของฉันเป็นรถซึ่งในกรณีนี้จะเป็นที่ที่ฉันโทรหารับ () เมื่อไม่มีองค์ประกอบที่จะพบ ฉันไม่ต้องการที่จะเขียนเรียงความไร้ประโยชน์เช่น: Optional<String> …

23 java8 

ฉันพยายามที่จะเข้าใจการรวบรวมและการตีความทีละขั้นตอนหาภาพรวม ดังนั้นฉันจึงพบคำถามขณะอ่านhttp://www.cs.man.ac.uk/~pjj/farrell/comp3.htmlบทความนี้ มันบอกว่า : ขั้นตอนต่อไปของคอมไพเลอร์เรียกว่า Parser คอมไพเลอร์ส่วนนี้มีความเข้าใจไวยากรณ์ของภาษา มันมีหน้าที่ในการระบุข้อผิดพลาดทางไวยากรณ์และสำหรับการแปลโปรแกรมที่ปราศจากข้อผิดพลาดเป็นโครงสร้างข้อมูลภายในที่สามารถตีความหรือเขียนออกมาในภาษาอื่น แต่ฉันไม่สามารถหาวิธี tokenizer สามารถโทเค็นสตรีมที่กำหนดอย่างถูกต้องซึ่งมีข้อผิดพลาดทางไวยากรณ์ มันควรจะติดอยู่ที่นั่นหรือให้ข้อมูลที่ไม่ถูกต้องกับตัวแยกวิเคราะห์ ฉันหมายถึงว่าการโทเค็นยังไม่ใช่นักแปลหรือ ดังนั้นวิธีที่จะเอาชนะบรรทัดที่มีความเสียหายของคำศัพท์ในขณะที่โทเค็น มีตัวอย่างของโทเค็นภายในลิงก์ด้านบนที่ส่วนหัวของTokenizer ตามที่ฉันเข้าใจรูปแบบของโทเค็นดูเหมือนว่าหากมีสิ่งผิดปกติในโทเค็นรหัสจะเสียหายเช่นกัน คุณช่วยอธิบายความเข้าใจผิดของฉันได้ไหม?

23 compiler  parsing  interpreters