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

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

10 microservices 

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

10 architecture  database  web-services  microservices  services 

พิจารณาสองคลาสDogและCatทั้งสองสอดคล้องกับAnimalโปรโตคอล (ในแง่ของภาษาการเขียนโปรแกรม Swift นั่นคืออินเทอร์เฟซใน Java / C #) เรามีหน้าจอที่แสดงรายการสุนัขและแมวที่หลากหลาย มีInteractorคลาสที่จัดการตรรกะเบื้องหลัง ตอนนี้เราต้องการที่จะนำเสนอการแจ้งเตือนการยืนยันให้กับผู้ใช้เมื่อเขาต้องการที่จะลบแมว อย่างไรก็ตามสุนัขจะต้องถูกลบทันทีโดยไม่มีการแจ้งเตือนใด ๆ วิธีที่มีเงื่อนไขจะมีลักษณะเช่นนี้: func tryToDeleteModel(model: Animal) { if let model = model as? Cat { tellSceneToShowConfirmationAlert() } else if let model = model as? Dog { deleteModel(model: model) } } รหัสนี้จะถูก refactored ได้อย่างไร? เห็นได้ชัดว่ามันมีกลิ่น

10 architecture  refactoring  software  architectural-patterns  polymorphism 

ฉันเพิ่งทำภารกิจการเขียนภาษาโปรแกรมสแต็ก ก่อนที่ฉันจะเริ่มออกแบบภาษาของฉัน แต่ฉันคิดว่ามันเป็นความคิดที่ดีที่จะอ่านและทดลองใช้ภาษาที่มีอยู่เดิม นี่นำฉันมาที่หัวข้อของโพสต์นี้ ฉันอ่านบทความวิกิพีเดียใน Forthซึ่งเป็นภาษาที่ใช้สแต็กซึ่งใช้การแสดงออกสไตล์ postfix ในบทความฉันเห็นข้อความต่อไปนี้: ความยืดหยุ่นของ Forth ทำให้ไวยากรณ์ BNF คงที่ไม่เหมาะสมและไม่มีคอมไพเลอร์เสาหิน การขยายคอมไพเลอร์เพียงต้องการเขียนคำใหม่แทนที่จะแก้ไขไวยากรณ์และเปลี่ยนการใช้งานพื้นฐาน จากความเข้าใจของฉันในศัพท์แสง Forth คำว่า "คำว่า" ดูเหมือนจะตรงกันกับ "subroutine" ด้วยสิ่งนี้ข้อความข้างต้นดูเหมือนแปลก ทำไมความสามารถในการสร้างฟังก์ชั่นใหม่ใน Forth จึงทำให้ไวยากรณ์เป็นทางการสำหรับ Forth ไม่เหมาะสม? ทำไมคุณต้องเขียนไวยากรณ์ใหม่สำหรับแต่ละรูทีนย่อยใหม่ที่คุณกำหนด การเขียนคำศัพท์ใหม่ในสภาพแวดล้อมประกอบด้วยการขยายคอมไพเลอร์อย่างไร ข้อความข้างต้นดูเหมือนจะคล้ายกับว่าไวยากรณ์อย่างเป็นทางการไม่เหมาะสมสำหรับ Python เพราะคุณสามารถกำหนดฟังก์ชั่นใหม่ได้ ในความเป็นจริงฉันตัดสินใจที่จะพยายามเขียนไวยากรณ์สไตล์ BNF สำหรับชุดย่อยง่ายๆของ Forth ด้านล่าง: program ::= stmt+ stmt ::= func | expr func ::= ':' expr+ ';' expr …

10 compiler  syntax  grammar  stack-oriented  forth 

ฉันต้องการสร้างระบบที่จัดการข้อความแจ้งเตือนจากโปรแกรมต่าง ๆ และสามารถประมวลผลการแจ้งเตือนเหล่านั้นไปยังผู้บริโภคที่ไม่ต้องการทางอีเมล ทั้งหมดนี้จะถูกเก็บไว้ในเครือข่ายภายในหนึ่งเครือข่าย ฉันคิดว่าฉันต้องการสถาปัตยกรรมพื้นฐานที่มีลักษณะเช่นนี้: ข้อกังวลหลักที่ฉันมีอยู่ในปัจจุบันคือบิต "ตัวจัดการข้อความ" ซึ่งเป็นสิ่งที่จะเป็น "sort-of-API" ของฉัน ฉันต้องการส่วนประกอบทั้งหมดของระบบนี้เพื่อส่งข้อมูลไปยัง API ซึ่งจัดการการเขียนทั้งหมดไปยังฐานข้อมูล ฉันคิดว่าวิธีนี้ง่ายกว่าเพราะมันช่วยลดความปลอดภัยและช่วยให้ฉันมีการสืบค้น DB ที่ซับซ้อนมากขึ้นในโปรแกรมเดียว ข้อกังวลคือฉันต้องการให้สิ่งนี้เป็นผู้ไม่เชื่อเรื่องภาษา - หมายความว่ารหัสใด ๆ ควรจะสามารถส่งข้อความไปยังตัวจัดการของฉัน - ซึ่งจะตีความพวกเขา ฉันหวังว่าจะทำสิ่งนี้ผ่านไฟล์แบน JSON - หรือผ่านการเรียกใช้ REST ไปยังโปรแกรม (ให้ความยืดหยุ่นกับแอพพลิเคชั่นดาวน์สตรีม) คำถามของฉันคือ - ฉันควรรบกวนตัวจัดการข้อความหรือไม่หรือจะเพิ่มความเรียบง่ายให้อนุญาตการเข้าถึงฐานข้อมูลโดยตรงไปยังแอพพลิเคชั่นดาวน์สตรีมรวมถึงส่วนประกอบอื่น ๆ สองตัว (Management Console และ Alert Manager) ด้วยวิธีนี้พวกเขาสามารถแทรกการแจ้งเตือนใดก็ได้ที่พวกเขาต้องการ - ตราบใดที่ INSERT ในตาราง DB / s นั้นถูกต้อง ฉันไม่ได้เป็นนักออกแบบซอฟต์แวร์โดยการค้าขอตัวฉัน …

10 design  design-patterns  architecture  api  api-design 

ฉันมีโครงการที่มีขนาดใหญ่พอที่ฉันไม่สามารถเก็บทุกแง่มุมไว้ในหัวของฉันได้อีก ฉันกำลังจัดการกับคลาสและฟังก์ชั่นจำนวนมากในนั้นและฉันกำลังส่งข้อมูลไปรอบ ๆ เมื่อเวลาผ่านไปฉันสังเกตว่าฉันยังคงได้รับข้อผิดพลาดอยู่เพราะฉันลืมว่ารูปแบบข้อมูลที่แม่นยำมีอะไรบ้างเมื่อฉันส่งมันไปยังฟังก์ชั่นที่แตกต่างกัน ( เช่นหนึ่งฟังก์ชั่นยอมรับและส่งออกอาเรย์ของสตริง ยอมรับสตริงที่ถูกเก็บไว้ในพจนานุกรม ฯลฯ ดังนั้นฉันจึงต้องเปลี่ยนสตริงที่ฉันทำงานด้วยจากการมีสตริงในอาร์เรย์เป็นสตริงในพจนานุกรม ) เพื่อหลีกเลี่ยงการต้องคิดออกว่าเกิดอะไรขึ้นฉันมักจะรักษาแต่ละฟังก์ชั่นและคลาสว่าเป็น "เอนทิตี้แยกตัว" ในแง่ที่ว่ามันไม่สามารถพึ่งพาโค้ดภายนอกที่ให้อินพุตที่ถูกต้องและต้องทำการตรวจสอบอินพุตเอง ในบางกรณีให้กำหนดข้อมูลใหม่หากข้อมูลได้รับในรูปแบบที่ไม่ถูกต้อง) สิ่งนี้ได้ลดเวลาที่ใช้ไปอย่างมากเพื่อให้แน่ใจว่าข้อมูลที่ฉันส่งไป "เหมาะกับ" ในทุกฟังก์ชั่นเพราะตอนนี้คลาสและฟังก์ชั่นของตัวเองเตือนฉันเมื่ออินพุตบางอย่างไม่ดี (และบางครั้งก็แก้ไขได้) ต้องใช้ดีบักเกอร์ผ่านโค้ดทั้งหมดอีกต่อไปเพื่อหาว่ามีอะไรเกิดขึ้นบ้าง อีกทางหนึ่งก็เพิ่มรหัสโดยรวมเช่นกัน คำถามของฉันคือถ้ารูปแบบรหัสนี้เหมาะสมสำหรับการแก้ปัญหานี้หรือไม่ แน่นอนทางออกที่ดีที่สุดคือการ refactor โครงการอย่างสมบูรณ์และตรวจสอบให้แน่ใจว่าข้อมูลมีโครงสร้างที่เหมือนกันสำหรับทุกฟังก์ชั่น - แต่เนื่องจากโครงการนี้เติบโตอย่างต่อเนื่องฉันจะจบลงด้วยการใช้จ่ายมากขึ้นและกังวลเกี่ยวกับรหัสสะอาด . (FYI: ฉันยังเป็นผู้เริ่มต้นดังนั้นโปรดแก้ตัวหากคำถามนี้ไร้เดียงสาโครงการของฉันอยู่ใน Python)

10 python  coding-style  data-structures  refactoring  code-quality 

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

10 agile 

การเขียนวัตถุผู้ใช้ในสวิฟท์ แต่คำถามของฉันเกี่ยวข้องกับภาษาที่พิมพ์ออกมาอย่างรุนแรง ผู้ใช้สามารถมีลิงก์จำนวนมาก (FacebookProfile, InstagramProfile, ฯลฯ ) คำถามสองสามข้อเกี่ยวกับเรื่องนี้ เป็นการดีที่จะรวมลิงก์ในวัตถุของตนเองหรือไม่? struct ผู้ใช้ { var firstName: string var lastName: string อีเมล var: สตริง ลิงก์ var: ลิงค์ } ลิงค์โครงสร้าง { var facebook: string var instagram: string var twitter: string } หรือพวกเขาควรจะหลวม? ฉันรู้ว่าทั้งสองวิธีใช้เทคนิคดี แต่สงสัยว่ามีวิธีแนะนำโดยทั่วไปหรือไม่โดยเฉพาะอย่างยิ่งสำหรับการอ่าน struct User { var firstName: string var lastName: string var …

10 java  c#  object-oriented  data-structures  swift-language 

ตัวอย่างเช่นคลาสมักจะมีสมาชิกชั้นเรียนและวิธีการเช่น: public class Cat{ private String name; private int weight; private Image image; public void printInfo(){ System.out.println("Name:"+this.name+",weight:"+this.weight); } public void draw(){ //some draw code which uses this.image } } แต่หลังจากอ่านเกี่ยวกับหลักการความรับผิดชอบเดี่ยวและหลักการเปิดแบบปิดฉันชอบแยกคลาสออกเป็น DTO และคลาสตัวช่วยด้วยวิธีสแตติกเท่านั้นเช่น: public class CatData{ public String name; public int weight; public Image image; } public class CatMethods{ public static …

10 object-oriented  static-methods  dto 

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

10 design  design-patterns  object-oriented  refactoring  clean-code 

ฉันได้อ่านบทความบทความและส่วน 4.1.4 ตอนที่ 4 ของคอมไพเลอร์: หลักการเทคนิคและเครื่องมือ (รุ่นที่ 2) (หรือที่รู้จักกันในชื่อ "The Dragon Book") ซึ่งทุกคนกล่าวถึงหัวข้อการกู้คืนข้อผิดพลาดทางไวยากรณ์ อย่างไรก็ตามหลังจากทดลองกับคอมไพเลอร์สมัยใหม่หลาย ๆ ตัวฉันได้เห็นแล้วว่าพวกเขากู้คืนจากข้อผิดพลาดทางความหมายเช่นเดียวกับข้อผิดพลาดทางไวยากรณ์ ฉันเข้าใจอัลกอริทึมและเทคนิคที่อยู่เบื้องหลังคอมไพเลอร์ที่กู้คืนจากข้อผิดพลาดเกี่ยวกับวากยสัมพันธ์ แต่ฉันไม่เข้าใจว่าคอมไพเลอร์สามารถกู้คืนจากข้อผิดพลาดทางความหมายได้อย่างไร ขณะนี้ฉันกำลังใช้รูปแบบผู้เยี่ยมชมที่แตกต่างกันเล็กน้อยเพื่อสร้างรหัสจากแผนผังไวยากรณ์นามธรรมของฉัน พิจารณาคอมไพเลอร์ของฉันรวบรวมการแสดงออกต่อไปนี้: 1 / (2 * (3 + "4")) คอมไพเลอร์จะสร้างแผนผังไวยากรณ์นามธรรมต่อไปนี้: op(/) | ------- / \ int(1) op(*) | ------- / \ int(2) op(+) | ------- / \ int(3) str(4) ขั้นตอนการสร้างรหัสจะใช้รูปแบบผู้เยี่ยมชมเพื่อสำรวจทรีไวยากรณ์แบบนามธรรมซ้ำ ๆ และดำเนินการตรวจสอบชนิด …

10 design  design-patterns  language-agnostic  type-systems 

ฉันเพิ่งอ่านhttps://techfindings.one/archives/2652เกี่ยวกับการเขียนโปรแกรมการทำงานและมาพร้อมกับสิ่งนี้: ฟังก์ชั่นที่ไม่ระบุชื่อมักจะไม่สามารถรวบรวม JIT และจะไม่ถูกปรับ มีคนอธิบายให้ฉันฟังได้ไหมว่าเพราะอะไรในกรณีนี้

10 javascript  functional-programming 

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

10 database  concurrency 

ใน C ++ โครงการของฉันฉันมีสองชั้นและParticle ContactในParticleระดับที่ฉันมีตัวแปรสมาชิกstd::vector<Contact> contactsที่มีรายชื่อทั้งหมดของParticleวัตถุและสอดคล้องฟังก์ชันสมาชิกและgetContacts() addContact(Contact cont)ดังนั้นใน "Particle.h" ฉันรวม "Contact.h" ในContactชั้นเรียนฉันต้องการเพิ่มรหัสไปยังตัวสร้างContactที่จะเรียกParticle::addContact(Contact cont)เพื่อให้contactsมีการปรับปรุงสำหรับParticleวัตถุทั้งสองระหว่างContactวัตถุที่จะถูกเพิ่ม ดังนั้นฉันจะต้องรวม "Particle.h" ใน "Contact.cpp" คำถามของฉันคือสิ่งนี้เป็นที่ยอมรับ / ฝึกการเขียนโปรแกรมที่ดีหรือไม่และหากไม่มีสิ่งใดจะเป็นวิธีที่ดีกว่าที่จะใช้สิ่งที่ฉันพยายามทำให้สำเร็จ (เพียงแค่อัปเดตรายชื่อผู้ติดต่อสำหรับอนุภาคเฉพาะโดยอัตโนมัติ ถูกสร้าง) คลาสเหล่านี้จะถูกผูกเข้าด้วยกันโดยNetworkคลาสที่จะมี N particles ( std::vector<Particle> particles) และ Nc contact ( std::vector<Contact> contacts) แต่ฉันต้องการที่จะมีฟังก์ชั่นเช่นparticles[0].getContacts()- มันไม่เป็นไรที่จะมีฟังก์ชั่นดังกล่าวในParticleชั้นเรียนในกรณีนี้หรือมีโครงสร้าง "เชื่อมโยง" ที่ดีขึ้นใน C ++ สำหรับวัตถุประสงค์นี้ (ของสองคลาสที่เกี่ยวข้องที่ใช้ในชั้นเรียนอื่น) . ฉันอาจต้องเปลี่ยนมุมมองที่นี่ในวิธีที่ฉันเข้าใกล้นี้ เนื่องจากทั้งสองคลาสเชื่อมต่อกันด้วยNetworkอ็อบเจกต์คลาสเป็นรหัสองค์กร / คลาสทั่วไปที่มีข้อมูลการเชื่อมต่อที่ควบคุมโดยNetworkวัตถุทั้งหมด (ในที่วัตถุ Particle ไม่ควรรับรู้รายชื่อผู้ติดต่อและดังนั้นจึงไม่ควรมีgetContacts()สมาชิก …

10 c++  class-design  class 

หนึ่งในคุณสมบัติที่เสนอสำหรับ "Project Coin" ของ Java 7 คือ "โอเปอเรเตอร์ Elvis" รายงานนำเสนอ 2,009 JavaOneโครงการเหรียญอธิบายว่ามันเป็นเช่น: หนึ่งใน "คุณสมบัติเล็ก ๆ " ที่กล่าวถึงในงานนำเสนอนี้คือสิ่งที่เรียกว่า "ผู้ดำเนินการ Elvis" ซึ่งเป็นผู้ประกอบการรุ่นที่สั้นกว่า ฉันพบว่าตัวเองขาดคุณสมบัติบางอย่างของ Groovy เมื่อใช้ Java แบบดั้งเดิมและนี่จะเป็นโอเปอเรเตอร์เดียวที่ฉันสามารถใช้ได้ทั้งสองภาษาหากมีการเพิ่มเข้ามา โอเปอเรเตอร์ "Elvis" มีประโยชน์สำหรับการระบุค่าเริ่มต้นที่สามารถใช้เมื่อนิพจน์ที่ประเมินเป็นโมฆะ เช่นเดียวกับโอเปอเรเตอร์ที่ปลอดภัยของ Groovy มันเป็นวิธีรัดกุมในการระบุวิธีหลีกเลี่ยงค่า null ที่ไม่จำเป็น ฉันบล็อกก่อนหน้านี้เกี่ยวกับวิธีที่ฉันต้องการหลีกเลี่ยง NullPointerException ในขณะที่แง่มุมอื่น ๆ ของ Project Coin ถูกนำไปใช้ในท้ายที่สุด เหตุใด Elvis Operator จึงปฏิเสธในที่สุดแม้ว่าจะถูกนำเสนอที่ JavaOne ในฐานะผู้สมัครที่น่าจะได้รับการคัดเลือก เพื่อความชัดเจนฉันถามเฉพาะผู้ดำเนินการนี้และเหตุผลที่ถูกปฏิเสธเนื่องจากเป็นส่วนหนึ่งของ "Project Coin" …

10 java  api-design