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

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

15 programming-practices  abstraction  strategy  low-level  high-level 

ฉันมีวิธีที่สร้างไฟล์ข้อมูลหลังจากคุยกับกระดานดิจิตอล: CreateDataFile(IFileAccess boardFileAccess, IMeasurer boardMeasurer) ที่นี่boardFileAccessและboardMeasurerเป็นเช่นเดียวกันของBoardวัตถุว่าการดำเนินการทั้งในและIFileAccess ใช้ในกรณีนี้สำหรับวิธีการเดียวที่จะตั้งหนึ่งพินบนกระดานเพื่อให้การวัดง่าย ข้อมูลที่ได้จากการวัดนี้จะถูกเก็บไว้แล้วไว้บนกระดานโดยใช้ ตั้งอยู่ในโครงการแยกต่างหากIMeasurerIMeasurerIFileAccessBoard ฉันมาถึงข้อสรุปที่CreateDataFileทำสิ่งหนึ่งโดยทำการวัดอย่างรวดเร็วแล้วเก็บข้อมูลและการทำทั้งสองอย่างในวิธีเดียวกันนั้นง่ายกว่าสำหรับคนอื่นที่ใช้รหัสนี้จากนั้นจึงต้องทำการวัดและเขียนไฟล์ เป็นการเรียกเมธอดแยกต่างหาก สำหรับฉันดูเหมือนว่าไม่เหมาะสมที่จะส่งวัตถุเดียวกันไปยังวิธีการสองครั้ง ฉันได้พิจารณาการทำอินเตอร์เฟซในท้องถิ่นIDataFileCreatorที่จะขยายIFileAccessและIMeasurerแล้วมีการดำเนินการที่มีBoardอินสแตนซ์ที่เพิ่งจะโทรที่จำเป็นต้องใช้Boardวิธีการ พิจารณาว่าวัตถุบอร์ดเดียวกันจะใช้สำหรับการวัดและการเขียนไฟล์เสมอหรือไม่มันเป็นวิธีที่ไม่ถูกต้องหรือไม่ที่จะส่งวัตถุเดียวกันไปยังวิธีการสองครั้ง? ถ้าเป็นเช่นนั้นใช้อินเทอร์เฟซท้องถิ่นและการใช้งานโซลูชันที่เหมาะสมหรือไม่

15 c#  interfaces  methods  parameters 

ฉันไม่ได้กำลังมองหาความคิดเห็นเกี่ยวกับความหมาย แต่เพียงสำหรับกรณีที่มีการใช้ getters อย่างสมเหตุสมผลเป็นอุปสรรคจริง บางทีมันอาจทำให้ฉันกลายเป็นเกลียวที่ไม่มีที่สิ้นสุดของการพึ่งพาพวกเขาบางทีอาจเป็นทางเลือกที่สะอาดและจัดการกับผู้ได้รับโดยอัตโนมัติ ฯลฯ บางอย่างเป็นรูปธรรม ฉันได้ยินข้อโต้แย้งทั้งหมดฉันได้ยินมาว่าพวกเขาไม่ดีเพราะพวกเขาบังคับให้คุณปฏิบัติต่อวัตถุในฐานะแหล่งข้อมูลว่าพวกเขาละเมิด "สถานะบริสุทธิ์" ของ "วัตถุ" อย่าให้มากเกินไป แต่เตรียมที่จะ ยอมรับมาก " แต่ไม่มีเหตุผลที่สมเหตุสมผลสำหรับเหตุผลที่getDataเป็นสิ่งที่ไม่ดีในความเป็นจริงไม่กี่คนที่เป็นที่ถกเถียงกันอยู่ว่ามันเป็นเรื่องเกี่ยวกับความหมาย, getters อย่างดีต่อ se แต่เพียงแค่ไม่ได้ตั้งชื่อพวกเขาgetXให้ฉันนี้อย่างน้อยตลก . อะไรคือสิ่งที่ไม่มีความคิดเห็นที่จะทำลายถ้าฉันใช้ตัวรับสัญญาณอย่างสมเหตุสมผลและสำหรับข้อมูลที่ชัดเจนว่าความสมบูรณ์ของวัตถุไม่แตกถ้ามันทำให้เกิดขึ้น แน่นอนว่าการอนุญาตให้ getter สำหรับสตริงที่ใช้ในการเข้ารหัสบางอย่างนั้นเกินกว่าจะเป็นใบ้ แต่ฉันกำลังพูดถึงข้อมูลที่ระบบของคุณต้องการใช้งาน บางทีข้อมูลของคุณจะถูกดึงผ่านProviderจากวัตถุ แต่ยังคงวัตถุยังคงต้องการที่จะช่วยให้Providerการทำ$provider[$object]->getDataมีวิธีรอบ ๆ มันไม่มี ทำไมฉันขอ: ฉัน getters เมื่อใช้อย่างสมเหตุสมผลและข้อมูลที่จะถือว่าเป็น "ปลอดภัย" จะถูกพระเจ้าส่ง 99% ของ getters ฉันจะใช้ในการระบุวัตถุในขณะที่ฉันถามรหัสผ่านObject, what is your name? Object, what is your identifier?, ทุกคนที่ทำงานกับวัตถุควรรู้สิ่งเหล่านี้เกี่ยวกับวัตถุเพราะเกือบทุกอย่างเกี่ยวกับการเขียนโปรแกรมเป็นตัวตนและใครอื่นรู้ดีกว่ามันคืออะไรตัวเอง? …

15 object-oriented 

ฉันแน่ใจว่านี่ไม่ใช่เรื่องแปลก เรามีทีมการต่อสู้สองทีมที่ทำงานได้ดีในการประเมินเรื่องราวของผู้ใช้โดยใช้จุดเรื่องราว (กลุ่มดาวในทีมปัจจุบันมีอายุประมาณ 8 เดือนเท่านั้นแม้ว่าสมาชิกในทีมจะมีประสบการณ์การต่อสู้หลายปี) แต่มันยากสำหรับส่วนธุรกิจของ บริษัท ที่เกี่ยวข้องกับเรื่องราวของผู้ใช้ พวกเขาต้องการหน่วยเวลาจริง (หรือ "สูตรในการแปลงคะแนนเรื่องราวเป็นชั่วโมง") เพื่อให้พวกเขาสามารถวางแผนได้ว่าเมื่อใดที่สิ่งต่างๆจะพร้อม ( "เราจำเป็นต้องรู้เมื่อเราสามารถบอกลูกค้าได้ว่า Feature X จะอยู่ในการผลิต " ) ฉันและผู้นำการต่อสู้ของฉันได้อธิบายว่า "ไม่มีความสัมพันธ์ที่ชัดเจนระหว่างจุดเรื่องราวและเวลาที่เกิดขึ้นจริง" และ "จุดเรื่องราวใช้เพื่อกำหนดจำนวนทีมที่สามารถวิ่งได้" และฉัน คุณสามารถเดาได้ว่าพวกเขาพึงพอใจแค่ไหนกับคำตอบนั้น พวกเขายังต้องการทราบตามเวลาในปฏิทินเมื่อเราจะไปที่เรื่องราวผู้ใช้ครั้งที่ 27 ใน Backlog ไม่ว่าในกรณีใดฉันได้รวบรวมสถิติบางส่วนและการประเมิน SP ของเราแปลเป็นผลลัพธ์ที่ใช้เวลาจริงที่แตกต่างกันอย่างดุเดือด (วัดโดยซอฟต์แวร์ scrum board ของเราซึ่งติดตามจำนวนตั๋วที่ใช้ในคอลัมน์ "กำลังทำงาน" ) สำหรับเรื่องราวของผู้ใช้ 1-SP นั้นแน่นอนว่ามีอคติอย่างหนักในช่วงเวลาสั้น ๆ (โดยมีการระเบิดขึ้นเป็นครั้งคราว) แต่โดยเฉพาะอย่างยิ่งสำหรับเรื่องราว 2-SP พวกเขาอยู่ทั่วทุกที่: มีปัจจัย 20 ระหว่างความสำเร็จ "เร็วที่สุด" …

15 scrum  estimation 

นักพัฒนาสร้างสคริปต์เพื่อช่วยในการทำงานของพวกเขา ตัวอย่างเช่นการเรียกใช้ Maven ด้วยพารามิเตอร์บางอย่างเพื่อฆ่างานพื้นหลังที่ไม่จำเป็นซึ่งครอบตัดในการพัฒนาหรือเพื่อเชื่อมต่อกับเซิร์ฟเวอร์ สคริปต์ไม่ใช่สคริปต์การสร้างหลักและไม่ได้ใช้ในเซิร์ฟเวอร์การรวมอย่างต่อเนื่องของเรา วิธีที่ดีที่สุดในการจัดการพวกเขาคืออะไร? หากต้องการใส่ไว้ในไดเรกทอรี (อาจจะ /scripts) และตรวจสอบพวกเขาใน Git? เพื่อรักษาแยกในไฟล์เซิร์ฟเวอร์บาง? อาร์กิวเมนต์สำหรับการจัดการพวกมันเป็นซอร์สโค้ดคือมันเป็นซอร์สและสามารถเปลี่ยนแปลงได้ อาร์กิวเมนต์สำหรับการไม่ทำเช่นนั้นเป็นเพียงเครื่องมือเสริมและนักพัฒนาบางคนไม่ต้องการสคริปต์ที่กำหนด (เช่นสคริปต์เฉพาะ Linux ที่ผู้พัฒนาบางรายทำงานบน Windows)

15 scripting  command-line 

ฉันสร้างโปรเจ็กต์เล็ก ๆ กับเพื่อนของฉัน แต่เรามักจะเจอกับความผิดพลาดซ้ำแล้วซ้ำอีก ฉันรู้วิธีเขียน PHP, Javascript และทุกอย่าง (ฉันรู้ CSS และ HTML) ดังนั้นฉันจึงสามารถทำงานส่วนใหญ่เมื่อมันมาถึงการสร้างฟังก์ชันการทำงานจริง อย่างไรก็ตามเขาทำไม่ได้ แต่เขาสามารถทำสิ่งที่ฉันแทบจะไม่สามารถทำได้: ออกแบบเว็บไซต์ แต่ทุกครั้งที่เราพบปัญหาเนื่องจากเขาไม่รู้วิธีเขียนโค้ดโดยทั่วไปการพัฒนาของเราช้าลงเล็กน้อย ในขณะนี้เป็นขั้นตอนการทำงานของเรา: เรามาพร้อมกับคุณสมบัติ เขาสร้างการออกแบบ front-end (ที่ควรจะวางไว้อย่างไรมันจะมีลักษณะ ฯลฯ ) เขาส่งแม่แบบที่สมบูรณ์ให้ฉัน (การส่งออก HTML จาก Pinegrow) ฉันค้นหาการเปลี่ยนแปลงที่เขาทำจากนั้นนำไปใช้ในไซต์จริง (ตั้งแต่สองสามสัปดาห์ฉันใช้ CakePHP) เมื่อบางสิ่งบางอย่างไม่ได้ผลตามที่ตั้งใจ (เช่นเช่นมันไม่ได้ผลตามที่เราวางแผนด้วยเหตุผลบางอย่าง) ฉันจะแก้ไขปัญหาด้านข้างแล้วส่งแม่แบบกลับมาให้เขา ล้างและทำซ้ำ กระบวนการนี้อย่างที่ใคร ๆ ก็จินตนาการได้ว่าช้าและไม่มีประสิทธิภาพอย่างเจ็บปวด ดังนั้นคำถามของฉันคือเราจะทำให้กระบวนการนี้ราบรื่นขึ้นได้อย่างไร ฉันได้เห็นสิ่งต่าง ๆ มากมายเกี่ยวกับการที่เราควรใช้ React และใช้ RESTful และไม่ใช้อะไร แต่เราต้องการใช้ CakePHP สำหรับมัน …

15 design  cakephp 

หากคุณมี enum ที่มีค่าเท่านั้น (ไม่มีวิธีใดที่สามารถทำได้ใน Java) และ enum นี้เป็นส่วนหนึ่งของคำจำกัดความทางธุรกิจของระบบหนึ่งหน่วยการเขียนควรทำการทดสอบหรือไม่? ฉันคิดว่าพวกเขาควรจะเขียนแม้ว่าพวกเขาจะดูเรียบง่ายและซ้ำซ้อนฉันพิจารณาว่าสิ่งที่เกี่ยวข้องกับข้อกำหนดทางธุรกิจควรจะเขียนอย่างชัดเจนในการทดสอบไม่ว่าจะเป็นกับหน่วย / บูรณาการ / UI / ฯลฯ การทดสอบหรือโดยใช้ระบบประเภทของภาษาเป็นวิธีการทดสอบ เนื่องจากค่าที่ enum (เช่นใน Java) ต้องมีจากมุมมองของธุรกิจจึงไม่สามารถทดสอบได้โดยใช้ระบบชนิดที่ฉันคิดว่าควรมีการทดสอบหน่วยสำหรับสิ่งนั้น คำถามนี้ไม่คล้ายกับคำถามนี้เพราะมันไม่ได้แก้ปัญหาเดียวกับของฉัน ในคำถามนั้นมีฟังก์ชั่นธุรกิจ (savePeople) และบุคคลกำลังสอบถามเกี่ยวกับการใช้งานภายใน (forEach) ในนั้นมีชั้นธุรกิจกลาง (ฟังก์ชั่นบันทึกคน) encapsulating การสร้างภาษา (forEach) นี่สร้างภาษา (enum) เป็นสิ่งที่ใช้ในการระบุพฤติกรรมจากมุมมองทางธุรกิจ ในกรณีนี้รายละเอียดการใช้งานจะเกิดขึ้นพร้อมกับ "ธรรมชาติที่แท้จริง" ของข้อมูลนั่นคือ: ชุด (ในแง่คณิตศาสตร์) ของค่า คุณสามารถใช้เซตที่ไม่เปลี่ยนรูปได้ แต่ค่าเดียวกันควรยังคงอยู่ที่นั่น หากคุณใช้อาร์เรย์คุณต้องทำสิ่งเดียวกันเพื่อทดสอบตรรกะทางธุรกิจ ฉันคิดว่าปริศนาที่นี่คือความจริงที่ว่าภาษาสร้างสอดคล้องกับธรรมชาติของข้อมูลได้ดีมาก ฉันไม่แน่ใจว่าฉันอธิบายตัวเองถูกต้องหรือไม่

15 unit-testing  testing  type-systems  enum 

เป็นเรื่องธรรมดามากที่จะระบุเวอร์ชันของ REST API ใน URL โดยเฉพาะที่จุดเริ่มต้นของเส้นทางนั่นคือ: POST /api/v1/accounts GET /api/v1/accounts/details อย่างไรก็ตามฉันไม่เห็นการออกแบบที่เกี่ยวข้องกับแต่ละ API กล่าวอีกนัยหนึ่งเรารักษาเวอร์ชันของแต่ละ API แยกจากกัน เช่น: POST /api/accounts/v2 GET /api/accounts/details/v3 การใช้วิธีการนี้ทำให้เราเพิ่มรุ่น API ของ API ที่เฉพาะเจาะจงเมื่อจำเป็นต้องทำการแตกหักการเปลี่ยนแปลงไม่จำเป็นต้องเพิ่มรุ่น API ทั้งหมด อะไรคือข้อเสียของการใช้สไตล์นี้แทนสไตล์ทั่วไป?

15 rest  api-design  versioning  enterprise-architecture  engineering 

ขณะนี้ฉันกำลังใช้ตัวบันทึกในโครงการของฉันด้วยวิธีต่อไปนี้: private static final Logger LOGGER; static{ LOGGER = logger.getLogger(); } ฉันได้รับรหัสตรวจสอบสำหรับการใช้บล็อกแบบคงที่เพื่อเริ่มต้นตัวแปรตัวบันทึก ฉันบอกให้ intialize ตัวแปร logger ในงบการประกาศตัวเอง private static final Logger LOGGER = Logger.getLogger(); ฉันพยายามคิดว่ามันจะสร้างความแตกต่างอะไรถ้าฉันไม่เริ่มต้นมันในบล็อกแบบคงที่ ฉันต้องการที่จะรู้ว่านี่คือการปฏิบัติ

15 java 

ไวยากรณ์ 3 ของ protobuf ทำให้ฟิลด์ทั้งหมดเป็นตัวเลือกที่ทิ้งคำหลักrequiredและoptionalจากไวยากรณ์ proto2 ก่อนหน้า อ่านความคิดเห็นจากนักพัฒนาดูเหมือนว่ามันทำเพื่อเพิ่มความเข้ากันได้ไบนารีไปข้างหน้า / ถอยหลัง แต่สำหรับฉันนั้นสามารถบังคับใช้ได้โดยเพียงแค่กำหนดชื่อแพคเกจพูดcom.example.messages.v1แล้วปล่อยให้ลูกค้าใช้ deserializers ที่พวกเขาเข้าใจ ในขณะเดียวกันก็ลบสัญญาบางฉบับที่ระบุว่าเป็นประเภทที่มีประโยชน์จากมุมมองด้านวิศวกรรมซอฟต์แวร์ เช่นถ้าฉันมี message Location { double latitude = 1; double longitude = 2; } ใน proto3 เป็นไปได้ที่จะสร้างการสำรองข้อมูลครึ่งหนึ่ง แต่ใช้ได้อย่างสมบูรณ์แบบLocationโดยไม่ได้ให้ข้อมูลหนึ่งในฟิลด์ที่จำเป็น นี่เป็นข้อเสียเปรียบครั้งใหญ่เมื่อสร้างรูปแบบการทำให้เป็นอนุกรมตามสคีมาสำหรับการแลกเปลี่ยนข้อมูลระหว่างลูกค้าหรือไม่ การย้ายรหัสตรวจสอบพิเศษเพิ่มเติมไปยังไคลเอนต์แต่ละรายไม่ได้แย่ไปกว่าการตรวจสอบว่าฟิลด์ที่จำเป็นทั้งหมดมีค่าที่ถูกต้องหรือไม่

15 event-programming  event-sourcing  protobuf 

ตัวดำเนินการเพิ่มของคลาส set ส่งคืนบูลีนซึ่งเป็นจริงหากองค์ประกอบ (ซึ่งจะถูกเพิ่ม) ยังไม่มีอยู่และเป็นเท็จ กำลังเขียน if (set.add(entry)) { //do some more stuff } ถือว่าเป็นสไตล์ที่ดีในแง่ของการเขียนโค้ดที่สะอาด? ฉันสงสัยว่าคุณทำสองสิ่งพร้อมกัน 1) การเพิ่มองค์ประกอบและ 2) การตรวจสอบว่ามีองค์ประกอบอยู่หรือไม่

15 java  coding-style  clean-code 

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

15 programming-practices  maintenance 

ลองนึกภาพระบบที่มีเซิร์ฟเวอร์จำนวนมาก แต่ละรายการมีการตั้งค่าจำนวนมาก: บางอย่างเฉพาะกับเซิร์ฟเวอร์ เฉพาะบางภูมิภาค บางคนพบเห็นได้ทั่วทุกคน บางทีคุณอาจมีการจัดกลุ่มแบบกำหนดเองบางอย่างเช่นกลุ่มเซิร์ฟเวอร์นี้มีไว้สำหรับอ่านเท่านั้น เป็นต้น การปฏิบัติปัจจุบันที่ฉันมีอยู่ในใจเป็นโครงสร้างที่เรียบง่ายพร้อมความสามารถที่เหนือกว่า ให้ใช้เซิร์ฟเวอร์ของ Google เพื่อเป็นตัวอย่าง แต่ละรายการมีรายการการตั้งค่าที่จะโหลด ตัวอย่างเช่นเซิร์ฟเวอร์ลอนดอนอาจมี: rootsettings.properties, europesettings.properties, londonsettings.properties, searchengine.propertiesฯลฯ ที่แต่ละไฟล์มีชุดของคุณสมบัติและลำดับการโหลดช่วยให้คุณสามารถแทนที่คุณสมบัติได้ยิ่งคุณไปได้ไกลเท่าไหร่ ตัวอย่างเช่น: rootsettings.propertiesอาจมีaccessible=falseค่าเริ่มต้น แต่อยู่เหนือsearchengine.propertiesด้วยaccessible=true ปัญหาที่ฉันมีกับโครงสร้างนี้คือมันง่ายมากที่จะออกจากการควบคุม มันไม่ได้มีโครงสร้างเลยหมายความว่าคุณสามารถกำหนดคุณสมบัติใด ๆ ได้ทุกระดับและหลายรายการอาจล้าสมัย นอกจากนี้การเปลี่ยนระดับกลางจะเป็นไปไม่ได้เมื่อเครือข่ายโตขึ้นเนื่องจากตอนนี้คุณส่งผลกระทบต่อเซิร์ฟเวอร์จำนวนมาก ท้ายสุด แต่ไม่ท้ายสุดแต่ละอินสแตนซ์แต่ละรายการอาจต้องการคุณสมบัติพิเศษ 1 รายการซึ่งหมายความว่าแผนผังของคุณจะจบลงด้วยการกำหนดค่าสำหรับเซิร์ฟเวอร์แต่ละเครื่องอย่างไรก็ตามมันจึงไม่ใช่โซลูชันที่ดีที่สุด ฉันจะขอขอบคุณอย่างมากหากคุณมีข้อเสนอแนะ / แนวคิดเกี่ยวกับสถาปัตยกรรมการจัดการการกำหนดค่าที่ดีขึ้น

15 configuration  configuration-management  properties 

บริษัท ของเราจะซื้อซอร์สโค้ดขนาดใหญ่และซับซ้อนมากสำหรับการสื่อสารผ่านดาวเทียม มันถูกเข้ารหัสใน C ++ และเราจะใส่รหัสเพิ่มเติมเข้าไปใน C ++ เชื่อมโยงรหัสของเรากับรหัสที่ซื้อไปยังหน่วยที่ปฏิบัติการได้เพียงหน่วยเดียว จำเป็นหรือไม่ที่เราจะใช้คอมไพเลอร์รุ่นเดียวกันและคอมไพเลอร์รุ่นเดียวกันกับที่ใช้ในการพัฒนารหัสที่ซื้อมา? จำเป็นหรือไม่ที่เราจะต้องใช้ C ++ รุ่นเดียวกันกับรหัสที่ซื้อมา? หากไม่ได้ใช้ 2014 เรา_might_ต้องการใช้คุณลักษณะบางอย่างของมัน แต่ไม่ใช่หากมีปัญหาในการผสมเวอร์ชันที่แตกต่างกัน แน่นอนว่าในทางทฤษฎีมันไม่ควรมีความสำคัญโดยเฉพาะอย่างยิ่งรุ่นภาษา แต่เป็นไปได้ว่าคอมไพเลอร์รุ่นต่าง ๆ จะสร้างรหัสวัตถุที่แตกต่างกันซึ่งอาจนำไปสู่ความแตกต่างของเวลาเป็นต้น เราควรระวังอะไรบ้าง?

15 c++ 

เรากำลังออกแบบ RESTful API ที่มีวัตถุประสงค์เพื่อตอบสนองความต้องการของลูกค้าเป็นหลัก เนื่องจากสถานการณ์ที่เฉพาะเจาะจงลูกค้าจึงต้องทำการร้องขอให้น้อยที่สุดเท่าที่จะทำได้ API จัดการ i18n ผ่านส่วนหัว Accept-Language ในคำขอ สิ่งนี้ใช้ได้กับทุกสิ่งที่ลูกค้าต้องทำยกเว้นคุณลักษณะหนึ่งซึ่งลูกค้าต้องเก็บการตอบสนองของคำขอไปยังจุดปลายเดียวในสถานที่ที่มีอยู่ทั้งหมด เราสามารถออกแบบ API ในลักษณะที่ช่วยให้ลูกค้าสามารถดึงข้อมูลทั้งหมดนี้ได้ด้วยการร้องขอเพียงครั้งเดียวและไม่ทำลายการออกแบบ RESTful API ที่มีโครงสร้างที่สอดคล้องและมีโครงสร้างที่ดี ตัวเลือกที่เราพิจารณาแล้ว: การอนุญาตให้รวมหลายโลแคลในส่วนหัว Accept-Language และเพิ่มเวอร์ชันที่โลคัลไลซ์สำหรับโลแคลที่ร้องขอทั้งหมดในการตอบกลับแต่ละอันระบุด้วยรหัสภาษา ISO 639-1 เป็นคีย์ การสร้างบางสิ่งเช่นพารามิเตอร์ "? all_languages ​​= true" ไปยังปลายทางนั้นและส่งคืนเวอร์ชันที่แปลแล้วสำหรับโลแคลที่มีอยู่ทั้งหมดในการตอบกลับหากมีพารามิเตอร์นั้น (หากไม่มีสิ่งใดที่ได้ผลข้างต้นสำหรับเรา) ทำการร้องขอหลายครั้งเพื่อคว้าเวอร์ชั่นที่แปลเป็นภาษาท้องถิ่นทั้งหมดจากลูกค้า อันไหนเป็นทางเลือกที่ดีที่สุด?

15 rest  api  api-design  http