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

ฉันกำลังอ่านและได้ยินว่าผู้คน (บนเว็บไซต์นี้) ชื่นชมกระบวนทัศน์การเขียนโปรแกรมการทำงานเป็นประจำโดยเน้นว่าการมีทุกสิ่งที่ไม่เปลี่ยนรูปนั้นดีเพียงใด ผู้คนเสนอวิธีการนี้แม้ในภาษา OO ที่จำเป็นแบบดั้งเดิมเช่น C #, Java หรือ C ++ ไม่เพียง แต่ในภาษาที่ใช้งานได้จริงเท่านั้นเช่น Haskell ที่บังคับใช้โปรแกรมนี้ ฉันพบว่ามันยากที่จะเข้าใจเพราะฉันพบว่าความไม่แน่นอนและผลข้างเคียง ... สะดวก อย่างไรก็ตามเมื่อพิจารณาว่าผู้คนในขณะนี้ประณามผลข้างเคียงและพิจารณาว่าเป็นวิธีปฏิบัติที่ดีในการกำจัดพวกเขาทุกที่ที่เป็นไปได้ฉันเชื่อว่าถ้าฉันต้องการเป็นโปรแกรมเมอร์ที่มีความสามารถฉันจะต้องเริ่มต้น ดังนั้นคำถามของฉัน ที่เดียวเมื่อฉันพบปัญหากับกระบวนทัศน์การทำงานคือเมื่อวัตถุถูกอ้างอิงโดยธรรมชาติจากหลาย ๆ ที่ ผมขออธิบายสองตัวอย่าง ตัวอย่างแรกจะเป็นของฉัน# เกม C ฉันพยายามที่จะทำในเวลาว่างของฉัน มันเป็นเกมบนเว็บแบบเปิดที่ผู้เล่นทั้งสองมีทีมจาก 4 มอนสเตอร์และสามารถส่งมอนสเตอร์จากทีมของพวกเขาไปยังสนามรบซึ่งมันจะเผชิญหน้ากับสัตว์ประหลาดที่ถูกส่งโดยผู้เล่นฝ่ายตรงข้าม ผู้เล่นสามารถจำสัตว์ประหลาดจากสนามรบและแทนที่พวกมันด้วยสัตว์ประหลาดอีกตัวจากทีมของพวกเขา (คล้ายกับโปเกมอน) ในการตั้งค่านี้มอนสเตอร์ตัวเดียวสามารถอ้างอิงได้อย่างเป็นธรรมชาติจากสถานที่อย่างน้อย 2 แห่ง: ทีมของผู้เล่นและสนามรบซึ่งอ้างอิงมอนสเตอร์ที่ "คล่องแคล่ว" สองตัว ทีนี้ลองพิจารณาสถานการณ์ตอนที่มอนสเตอร์ตัวใดตัวหนึ่งถูกโจมตีและเสียพลังชีวิต 20 แต้ม ภายในวงเล็บของกระบวนทัศน์ที่จำเป็นฉันปรับเปลี่ยนhealthฟิลด์ของมอนสเตอร์นี้เพื่อสะท้อนการเปลี่ยนแปลงนี้ - และนี่คือสิ่งที่ฉันกำลังทำอยู่ตอนนี้ อย่างไรก็ตามสิ่งนี้ทำให้Monsterคลาสไม่แน่นอนและฟังก์ชั่นที่เกี่ยวข้อง (เมธอด) ไม่บริสุทธิ์ซึ่งฉันคิดว่าเป็นวิธีปฏิบัติที่ไม่ดี ณ …

10 design-patterns  pure-function 

ฉันสืบทอดบางโปรเจ็กต์ที่ความลับอยู่ในการควบคุมซอร์สใน App.config และไฟล์ที่คล้ายกัน โชคดีที่มันไม่ใช่ที่เก็บข้อมูลสาธารณะดังนั้นความเสี่ยงจึงไม่ร้ายแรงเท่าที่ควร ฉันกำลังมองหาวิธีที่ดีกว่าในการจัดการสิ่งนี้เช่น Azure KeyVault (แต่ฉันไม่ได้ตั้งใจจะให้คำถามนี้เฉพาะเจาะจงกับโซลูชันนั้น) โดยทั่วไปเราไม่ได้เป็นเพียงแค่การแก้ปัญหาหรือไม่ ตัวอย่างเช่นด้วย Azure KeyVault รหัสแอปและความลับของแอปกลายเป็นสิ่งที่คุณต้องการหลีกเลี่ยงการควบคุมแหล่งที่มา นี่เป็นตัวอย่างทั่วไปที่น่าเสียดายที่สิ่งนี้มีแนวโน้มที่จะผิดพลาด วิธีการอื่น ๆ นั้นมีความคล้ายคลึงกันโดยใช้คีย์ API หรือไฟล์ที่เก็บคีย์ที่คุณต้องปกป้อง สำหรับฉันแล้วดูเหมือนว่าผลิตภัณฑ์อย่าง Azure KeyVault นั้นไม่ดีกว่าและซับซ้อนกว่าการเก็บความลับของคุณในไฟล์กำหนดค่าแยกต่างหากและทำให้แน่ใจว่ามันอยู่ใน. gitignore หรือเทียบเท่า ไฟล์นี้จะต้องมีการแบ่งปันตามต้องการผ่านช่องทางด้านข้าง แน่นอนว่าผู้คนอาจจะส่งอีเมลถึงกันอย่างไม่ปลอดภัย ... มีวิธีการจัดการความลับที่ไม่เพียง แต่ย้ายปัญหาหรือไม่ ฉันเชื่อว่าคำถามนี้มีคำตอบที่ชัดเจนคำตอบเดียว โดยการเปรียบเทียบถ้าฉันถามว่า HTTPS ไม่เพียงแค่เคลื่อนย้ายปัญหาคำตอบก็คือปุ่ม CA จะกระจายไปกับระบบปฏิบัติการของคุณและเราเชื่อมั่นพวกเขาเพราะเราเชื่อถือวิธีการกระจายของระบบปฏิบัติการ (ไม่ว่าเราควรเป็นคำถามแยกต่างหาก ... )

10 version-control  code-security 

เมื่อเร็ว ๆ นี้ฉันคิดถึงรหัสที่ปลอดภัยมาก Thread ปลอดภัย หน่วยความจำที่ปลอดภัย ไม่ระเบิดในหน้าของคุณด้วย -a- segfault ปลอดภัย แต่เพื่อความชัดเจนในคำถามลองใช้โมเดลความปลอดภัยของรัสเป็นคำจำกัดความต่อเนื่องของเรา บ่อยครั้งที่การทำให้มั่นใจในความปลอดภัยนั้นเป็นปัญหาใหญ่แค่ไหนเพราะได้รับการพิสูจน์โดยความต้องการของ Rust unsafeมีแนวคิดการเขียนโปรแกรมที่สมเหตุสมผลเช่นการเห็นพ้องต้องกันซึ่งไม่สามารถนำมาใช้ใน Rust ได้โดยไม่ต้องใช้unsafeคำสำคัญ . แม้ว่าการทำงานพร้อมกันสามารถทำให้ปลอดภัยได้อย่างสมบูรณ์แบบด้วยการล็อก mutexes ช่องทางและการแยกหน่วยความจำหรือสิ่งที่มีอยู่คุณต้องทำงานนอกรูปแบบความปลอดภัยของ Rust ด้วยunsafeแล้วรับรองตัวแปลด้วยตนเองว่า"ใช่ฉันรู้ว่าฉันกำลังทำอะไร สิ่งนี้ดูไม่ปลอดภัย แต่ฉันได้พิสูจน์แล้วว่าในทางคณิตศาสตร์มันปลอดภัยอย่างสมบูรณ์ " แต่ปกติแล้วจะลงมาด้วยตนเองทำให้รูปแบบของสิ่งเหล่านี้และพวกเขาพิสูจน์ความปลอดภัยอยู่กับprovers ทฤษฎีบท จากทั้งมุมมองวิทยาศาสตร์คอมพิวเตอร์ (เป็นไปได้) และมุมมองการปฏิบัติจริง (มันจะใช้ชีวิตของจักรวาล) มันสมเหตุสมผลที่จะจินตนาการโปรแกรมที่ใช้รหัสโดยพลการในภาษาใด ๆ และประเมินว่ามันเป็นหรือไม่ " ปลอดภัยสนิม "? คำเตือน : สิ่งที่ง่ายในเรื่องนี้ก็คือการชี้ให้เห็นว่าโปรแกรมอาจจะปล่อยปละละเลยดังนั้นปัญหาการหยุดทำงานจึงทำให้เราล้มเหลว สมมติว่าโปรแกรมใดก็ตามที่ส่งไปยังผู้อ่านนั้นรับประกันว่าจะหยุด ในขณะที่ "รหัสโดยพลการในภาษาใด ๆ " เป็นเป้าหมาย แต่ฉันก็ตระหนักว่าสิ่งนี้ขึ้นอยู่กับความคุ้นเคยของโปรแกรมกับภาษาที่เลือกซึ่งเราจะดำเนินการตามที่กำหนด

10 algorithms  testing  computer-science  rust 

โดยทั่วไปเมื่อประกาศคลาส C ++ เป็นแนวปฏิบัติที่ดีที่สุดที่จะใส่เฉพาะการประกาศในไฟล์ส่วนหัวและวางการประยุกต์ใช้ในไฟล์ต้นฉบับ อย่างไรก็ตามดูเหมือนว่ารูปแบบการออกแบบนี้จะไม่ทำงานกับคลาสเทมเพลต เมื่อดูทางออนไลน์มีความคิดเห็น 2 ข้อเกี่ยวกับวิธีที่ดีที่สุดในการจัดการคลาสเทมเพลต: 1. การประกาศทั้งหมดและการใช้งานในส่วนหัว สิ่งนี้ค่อนข้างตรงไปตรงมา แต่นำไปสู่สิ่งที่ฉันคิดว่าเป็นเรื่องยากที่จะรักษาและแก้ไขไฟล์โค้ดเมื่อเทมเพลตมีขนาดใหญ่ 2. เขียนการใช้งานในเทมเพลตรวมไฟล์ (.tpp) ที่รวมอยู่ท้าย ดูเหมือนว่าจะเป็นทางออกที่ดีกว่าสำหรับฉัน แต่ดูเหมือนจะไม่ได้ใช้อย่างกว้างขวาง มีเหตุผลที่วิธีนี้ด้อยกว่าหรือไม่? ฉันรู้ว่าหลายครั้งที่รูปแบบของรหัสถูกกำหนดโดยการตั้งค่าส่วนตัวหรือรูปแบบดั้งเดิม ฉันกำลังเริ่มโครงการใหม่ (การย้ายโครงการ C เก่าไปยัง C ++) และฉันค่อนข้างใหม่ในการออกแบบ OO และต้องการปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุดตั้งแต่เริ่มต้น

10 object-oriented  c++  coding-style  templates 

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

10 functional-programming  paradigms  side-effect  imperative-programming  declarative-programming 

ในการพัฒนาของฉัน (เป็นหลัก C ++) ฉันได้ปฏิบัติตามการใช้งานบิลด์ที่มาจากแหล่งต่าง ๆ มานาน นั่นคือที่มาของฉันมักจะนั่งอยู่ใน/project/srcไดเรกทอรีและสร้างอาศัยอยู่ใน/project/build/bin/release, /project/build/bin/debugไดเรกทอรี ฉันทำสิ่งนี้เพราะมันทำให้ไดเรกทอรีต้นทางของฉันสะอาดจากไฟล์ระดับกลางฉันมีที่เดียวสำหรับไบนารีทั้งหมดของฉันบรรจุภัณฑ์ง่ายกว่าการทำความสะอาดง่ายขึ้นและการควบคุมเวอร์ชันทำได้ง่ายขึ้น (ฉันคิดถึงอะไรเหรอ?) ฉันกำลังสืบทอดโครงการ (ขนาดใหญ่) ในขณะนี้ที่ใช้การสร้างในแหล่งที่มา แรงจูงใจสำหรับโครงสร้างประเภทนี้คืออะไรและมีข้อดีอย่างไร? (ฉันกังวลมากที่สุดกับเหตุผลระดับวิศวกรรมกับเหตุผลส่วนตัวที่ชอบ) ฉันหวังว่า "การออกแบบซอฟต์แวร์ C ++ ขนาดใหญ่ของ Lakos" จะมีน้ำหนักอยู่ในนั้น แต่ฉันก็พลาดถ้ามันทำ

10 builds  directory-structure  large-scale-project  cmake 

ฉันมีจุดสิ้นสุดดังต่อไปนี้: a/{id}/b และต้องการสร้างbพร้อมกับส่งPOSTคำขอไปยังมัน ถ้าaมีให้{id}ไม่ได้พบว่าผมควรจะตอบสนองด้วย404 NOT_FOUNDหรืออาจจะมี409 CONFLICT? มันคือการจัดการธรรมดาa/{id}เคล็ดลับคือที่นี่มีการใช้แหล่งข้อมูลย่อย

10 rest  api  api-design  http-request 

เรามีแอปพลิเคชั่นที่ผสมผสานทั้งความรวดเร็ว (<1 วินาที) และการย้ายฐานข้อมูลที่ช้า (> 30 วินาที) ตอนนี้เรากำลังเรียกใช้การย้ายฐานข้อมูลเป็นส่วนหนึ่งของ CI แต่จากนั้นเครื่องมือ CI ของเราต้องรู้สตริงการเชื่อมต่อฐานข้อมูลทั้งหมดสำหรับแอปของเรา (ในหลาย ๆ สภาพแวดล้อม) ซึ่งไม่เหมาะ เราต้องการเปลี่ยนกระบวนการนี้เพื่อให้แอปพลิเคชันรันการย้ายฐานข้อมูลของตัวเองเมื่อเริ่มต้น นี่คือสถานการณ์: เรามีแอพพลิเคชั่นนี้หลายตัว - ประมาณ 5 ตัวในการผลิต มาเรียกพวกเขาnode1, ..., node5กัน แต่ละแอปเชื่อมต่อกับอินสแตนซ์ของ SQL Server เดียวและเราไม่ได้ใช้การปรับใช้แบบหมุนเวียน (แอพทั้งหมดจะถูกปรับใช้พร้อมกันเท่าที่ฉันรู้) ปัญหา: ว่าเรามีการโยกย้ายที่ใช้เวลานาน ในกรณีนี้node1เริ่มต้นจากนั้นเริ่มดำเนินการโยกย้าย ตอนนี้node4เริ่มและการโยกย้ายที่ใช้เวลานานยังไม่เสร็จดังนั้นจึงnode4เริ่มการโยกย้าย -> ความเสียหายของข้อมูลที่เป็นไปได้หรือไม่ คุณจะป้องกันปัญหานี้อย่างไรหรือเป็นปัญหาที่สำคัญพอที่จะกังวลได้อย่างไร ฉันกำลังคิดที่จะแก้ปัญหานี้ด้วยการล็อคแบบกระจาย AA (ใช้etcdหรืออะไรก็ได้ตามบรรทัดเหล่านั้น) โดยพื้นฐานแล้วแอพทั้งหมดพยายามที่จะได้รับการล็อคโดยมีเพียงหนึ่งในนั้นเท่านั้นที่ได้รับมันและเรียกใช้การย้ายข้อมูลจากนั้นปลดล็อค เมื่อแอปที่เหลือเริ่มต้นและเข้าสู่ส่วนที่สำคัญการโยกย้ายทั้งหมดจะถูกเรียกใช้แล้วสคริปต์การโยกย้ายก็จะออก อย่างไรก็ตามลำไส้ของฉันกำลังพูดว่า "นี่มันเกินจะต้องมีวิธีแก้ปัญหาที่ง่ายกว่า" ดังนั้นฉันจึงคิดว่าฉันจะขอให้ที่นี่เพื่อดูว่าใครมีความคิดที่ดีกว่านี้อีก

10 database  sql  sql-server  distributed-system 

ฉันมีชั้นเรียนที่คำนวณรายได้สุทธิต่อปีของคนงาน มันมีค่าคงที่คิดเป็นร้อยละภาษี แต่วันหนึ่งอัตราภาษีมีการเปลี่ยนแปลงดังนั้นฉันต้องแก้ไขรหัส การกระทำของการแก้ไขค่าคงที่นี้บ่งบอกถึงการละเมิดหลักการ Open-Closedเนื่องจากมันเป็นหลักว่าชั้นควรจะปิดเพื่อแก้ไข?

10 object-oriented  object-oriented-design  solid 

วันนี้ฉันอยากถามคุณเกี่ยวกับความสามารถของ C ++ ในการตระหนักถึงสถาปัตยกรรมซอฟต์แวร์เฉพาะ แน่นอนฉันใช้การค้นหา แต่ไม่พบคำตอบที่เชื่อมโยงโดยตรง โดยพื้นฐานแล้วเป้าหมายของฉันคือการสร้างโปรแกรมที่อนุญาตให้ผู้ใช้สร้างแบบจำลองและจำลองระบบทางกายภาพที่ประกอบขึ้นโดยพลการเช่นรถขับ ฉันคิดว่ามีไลบรารี่ของโมเดลทางกายภาพ (ฟังก์ชั่นภายในคลาส) แต่ละฟังก์ชั่นอาจมีอินพุตบางส่วนและส่งคืนเอาต์พุตบางอย่างขึ้นอยู่กับคำอธิบายทางกายภาพเช่นโมเดลเครื่องยนต์เผาไหม้รุ่นลากอากาศพลศาสตร์แบบจำลองล้อเป็นต้น ตอนนี้ความคิดคือการจัดเตรียมเฟรมเวิร์กให้กับผู้ใช้ซึ่งช่วยให้เขาสามารถเขียนฟังก์ชั่นใด ๆ ตามความต้องการของเขาเช่นเพื่อแมปพฤติกรรมทางกายภาพใด ๆ เฟรมเวิร์กควรจัดเตรียมฟังก์ชันการทำงานเพื่อเชื่อมต่อเอาต์พุตและอินพุตของฟังก์ชันที่แตกต่างกัน ดังนั้นกรอบงานให้คลาสคอนเทนเนอร์ ฉันเรียกมันว่า COMPONENT ซึ่งสามารถเก็บวัตถุโมเดลหนึ่งหรือหลายอันได้ (ฟังก์ชั่น) คอนเทนเนอร์เหล่านี้ยังสามารถเก็บส่วนประกอบอื่น ๆ (รูปแบบคอมโพสิต) รวมถึงการเชื่อมต่อ (CONNECTOR) ระหว่างพารามิเตอร์ฟังก์ชัน นอกจากนี้คลาสคอมโพเนนต์ยังมีฟังก์ชันตัวเลขทั่วไปเช่นตัวแก้ปัญหาคณิตศาสตร์และอื่น ๆ องค์ประกอบของฟังก์ชั่นควรจะทำในช่วงรันไทม์ ในตัวอย่างแรกผู้ใช้ควรจะสามารถตั้งค่าการแต่งเพลงผ่านการนำเข้า XML ซึ่งกำหนดโครงสร้างองค์ประกอบ หลังจากนั้นหนึ่งอาจคิดเพิ่ม GUI เพื่อให้คุณเข้าใจมากขึ้นนี่เป็นตัวอย่างที่ง่ายมาก: <COMPONENT name="Main"> <COMPONENT name="A"> <FUNCTION name="A1" path="lib/functionA1" /> </COMPONENT> <COMPONENT name="B"> <FUNCTION name="B1" path="lib/functionB1" /> …

10 c++  runtime  reflection 

เมื่อเร็ว ๆ นี้ฉันมีปัญหาเกี่ยวกับการใช้คลาสที่เป็นนามธรรม บางครั้งคลาสนามธรรมจะถูกสร้างขึ้นล่วงหน้าและทำงานเป็นแม่แบบของวิธีการเรียนที่ได้รับจะทำงาน ซึ่งหมายความว่ามากหรือน้อยที่พวกเขามีฟังก์ชั่นระดับสูงบางอย่าง แต่ออกรายละเอียดบางอย่างที่จะดำเนินการโดยชั้นเรียนที่ได้รับ ชั้นนามธรรมกำหนดความต้องการรายละเอียดเหล่านี้โดยการวางวิธีการบางอย่างที่เป็นนามธรรม ในกรณีเช่นนี้คลาสนามธรรมจะทำงานเหมือนกับพิมพ์เขียวคำอธิบายระดับสูงของฟังก์ชันหรือสิ่งที่คุณต้องการเรียกใช้ ไม่สามารถใช้ด้วยตนเองได้ แต่ต้องมีความเชี่ยวชาญในการกำหนดรายละเอียดที่ถูกทิ้งไว้จากการใช้งานระดับสูง บางครั้งมันเกิดขึ้นที่คลาสนามธรรมถูกสร้างขึ้นหลังจากการสร้างคลาส "ที่ได้รับ" บางส่วน (เนื่องจากคลาสแม่ / นามธรรมไม่ได้อยู่ที่นั่นพวกเขายังไม่ได้รับมา แต่คุณรู้ว่าฉันหมายถึงอะไร) ในกรณีเหล่านี้คลาสนามธรรมมักจะใช้เป็นสถานที่ที่คุณสามารถใส่รหัสทั่วไปใด ๆ ที่คลาสที่ได้รับปัจจุบันมี หลังจากทำการสังเกตข้างต้นฉันสงสัยว่าในสองกรณีนี้ควรเป็นกฎ รายละเอียดใด ๆ ที่ควรจะถูกทำให้กระฉับกระเฉงขึ้นไปสู่ชั้นนามธรรมเพียงเพราะพวกเขากำลังเกิดขึ้นเป็นเรื่องธรรมดาในทุกชั้นเรียนที่ได้รับ? ควรใช้รหัสทั่วไปที่ไม่ได้เป็นส่วนหนึ่งของฟังก์ชั่นระดับสูงหรือไม่? รหัสที่อาจไม่มีความหมายสำหรับคลาสนามธรรมควรมีเพียงเพราะมันเกิดขึ้นเป็นเรื่องธรรมดาสำหรับคลาสที่ได้รับ? ขอยกตัวอย่าง: คลาสนามธรรม A มีเมธอด a () และเมธอด abstract aq () เมธอด aq () ทั้งคลาสที่ได้รับ AB และ AC ใช้เมธอด b () ควรย้าย b () ไปที่ …

10 object-oriented  clean-code  abstract-class 

คำปฏิเสธ ฉันหวังว่าฉันจะไม่เหยียบนิ้วเท้าของใครก็ตาม พื้นหลัง ฉันค้นหาความแตกต่างที่แท้จริงระหว่าง Service Oriented Architecture และ Microservices โดยไม่ต้องค้นหาคำตอบที่ชัดเจน ฉันอ่านสิ่งที่ชอบ: ผลข้างเคียงของ SOA SOA เป็นรูปแบบการต่อต้าน Microservices มาเพื่อแก้ไขความล้มเหลวของ SOA ESB ไม่ใช่ ESB จริง ๆ แทนที่จะเป็น EAI พึ่งพาโบรกเกอร์ข้อความมากเกินไป ผู้ขายใช้ความคิดในทางที่ผิดของ SOA และพยายามขายผลิตภัณฑ์ของตน SOA เติบโตอย่างไม่สามารถควบคุมได้ แต่ถึงกระนั้นก็ไม่มีอะไรกำหนดความแตกต่างทางสถาปัตยกรรมอย่างชัดเจนระหว่าง Service Oriented Architecture (เป็นแนวคิด) และ Microservices (เป็นแนวคิด) ตามที่ฉันเข้าใจพวกเขาทั้งสองมี: ผู้ให้บริการทำสิ่งเดียวเท่านั้น Service Gateway / ESB เปิดเผยบริการเหล่านั้นต่อผู้บริโภค ผู้บริโภคบริการเข้าถึงบริการผ่าน ESB / เกตเวย์บริการ …

10 microservices  enterprise-architecture  soa 

ฉันรู้ว่าเราควรมีสภาพแวดล้อมที่แตกต่างกันอย่างน้อย 3 สภาพในขณะที่กำลังพัฒนาวิธีแก้ปัญหา: การพัฒนา : โปรแกรมเมอร์มีอิสระที่จะเปลี่ยนแปลงและผลักดันการเปลี่ยนแปลงได้ตลอดเวลาเพื่อทดสอบโค้ดของพวกเขาและรวมเข้ากับการเปลี่ยนแปลงอื่น ๆ ได้อย่างรวดเร็วโดยไม่ต้องกลัวว่าจะทำสิ่งใด - มันเชื่อมต่อกับฐานข้อมูลและบริการทดสอบ เอือด : ควรได้รับการปฏิบัติด้วยความเคารพจากนักพัฒนาเพราะมันควรจะมีสำเนา "ดีที่สุดเท่าที่จะเป็นไปได้" ของสภาพแวดล้อมการผลิตที่เกี่ยวข้องกับฮาร์ดแวร์ด้วยความแตกต่างที่ว่าสภาพแวดล้อมนี้เชื่อมต่อกับฐานข้อมูลของ UAT มันใช้ทั้งคำถามและคำตอบของทีมและผู้ใช้ในการตรวจสอบการเปลี่ยนแปลงที่จะไปสู่การผลิต การผลิต : เรื่องจริง ฉันได้ดูคำถามนี้เกี่ยวกับ SoftwareEngineeringและคำถามนี้ใน ServerFaultและพวกเขาดูเหมือนจะแตกต่างกันในความหมายของ Staging Environment นอกจากนี้หน้า Wikipediaเกี่ยวกับหัวเรื่องระบุว่า: การใช้งานหลักของสภาวะแวดล้อม staging คือการทดสอบสคริปต์และโพรซีเดอร์การติดตั้ง / คอนฟิกูเรชัน / การโอนย้ายทั้งหมดก่อนที่จะนำไปใช้กับสภาวะแวดล้อมการใช้งานจริง สิ่งนี้ทำให้มั่นใจได้ว่าการอัปเกรดหลักและรองทั้งหมดไปยังสภาพแวดล้อมการผลิตจะสมบูรณ์ได้อย่างน่าเชื่อถือโดยไม่มีข้อผิดพลาดในเวลาขั้นต่ำ สำหรับฉัน Staging เท่ากับ UAT ซึ่งคุณต้องทดสอบแอปพลิเคชันและขั้นตอนการปรับใช้ก่อนที่จะผลักดันสู่โลกแห่งความจริง ดังนั้นเราจึงผลักดันแพ็คเกจด้วยการเปลี่ยนแปลง UAT ในลักษณะเดียวกับที่เราผลักดันไปสู่การผลิตอัตโนมัติโดยสมบูรณ์และด้วยพิธีทั้งหมดที่เราควรมีกับสภาพแวดล้อมการผลิต ที่ถูกกล่าวว่าสิ่งที่แตกต่างที่เหมาะสมระหว่างสภาพแวดล้อม UAT และสภาพแวดล้อม Staging คืออะไร? - แก้ไข: …

10 web-applications  continuous-delivery  environment 

ฉันเป็นนักพัฒนา C ++ และในความพยายามที่จะเข้าใจการพัฒนาข้ามแพลตฟอร์มได้ดียิ่งขึ้นฉันพยายามทำความเข้าใจกับรายละเอียดการใช้งานคอมไพเลอร์ให้ดีขึ้นและพวกเขาสร้างไบนารีเฉพาะระบบปฏิบัติการได้อย่างไร ในระหว่างการศึกษาของฉันฉันรู้ว่าอย่างน้อยก็ชั่วขณะคอมไพเลอร์ส่วนใหญ่ที่คุณดาวน์โหลดสำหรับแพลตฟอร์มเฉพาะรวบรวมไบนารีสำหรับแพลตฟอร์มนั้นเท่านั้น ดังนั้นถ้าคุณดาวน์โหลด IDE ที่มาพร้อมกับคอมไพเลอร์ exe สำหรับ Windows คอมไพเลอร์นั้นจะสามารถรวบรวมโปรแกรมของคุณสำหรับแอปพลิเคชัน windows x86-x64 และไม่ใช่แอปพลิเคชัน Linux หรือ Mac ตอนนี้ฉันเข้าใจแล้วว่าแพลตฟอร์มต่าง ๆ ต้องการรูปแบบไบนารีที่แตกต่างกัน แต่สิ่งที่ทำให้พูดคอมไพเลอร์ Visual C ++ บน windows เพื่อสร้างไฟล์ปฏิบัติการไบนารีของ linux ทำได้ยาก? ตราบใดที่คุณมีคำแนะนำการประกอบสำหรับ CPU ที่คุณใช้งานอยู่รวมถึงไลบรารีเฉพาะของ OS คุณไม่ควรรวบรวม exectuables สำหรับแพลตฟอร์มใด ๆ บนเครื่องใด ๆ

10 compiler  cross-platform  cpu  low-level 

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

10 design-patterns  object-oriented-design