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

ฉันกำลังทำงานกับแอปพลิเคชันที่เกี่ยวข้องกับการเรียกใช้คิวรีแบบเลือกใช้ / อัปเดตในฐานข้อมูล ฉันมีตารางฐาน (A) ซึ่งจะมีระเบียนประมาณ 500 รายการสำหรับหนึ่งวัน และสำหรับผู้ใช้ทุกคนในระบบรูปแบบของเอนทิตีนี้จะถูกสร้างขึ้นตามการตั้งค่าบางอย่างของผู้ใช้และพวกเขาจะถูกเก็บไว้ในตารางอื่น (B) ทำได้โดยงาน cron ที่ทำงานตอนเที่ยงคืนทุกวัน ดังนั้นหากมี 10,000 ผู้ใช้และ 500 บันทึกในตาราง A จะมีระเบียน 5M ในตาราง B สำหรับวันนั้น ฉันมักจะเก็บข้อมูลเป็นเวลาหนึ่งวันในตารางเหล่านี้และในเวลาเที่ยงคืนฉันจะเก็บข้อมูลประวัติเพื่อ HBase การตั้งค่านี้ทำงานได้ดีและฉันไม่มีปัญหาด้านประสิทธิภาพมาก่อน มีการเปลี่ยนแปลงข้อกำหนดทางธุรกิจเมื่อไม่นานมานี้และตอนนี้คุณลักษณะบางอย่างในตารางฐาน A (สำหรับ 15 - 20 บันทึก) จะเปลี่ยนทุก ๆ 20 วินาทีและขึ้นอยู่กับว่าฉันต้องคำนวณค่าบางอย่างสำหรับบันทึกชุดรูปแบบทั้งหมดในตาราง B สำหรับ ผู้ใช้ทั้งหมด. แม้ว่าจะมีการเปลี่ยนแปลงเรคคอร์ดหลักเพียง 20 รายการ แต่ฉันต้องทำการคำนวณใหม่และอัปเดตระเบียนผู้ใช้ 200,000 รายการซึ่งใช้เวลามากกว่า 20 วินาทีจากนั้นการอัปเดตครั้งต่อไปก็เกิดขึ้นในที่สุดจึงทำให้คิวรี Select …

10 database-design  nosql 

คุณกำลังสร้างระบบที่ติดตาม บริษัท บริษัท เหล่านั้นมีผู้ติดต่อ ผู้ติดต่อเหล่านั้นมักเป็นผู้เชี่ยวชาญที่ตอบเฉพาะคำถามบางประเภทเท่านั้นเช่นการเรียกเก็บเงิน / ชำระเงินการขายการสั่งซื้อและการสนับสนุนลูกค้า การใช้การออกแบบโดเมนขับเคลื่อนและสถาปัตยกรรมหัวหอมฉันได้ทำแบบจำลองนี้ด้วยประเภทต่อไปนี้: บริษัท มีผู้ติดต่อ ติดต่อ มีประเภทการติดต่อ ContactType (enum) CompanyRepository (อินเตอร์เฟส) EFCompanyRepository (กำหนดไว้ในแอสเซมบลีภายนอกใช้ EntityFramework ดำเนินการ CompanyRepository) ทีมของเรามีความเห็นแยกกันเกี่ยวกับวิธีการสร้างแบบจำลองฐานข้อมูลสำหรับแอปพลิเคชันนี้ ด้าน A: DDDers แบบ Lean: เป็นหน้าที่ของโดเมนในการกำหนดว่า ContactTypes ใดที่ถูกต้องสำหรับที่ติดต่อ การเพิ่มตารางไปยังฐานข้อมูลเพื่อตรวจสอบว่า ContactTypes ที่ไม่รู้จักไม่ได้ถูกบันทึกเป็นสัญลักษณ์ของโดเมนที่รั่ว มันกระจายตรรกะออกไปไกลเกินไป การเพิ่มตารางคงที่ในฐานข้อมูลและรหัสที่เกี่ยวข้องนั้นสิ้นเปลือง ในแอปพลิเคชั่นนี้ฐานข้อมูลแก้ปัญหาหนึ่ง: ยืนยันสิ่งนั้นและส่งคืนให้ฉัน การเขียนตารางพิเศษและรหัส CRUD ที่เกี่ยวข้องนั้นสิ้นเปลือง การเปลี่ยนกลยุทธ์เพื่อการคงอยู่นั้นง่ายที่สุดเท่าที่จะทำได้ มีแนวโน้มที่จะเปลี่ยนกฎธุรกิจ ถ้าฉันตัดสินใจว่า SQL Server มีค่าใช้จ่ายมากเกินไปฉันไม่ต้องการสร้างการตรวจสอบความถูกต้องทั้งหมดที่ฉันใส่ไว้ในสคีมาใหม่อีกครั้ง ด้าน B: นักอนุรักษนิยม [นั่นอาจไม่ใช่ชื่อที่ยุติธรรม …

10 domain-driven-design  domain-model  onion-architecture 

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

10 version-control  dvcs 

Java เป็นเชิงวัตถุ แต่ทำไมเราต้องสร้างวัตถุจาก Scanner Class เพื่อรับอินพุต next()ยกตัวอย่างเช่นเมธอดไม่สามารถเป็นแบบคงที่ได้หรือไม่ C ดูเหมือนผมสวยเรียบง่ายที่คุณเพียงแค่ใช้scanf(), หรือgets() fgets()ฉันแน่ใจว่ามีเหตุผลสำหรับนักพัฒนา Java ในการสร้างคลาสสแกนเนอร์ แต่จะดีกว่าแค่มีฟังก์ชั่นปกติในการทำงานอย่างไร ฉันพบลิงค์นี้ที่อาจดูเหมือนถามคำถามเดียวกัน แต่คำตอบนั้นใกล้เคียงกัน "คุณต้องสร้างวัตถุเพราะไม่คงที่" ... ฉันเดา: เนื่องจาก Java เป็น Object Oriented พวกเขาตัดสินใจที่จะใส่วิธีการป้อนข้อมูลทั้งหมดในชั้นเรียน พวกเขาไม่ได้ทำวิธีการคงที่เพื่อให้คุณสามารถมีแหล่งที่แตกต่างกันทุกชนิด (คีย์บอร์ดอินพุตไฟล์อินพุต ... ) ในวัตถุที่แตกต่างกันอย่างไร ฉันจะขอบคุณถ้ามีคนสามารถแก้ไขคำถามเพื่อให้ชัดเจนยิ่งขึ้น!

10 java  object-oriented 

ฉันกำลังอ่าน " ในรูปแบบ MVC ควรจัดการกับการตรวจสอบหรือไม่ " เพราะฉันอยากรู้ว่าตรรกะการตรวจสอบควรอยู่ที่ใดในเว็บไซต์ MVC หนึ่งบรรทัดในคำตอบยอดนิยมจะเป็นดังนี้: "ตัวควบคุมควรจัดการกับการตรวจสอบความถูกต้องโมเดลควรจัดการกับการตรวจสอบความถูกต้อง" ฉันชอบที่ แต่มันทำให้ฉันสงสัยว่าทำไมเราจะไม่ตรวจสอบข้อมูลในมุมมองด้วยเหตุผลหลายประการ: มุมมองมักมีการสนับสนุนการตรวจสอบที่มีประสิทธิภาพ (ไลบรารี JS, แท็ก HTML5) มุมมองสามารถตรวจสอบภายในเครื่องลด IO เครือข่าย UI ได้รับการออกแบบโดยคำนึงถึงประเภทข้อมูลเป็นหลัก (ปฏิทินสำหรับวันที่, ตัวหมุนสำหรับตัวเลข) ทำให้เป็นขั้นตอนเดียวจากการตรวจสอบความถูกต้อง การยืนยันในที่มากกว่าหนึ่งแห่งนั้นตรงกันข้ามกับแนวคิดของ MVC ในการแยกความรับผิดชอบดังนั้น "การทำทั้งสองอย่าง" ดูเหมือนไม่เหมาะสม การตรวจสอบความถูกต้องของข้อมูลในคอนโทรลเลอร์เป็นวิธีการที่โดดเด่นอย่างแท้จริงหรือไม่?

10 architecture  mvc 

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

10 design-patterns  object-oriented-design  database-design  data-structures 

ฉันได้ดูคำตอบและค้นหาใน Google แล้ว แต่ฉันไม่พบสิ่งที่เป็นประโยชน์ (เช่นนั่นจะไม่มีผลข้างเคียงที่น่าอึดอัดใจ) ปัญหาของฉันในเชิงนามธรรมคือฉันมีวัตถุและจำเป็นต้องดำเนินการลำดับที่ยาวนานของมัน ฉันคิดว่ามันเป็นสายการประกอบเช่นการสร้างรถ ผมเชื่อว่าวัตถุเหล่านี้จะเรียกว่าวิธีวัตถุ ดังนั้นในตัวอย่างนี้ในบางครั้งฉันจะมี CarWithoutUpholstery ซึ่งฉันจะต้องเรียกใช้ installBackSeat, installFrontSeat, installWoodenInserts (การดำเนินการไม่รบกวนซึ่งกันและกันและอาจทำได้ในแบบคู่ขนาน) การดำเนินการเหล่านี้ดำเนินการโดย CarWithoutUpholstery.worker () และให้ผลลัพธ์เป็นวัตถุใหม่ซึ่งจะเป็น CarWithUpholstery ซึ่งฉันจะเรียกใช้ cleanInsides (), validNoUpholsteryDefects () และอื่น ๆ การดำเนินงานในเฟสเดียวนั้นมีความเป็นอิสระอยู่แล้วเช่นฉันกำลังต่อสู้กับส่วนย่อยของพวกเขาที่อาจดำเนินการในลำดับใด ๆ (ที่นั่งด้านหน้าและด้านหลังอาจติดตั้งในลำดับใดก็ได้) ตรรกะของฉันในปัจจุบันใช้ Reflection เพื่อความง่ายในการใช้งาน นั่นคือเมื่อฉันมี CarWithoutUpholstery วัตถุจะตรวจสอบตัวเองสำหรับวิธีที่เรียกว่า performSomething () ณ จุดนั้นมันรันวิธีการเหล่านี้ทั้งหมด: myObject.perform001SomeOperation(); myObject.perform002SomeOtherOperation(); ... ในขณะที่ตรวจสอบข้อผิดพลาดและสิ่งต่างๆ ในขณะที่คำสั่งของการดำเนินงานเป็นสำคัญผมได้รับมอบหมายเพื่อทำพจนานุกรมในกรณีที่ผมเคยค้นพบคำสั่งบางเป็นสิ่งสำคัญหลังจากทั้งหมด สิ่งนี้ขัดแย้งกับYAGNIแต่มีค่าใช้จ่ายน้อยมาก - การเรียงลำดับแบบง่าย ๆ () …

10 design-patterns  refactoring  complexity 

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

10 agile  scrum  versioning 

ฉันกำลังสร้างแอพพลิเคชั่นในไพ ธ อนด้วยไพ ธ อนแรปเปอร์สำหรับ WPF และด้วยการรองรับ DAG ขณะนี้ฉันอยู่ในจุดที่ฉันต้องตัดสินใจเลือกวิธีที่สอดคล้องกันในการโต้ตอบระหว่างข้อมูลและมุมมอง เท่าที่ฉันเห็นมีอยู่สองวิธีที่ชัดเจนในปัจจุบัน สิ่งแรกนั้นคล้ายกับโครงสร้างแอปพลิเคชัน Android คุณมีตัวควบคุมที่กำหนด / เติมมุมมอง ดังนั้นคอนโทรลเลอร์จึงเป็นเจ้าของมุมมองและผลักดันเฉพาะข้อมูลดั้งเดิมที่จะแสดง มุมมองเป็นเพียงเลเยอร์โง่และไม่รู้ว่าเกิดอะไรขึ้นและข้อมูลมาจากไหน และถ้าผู้ใช้โต้ตอบกับมุมมองมันจะส่งการเรียกกลับไปยังตัวควบคุม (ถ้าลงทะเบียนแล้ว) UserInfoController.py userInfoView = UserInfoView() userInfoView.onGenderChangedCallback = self.onGenderChangedCallback userInfoView.setUserGenderValue(user.getGender()) UserInfoView.py def setUserGenderValue(self, gender): self.userGender = gender def getView(self): return ui.Label(self.userGender, onEditCallback=self.onGenderChangedCallback) ประการที่สองคือการส่งแบบจำลอง (การอ้างอิง) ไปยังมุมมองและให้มุมมองเพื่อดึงและอัปเดตข้อมูล มุมมองในขณะนี้มีรูปแบบและดังนั้นจึงสามารถปรับปรุงได้โดยไม่ต้องโทรกลับไปที่ตัวควบคุมเพิ่มเติม UserInfoViewModel.py self.gender = 'Male' UserInfoView.py def getView(self): …

10 model  view 

ฉันได้พบกับคำย่อ MDSE วันนี้ใน infoqและข้อมูลที่ฉันสามารถค้นหาสิ่งที่ค่อนข้างชัดเจนและคำอธิบายที่เต็มไปด้วย buzzwords: MDSE เป็นเรื่องเกี่ยวกับการทำให้วิศวกรซอฟต์แวร์ทำงานในระดับที่เป็นนามธรรมซึ่งความต้องการข้อมูลสถาปัตยกรรมและการออกแบบได้รับการสั่งซื้อสูงสุด (ในแง่ของข้อมูล "เอนโทรปี") และเก็บรักษาไว้ (เรียกสิ่งนี้ว่า "งานออกแบบผลิตภัณฑ์") นอกจากนี้ MDSE ควรให้วิศวกรมีวิธีการตรวจสอบและตรวจสอบความถูกต้องของการออกแบบของพวกเขาในแง่ของ "ผลิตภัณฑ์งานออกแบบ" เป็นหลัก และเห็นได้ชัดว่าทุกคนกำลังทำมัน: (จากบทความอีกครั้ง) เรากำลังใกล้จะถึงยุคของ MDSE แล้ว ในอีก 5 - 10 ปีข้างหน้าเราจะเห็นการเปลี่ยนแปลงอย่างมีนัยสำคัญต่อ MDSE เท่าที่ฉันเชื่อว่าภายในสิ้นระยะเวลานี้บางที 60 - 80% ของซอฟต์แวร์จะได้รับการออกแบบโดยใช้เทคนิคแบบจำลอง ฉันต้องการคำอธิบายที่เป็นรูปธรรมและไม่มีคำบอกเล่าเกี่ยวกับสิ่งที่ MDSE เป็นรูปธรรม มันคือการวาดกล่อง UML และสร้างรหัสด้วยเช่นที่พวกเขาทำใน 90s กับ Rational Rose? (ในขณะที่อยู่ในนั้นถ้าใครมีตัวอย่างของซอฟต์แวร์ที่สร้างขึ้นโดยใช้เทคนิคเหล่านั้นฉันอยากจะเห็นตัวอย่างที่เป็นรูปธรรมจริงๆ)

10 methodology 

ฉันเพิ่งอ่านเกี่ยวกับ@ImplementedByคำอธิบายประกอบที่มีอยู่ในGoogle Guice อนุญาตให้โปรแกรมเมอร์ระบุการเชื่อมโยงระหว่างอินเตอร์เฟสและการนำไปใช้เพื่อใช้ในอนาคตในการฉีดพึ่งพา มันเป็นตัวอย่างของหนึ่งเพียงในเวลาที่มีผลผูกพัน ฉันค่อนข้างคุ้นเคยกับการกำหนดการผูกอย่างชัดเจนในโมดูลของฉันโดยใช้ไวยากรณ์ต่อไปนี้: bind(SomeInterface.class).to(SomeInterfaceImplementation.class); ตามเอกสารนี้เทียบเท่ากับการใช้@ImplementedByคำอธิบายประกอบต่อไปนี้: @ImplementedBy(SomeInterfaceImplementation.class) public interface SomeInterface { //method declarations } กำไรเดียวที่ฉันเห็นที่นี่คือรหัสสั้นลงเล็กน้อย ในเวลาเดียวกันวิธีการนี้มีข้อเสียเปรียบชี้ให้เห็นอย่างถูกต้องโดยเอกสารเดียวกัน: ใช้@ImplementedByอย่างระมัดระวัง มันเพิ่มการพึ่งพาเวลารวบรวมจากอินเทอร์เฟซเพื่อการใช้งาน การพึ่งพาดังกล่าวอาจไม่เป็นปัญหาในหลายกรณี แต่โดยส่วนตัวแล้วฉันเห็นว่ามันเป็นกลิ่นรหัส กรณีการใช้งานใดที่ทำให้การเพิ่มความคิดเห็นมี@ImplementedByค่าควรใช้ วิธีหนึ่งที่เป็นไปได้คือการใช้มันในโค้ดของไลบรารีหรือกรอบงาน ดังที่อธิบายไว้ในเอกสารคำอธิบายประกอบสามารถจัดเตรียมการโยงดีฟอลต์ได้ง่าย ๆ หากประเภทอยู่ในทั้งสองbind()คำสั่ง (เป็นอาร์กิวเมนต์แรก) และมี@ImplementedByคำอธิบายประกอบคำbind()สั่งจะถูกนำมาใช้ คำอธิบายประกอบแนะนำการใช้งานเริ่มต้นที่สามารถแทนที่ด้วยการผูก ด้วยวิธีนี้ในฐานะนักพัฒนาของห้องสมุดฉันสามารถให้ผู้ใช้ของฉันมีส่วนร่วมนอกกรอบที่สามารถปรับแต่งที่ไหนสักแห่งในรหัสลูกค้า นี่เป็นเหตุผลเดียวที่มีคำอธิบายประกอบอยู่หรือไม่ หรือมีบางอย่างที่ฉันขาดหายไป? ฉันจะได้อะไรจากการใช้มันในโค้ดที่เป็นเพียงแอปพลิเคชันที่ดูแลตรรกะทางธุรกิจบางอย่างและไม่สามารถขยายไลบรารี / กรอบงานได้หรือไม่?

10 java  dependency-injection 

หลังจากคำตอบที่มีประโยชน์สองสามข้อว่าฉันควรใช้วัตถุโดเมนหรือรหัสที่ไม่ซ้ำกันเป็นพารามิเตอร์วิธีการ / ฟังก์ชั่นที่นี่ตัวบ่งชี้ vs วัตถุโดเมนเป็นพารามิเตอร์วิธีฉันมีคำถามที่คล้ายกันอีกสมาชิก: (การอภิปรายคำถามก่อนหน้านี้ไม่ได้จัดการ ครอบคลุมสิ่งนี้) ข้อดีและข้อเสียของการใช้ ID ที่ไม่ซ้ำกันในฐานะสมาชิก vs object เป็นสมาชิกคืออะไร ฉันกำลังขอให้อ้างอิงกับภาษาที่พิมพ์อย่างมากเช่น Scala / C # / Java ฉันควรจะมี (1) User( id: Int, CurrentlyReadingBooksId: List[Int]) Book( id: Int, LoanedToId: Int ) หรือ (2) เป็นที่ต้องการสำหรับ (1) หลังจากผ่าน: เราควรกำหนดประเภทสำหรับทุกสิ่งหรือไม่ User( id: UserId, CurrentlyReadingBooksId: List[ BookId] ) Book( id: BookId, LoanedToId: …

10 coding-style 

การทำต่อเนื่องนั้นมีประโยชน์อย่างมากในภาษาโปรแกรมที่ใช้งานได้ (เช่นContmonad ใน Haskell) เพราะพวกมันยอมให้สัญกรณ์ง่ายและสม่ำเสมอสำหรับโค้ดสไตล์ที่จำเป็น นอกจากนี้ยังมีประโยชน์ในภาษาที่จำเป็นบางอย่างที่เก่ากว่าเพราะสามารถใช้ในการใช้คุณสมบัติภาษาที่ขาดหายไป (เช่นข้อยกเว้น coroutines, เธรดสีเขียว) แต่สำหรับภาษาเชิงวัตถุที่ทันสมัยด้วยการสนับสนุนในตัวสำหรับคุณลักษณะเหล่านี้สิ่งที่มีปากเสียงจะมีเป็นยังเพิ่มการสนับสนุนสำหรับตชั้นแรก (ไม่ว่าจะรูปแบบที่คั่นที่ทันสมัยมากขึ้นresetและshiftหรือโครงการเหมือนcall-with-current-continuation)? มีการขัดแย้งกับการเพิ่มการสนับสนุนอื่น ๆ นอกเหนือจากประสิทธิภาพการทำงานและความซับซ้อนของการดำเนินการ?

10 language-design  continuation 

พื้นหลัง ฉันกำลังทำงานกับแอพสำหรับลูกค้าที่มีคุณสมบัติเครือข่ายสังคมบางอย่าง ตอนแรกฉันพัฒนามือถือส่วนหน้า แต่สถานการณ์ก็ทำให้ฉันต้องรับผิดชอบด้านการพัฒนาด้านหลังเช่นกัน ในฐานะที่เป็นพื้นหลังทั่วไประบบของเราอนุญาตให้ผู้ใช้ติดตามผู้ใช้รายอื่นและรับการแจ้งเตือนเกี่ยวกับสิ่งที่พวกเขากำลังติดตามดังที่คุณคาดหวังจากเครือข่ายสังคมออนไลน์ ข้อแม้คือว่าจะมีเพียงผู้ใช้ชุดย่อยขนาดเล็ก (อย่างน้อยไม่กี่ร้อย) โดยมีความคาดหวังว่าฐานผู้ใช้ส่วนใหญ่จะติดตามบุคคลเหล่านี้อย่างน้อยหนึ่งคน ทางด้าน UI เราจะมีปุ่มแจ้งเตือนพร้อมตัวเลขและการคลิกปุ่มจะนำคุณไปยังหน้าจอการแจ้งเตือน ปัญหา ฉันค้นคว้ากลยุทธ์ในการใช้งานการแจ้งเตือนและทรัพยากรส่วนใหญ่ที่ฉันพบพบว่าสร้างตารางการแจ้งเตือนหนึ่งตารางขึ้นไปในฐานข้อมูล (ตัวอย่างที่ฉันชอบคือคำตอบที่ยอมรับได้ที่นี่: /programming/9735578/building-a-notification-system ) สิ่งที่ทิ้งฉันไปคือกลยุทธ์การขับเคลื่อนฐานข้อมูลส่วนใหญ่สำหรับการแจ้งเตือนจำเป็นต้องแทรกแถวสำหรับการแจ้งเตือนแต่ละรายการสำหรับผู้ติดตามแต่ละคน ดังนั้นหากคนนับพันติดตามแซลลี่เราจะแทรกหนึ่งพันแถวลงในตารางที่เกี่ยวข้อง ปรับขนาดได้หรือไม่ จะเกิดอะไรขึ้นถ้าเราไปถึงจุดที่ผู้ใช้หลายสิบหรือหลายแสนคนติดตาม Sally และเธอกำลังโพสต์ไม่กี่โหลต่อวัน แนวคิดดั้งเดิมของฉันคือการจัดการทุกอย่างด้วยข้อความค้นหา: หมายเลขบนปุ่มแจ้งเตือนจะได้รับโดยขอจำนวนแถวของเนื้อหาที่โพสต์เร็วกว่าครั้งล่าสุดที่คุณเยี่ยมชมหน้าจอการแจ้งเตือนในขณะที่การแจ้งเตือนแต่ละรายการจะถูกสร้างขึ้น เมื่อคุณเยี่ยมชมหน้าจอการแจ้งเตือน วิธีนี้จะไม่ต้องมีการเขียนหรือการเก็บข้อมูลเพิ่มเติม แต่ยืดหยุ่นและอาจค้อนเซิร์ฟเวอร์ค่อนข้างยาก ติดตั้ง แบ็กเอนด์ (ตามที่กำหนดโดยผู้พัฒนาก่อนหน้านี้) ใช้CodeIgniterและฐานข้อมูลMySQL ขณะนี้กำลังทำงานบนบัญชีโฮสติ้งที่ใช้ร่วมกันแบบเส็งเคร็ง GoDaddy แต่ฉันคิดว่า (หวังว่า) สิ่งนี้จะได้รับการอัปเกรดก่อนที่เราจะเข้าสู่การผลิตและแพ็คเกจโฮสติ้งจะถูกปรับสัดส่วนตามการเติบโตของผู้ใช้ ปัจจุบันส่วนหน้าของเราคือแอพมือถือ แต่เราวางแผนที่จะสร้างเว็บไซต์ในภายหลัง ฉันไม่ได้กังวลเกี่ยวกับการได้รับการอัพเดตแบบพุชแบบเรียลไทม์จากเซิร์ฟเวอร์เกี่ยวกับการแจ้งเตือน ภาคผนวก ฉันไม่เชี่ยวชาญในแบ็กเอนด์และฉันอยู่ในหัวของฉันในแผนกนั้น ลูกค้ารู้และฉันพยายามอย่างเต็มที่ที่จะอธิบายขอบเขตของโครงการในลักษณะนี้ แต่พวกเขาทำให้มันชัดเจนว่า ณ จุดนี้พวกเขาจะไม่ไว้ใจคนอื่นให้ทำงานในโครงการ เราอาจมีงานอีกเดือนที่ต้องทำก่อนที่จะเริ่มเพิ่มผู้ทดสอบและฉันจะได้รับการวัดประสิทธิภาพใด ๆ ฉันไม่สามารถประมาณจำนวนผู้ใช้ที่เราอาจมีหรือฮาร์ดแวร์ที่เราอาจจะเปิดตัวในอีก 5 ปีข้างหน้า …

10 design  php  mysql  social-networks 

ฉันกำลังเรียนรู้การเขียนโปรแกรมฟังก์ชั่นและฉันมีปัญหาในการทำความเข้าใจว่าบางสถานการณ์ถูกนำไปใช้โดยไม่ได้รับมอบหมาย ปัญหาง่าย ๆ ดังต่อไปนี้ค่อนข้างจะทำให้ฉันสับสน เขียนโปรแกรมที่รับเหตุการณ์เกี่ยวกับการเปลี่ยนแปลงในโครงสร้างข้อมูลที่กำหนดและส่งเหตุการณ์เมื่อโครงสร้างข้อมูลนี้ถึงสถานะที่แน่นอน ดังนั้นฉันจึงมีสำเนาของโครงสร้างข้อมูลที่ฉันเก็บไว้ datastructure_copy::DataStructure ฉันมีกระแสของเหตุการณ์ที่ถูกไล่ออกเมื่อมีการเปลี่ยนแปลง: datastructure_changes::Stream Change ฉันมีฟังก์ชั่นที่ใช้การเปลี่ยนแปลงกับโครงสร้างข้อมูลและส่งคืนสำเนาใหม่: apply_change::Change -> DataStructure -> DataStructure และฉันมีภาคที่ตรวจสอบว่าสถานะข้อมูลได้ถึงสถานะที่ต้องการ is_ready::DataStructure ->Boolean กล่าวอีกนัยหนึ่งฉันต้องการบางสิ่งเช่น 'ลด' ที่ทำงานบนสตรีม ฉันรู้ว่าวิธีหนึ่งในการดำเนินการนี้คือการคำนวณสถานะใหม่ทุกครั้งที่มีการเปลี่ยนแปลงมาถึงอย่างไรก็ตามสิ่งนี้ดูเหมือนจะไม่จริง ฉันเล่นกับ Monad ของรัฐ แต่ดูเหมือนว่าฉันจะแก้ปัญหาที่แตกต่าง ดังนั้นมีวิธีอื่นในการทำเช่นนั้น? โปรดทราบว่าคำถามของฉันเป็นแนวคิดอย่างหมดจดและฉันไม่คุ้นเคยอย่างลึกซึ้งกับ Haskell

10 functional-programming  haskell  reactive