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

เมื่อเร็ว ๆ นี้ฉันได้พบว่าวัตถุที่เปลี่ยนไม่ได้มีประโยชน์อย่างไรและเช่นถ้าคุณส่งองค์ประกอบไปยังตัวสร้างและคลาสของคุณควรจะไม่เปลี่ยนรูปคุณต้องคัดลอกองค์ประกอบเหล่านี้หากพวกเขาไม่เปลี่ยนรูปตัวเอง สิ่งนี้ต้องการการตรวจสอบหรือความรู้มากมายเกี่ยวกับโครงการของฉันเพราะถ้าฉันมี public A(B foo) และBไม่ได้เปลี่ยนรูปฉันต้องคัดลอกA Bตอนนี้จินตนาการBดูเหมือนไม่เปลี่ยนรูป แต่ตัวเองมีคลาสที่ไม่แน่นอนในตัวสร้างและอื่น ๆ มีมาตรฐานหรือแนวปฏิบัติที่ดีที่สุดสำหรับการจัดทำเอกสารหรือไม่หากคลาสไม่เปลี่ยนรูปแบบใน Java? ดูเหมือนว่าไม่มี@immutableคำหลักใน Javadoc คำอธิบายประกอบ @Immutableดูเหมือนว่าจะมีบางสิ่งบางอย่างที่แตกต่างกันโดยสิ้นเชิงในการผลิตระดับอัตโนมัติและไม่ได้เป็นส่วนหนึ่งของมาตรฐาน Java

14 java  documentation  immutability 

var toSizeString = (function() { var KB = 1024.0, MB = 1024 * KB, GB = 1024 * MB; return function(size) { var gbSize = size / GB, gbMod = size % GB, mbSize = gbMod / MB, mbMod = gbMod % MB, kbSize = mbMod / KB; if (Math.floor(gbSize)) …

14 javascript  performance 

จากหัวข้อ 5.1.4 การเข้าถึงหน่วยความจำโดยตรงในระบบปฏิบัติการสมัยใหม่โดย Andrew S. Tanenbaum, Herbert Bos, 2014 , เพื่อให้คำอธิบายง่ายขึ้นเราสันนิษฐานว่า CPU เข้าถึงอุปกรณ์และหน่วยความจำทั้งหมดผ่านบัสระบบเดียวที่เชื่อมต่อ CPU หน่วยความจำและอุปกรณ์ I / O ดังแสดงในรูปที่ 5-4 เพื่ออธิบายวิธีการทำงานของ DMA ให้เราพิจารณาก่อนว่าการอ่านดิสก์เกิดขึ้นอย่างไรเมื่อไม่ได้ใช้ DMA ก่อนอื่นตัวควบคุมดิสก์จะอ่านบล็อก (หนึ่งส่วนขึ้นไป) จากไดรฟ์แบบอนุกรมทีละบิตจนกระทั่งบล็อกทั้งหมดอยู่ในบัฟเฟอร์ภายในของคอนโทรลเลอร์ จากนั้นคำนวณการตรวจสอบเพื่อตรวจสอบว่าไม่มีข้อผิดพลาดในการอ่านเกิดขึ้น จากนั้นคอนโทรลเลอร์จะทำให้เกิดการขัดจังหวะ เมื่อระบบปฏิบัติการเริ่มทำงานมันสามารถอ่านบล็อกดิสก์จากบัฟเฟอร์ของคอนโทรลเลอร์เป็นไบต์หรือคำในแต่ละครั้งโดยเรียกใช้ลูปโดยการวนซ้ำแต่ละครั้งจะอ่านหนึ่งไบต์หรือหนึ่งคำจากอุปกรณ์ควบคุมรีจิสเตอร์และเก็บไว้ในหน่วยความจำหลัก ถาม: ในขั้นตอนที่สอง ไม่ถ่ายโอนข้อมูล " จากบัฟเฟอร์ของคอนโทรลเลอร์ " ไปยังหน่วยความจำหลัก? ทำไมถึงพูดว่า " จากบัฟเฟอร์ของคอนโทรลเลอร์ " และ " จากอุปกรณ์ควบคุมรีจิสเตอร์ "? ในขั้นตอนที่สองคอนโทรลเลอร์สามารถถ่ายโอนข้อมูลจากบัฟเฟอร์ไปยังหน่วยความจำหลักโดยไม่รบกวนการทำงานของ cpu และไม่เกี่ยวข้องกับระบบปฏิบัติการอีกครั้ง? เมื่อใช้ DMA …

14 operating-systems  io 

ฉันมีฟังก์ชั่นตรวจสอบค่าบางอย่างคล้ายกับฟังก์ชั่นตรวจสอบหมายเลขบัตรเครดิตที่ส่งผ่านมาในสตริงและต้องตรวจสอบว่าค่าเป็นรูปแบบที่ถูกต้อง หากเป็นรูปแบบที่ถูกต้องจะต้องส่งคืนจริง หากไม่ใช่รูปแบบที่ถูกต้องจะต้องส่งคืนค่าเท็จและแจ้งให้เราทราบว่ามีอะไรผิดปกติกับมูลค่า คำถามคือวิธีที่ดีที่สุดในการบรรลุเป้าหมายนี้คืออะไร นี่คือวิธีแก้ปัญหาบางประการ: 1. ใช้รหัสส่งคืนจำนวนเต็ม / enum เพื่อแสดงความหมาย: String[] returnCodeLookup = [ "Value contains wrong number of characters, should contain 10 characters", "Value should end with 1", "Value should be a multiple of 3" ] private int valueChecker(String value) { /*check value*/ return returnCode; } rc = checkValue(valueToBeChecked); …

14 java  error-handling 

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

14 database  security  email 

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

14 agile  code-reviews  pair-programming  extreme-programming 

ฉันเพิ่งทำงานในสถานการณ์ต่อไปนี้ class A{ public: void calculate(T inputs); } ประการแรกAแสดงถึงวัตถุในโลกทางกายภาพซึ่งเป็นข้อโต้แย้งที่แข็งแกร่งที่ไม่แยกชั้นเรียนขึ้น ตอนนี้calculate()กลายเป็นฟังก์ชั่นที่ค่อนข้างยาวและซับซ้อน ฉันเข้าใจโครงสร้างที่เป็นไปได้สามประการ: เขียนเป็นกำแพงข้อความ - ข้อดี - ข้อมูลทั้งหมดอยู่ในที่เดียว เขียนprivateฟังก์ชั่นยูทิลิตี้ในชั้นเรียนและใช้พวกเขาในcalculateร่างกาย - ข้อเสีย - ส่วนที่เหลือของชั้นไม่ทราบ / ดูแล / เข้าใจเกี่ยวกับวิธีการเหล่านั้น เขียนcalculateวิธีดังต่อไปนี้: void A::calculate(T inputs){ auto lambda1 = () [] {}; auto lambda2 = () [] {}; auto lambda3 = () [] {}; lambda1(inputs.first_logical_chunk); lambda2(inputs.second_logical_chunk); lambda3(inputs.third_logical_chunk); …

14 c++11  lambda 

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

14 programming-languages  backward-compatibility 

คำถาม: ฉันทามติของอุตสาหกรรมซอฟต์แวร์คือรหัสที่สะอาดและเรียบง่ายเป็นพื้นฐานของความมีชีวิตในระยะยาวของฐานรหัสและองค์กรที่เป็นเจ้าของ คุณสมบัติเหล่านี้นำไปสู่การลดค่าใช้จ่ายในการบำรุงรักษาและเพิ่มโอกาสในการสร้างรหัสฐานอย่างต่อเนื่อง อย่างไรก็ตามรหัส SIMD นั้นแตกต่างจากรหัสแอปพลิเคชันทั่วไปและฉันต้องการทราบว่ามีฉันทามติที่คล้ายกันเกี่ยวกับรหัสที่สะอาดและใช้งานง่ายที่ใช้เฉพาะกับรหัส SIMD พื้นหลังคำถามของฉัน ฉันเขียนโค้ด SIMD (คำสั่งคำสั่งเดียวหลายข้อมูล) มากมายสำหรับการประมวลผลภาพและการวิเคราะห์ที่หลากหลาย เมื่อเร็ว ๆ นี้ฉันยังต้องพอร์ตฟังก์ชั่นเหล่านี้จำนวนเล็กน้อยจากสถาปัตยกรรมหนึ่ง (SSE2) ไปยังอีก (ARM NEON) รหัสนี้เขียนขึ้นสำหรับซอฟต์แวร์ที่มีการย่อขนาดดังนั้นจึงไม่สามารถขึ้นอยู่กับภาษาที่เป็นกรรมสิทธิ์หากไม่มีสิทธิ์การแจกจ่ายซ้ำเช่น MATLAB ตัวอย่างของโครงสร้างรหัสทั่วไป: ใช้ประเภทเมทริกซ์ของOpenCV ( Mat)สำหรับการจัดการหน่วยความจำบัฟเฟอร์และอายุการใช้งานทั้งหมด หลังจากตรวจสอบขนาด (ขนาด) ของอาร์กิวเมนต์อินพุตพอยน์เตอร์ไปยังที่อยู่เริ่มต้นของแต่ละแถวของพิกเซลจะถูกนำมาใช้ จำนวนพิกเซลและที่อยู่เริ่มต้นของพิกเซลแต่ละแถวจากเมทริกซ์อินพุตแต่ละอันจะถูกส่งผ่านไปยังฟังก์ชัน C ++ ระดับต่ำ ฟังก์ชัน C ++ ระดับต่ำเหล่านี้ใช้ SIMD ภายใน (สำหรับสถาปัตยกรรม IntelและARM NEON ) โหลดจากและบันทึกไปยังที่อยู่ตัวชี้แบบดิบ ลักษณะของฟังก์ชั่น C ++ ระดับต่ำเหล่านี้: สิทธิพิเศษหนึ่งมิติ (ต่อเนื่องกันในหน่วยความจำ) ไม่จัดการกับการจัดสรรหน่วยความจำ …

14 performance  optimization  estimation 

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

14 object-oriented  programming-languages 

ฉันมีคลาสต่อไปนี้ class Student{ int rollNumber; int marks; public void setResult(int rollNumber, int marks){ this.rollNumber=rollNumber; this.marks=marks; } public void displayResult(){ System.out.println("Roll Number= "+this.rollNumber+" Marks= "+this.marks); } } ตอนนี้ฉันสร้างวัตถุสองประเภทที่เป็นนักเรียนดังนี้ Student s1=new Student(); Student s2=new Student(); ตอนนี้มีการจัดสรรหน่วยความจำสองชุดที่แตกต่างกันสำหรับฟิลด์อินสแตนซ์ ตอนนี้คำถามของฉันคือการจัดสรรหน่วยความจำสำหรับวิธีการ ( setResultและdisplayResult) สองครั้งหรือหนึ่งครั้ง? โปรดดูรูปต่อไปนี้และคุณสามารถช่วยฉันบอกว่ารูปใดให้ข้อมูลที่ถูกต้อง

14 java  object-oriented  memory  jvm 

ฉันเข้าใจวิธีการทำงานกับอินเตอร์เฟสและการใช้อินเตอร์เฟสอย่างชัดเจนใน C # แต่ฉันสงสัยว่ามันถือว่าเป็นรูปแบบที่ไม่ดีเพื่อซ่อนสมาชิกบางคนที่ไม่ได้ใช้บ่อย ตัวอย่างเช่น: public interface IMyInterface { int SomeValue { get; set; } int AnotherValue { get; set; } bool SomeFlag { get; set; } event EventHandler SomeValueChanged; event EventHandler AnotherValueChanged; event EventHandler SomeFlagChanged; } ฉันรู้ล่วงหน้าว่ากิจกรรมในขณะที่มีประโยชน์จะไม่ค่อยได้ใช้ ดังนั้นฉันคิดว่ามันจะสมเหตุสมผลที่จะซ่อนพวกเขาออกจากชั้นเรียนการใช้งานผ่านการใช้งานอย่างชัดเจนเพื่อหลีกเลี่ยงความไม่เป็นระเบียบของ IntelliSense

14 c#  interfaces  implementations 

ฉันได้อ่านเกี่ยวกับ Model View Controller, Model View Presenter, Model View ViewModel เป็นต้นโดยทั่วไปแนวคิดพื้นฐานดูเหมือนจะเข้าใจง่าย: เก็บภาพที่สวยงามและความกล้าหาญทางวิทยาศาสตร์แยกจากกันและงมงายเป็น เป็นไปได้ ไม่ได้รับเนยถั่วลิสงในการออกแบบช็อคโกแลต; ฉันชอบมัน ปัญหาคือฉันยังคงคลุมเครือเล็กน้อยในส่วนที่สามนั่นคือ ... ไม่ใช่โมเดลหรือมุมมอง ทุกคนดูเหมือนจะมีความคิดของตัวเองว่าจะเรียกมันว่าอะไรควรทำอะไรเหมาะสมอะไรผิดปกติธรรมดา ... และฉันจะพยายามคิดออกเมื่อผู้นำเสนอกลายเป็น ViewModel และเมื่อมุมมองไม่ควร ' อย่าทำอย่างนั้นเพราะนั่นคืองานของผู้นำเสนอและ - ฉันเที่ยว แทนที่จะขอให้ใครบางคนอธิบายความแตกต่างระหว่างพวกเขา - เพราะมันทำมาแล้วครั้งแล้วครั้งเล่า (ฉันรู้ว่าฉันอ่านบทความมากกว่าที่ฉันสามารถนับได้) - ฉันอยากรู้อยากเห็นความคิดของ โปรแกรมเมอร์เพียงไม่กี่คนในแบบจำลองที่ฉันได้เดินด้วยกัน ที่กล่าวว่าสิ่งที่คุณจะจัดประเภทการออกแบบนี้และที่สำคัญกว่าคุณเห็นอะไรเกี่ยวกับเรื่องนี้ที่ชัดดูด? แน่นอนว่าฉันชอบที่จะได้ยินว่าฉันทำได้ดีถ้านี่คือการออกแบบที่มั่นคงอย่างแท้จริง แต่ฉันอยากได้รับคำแนะนำที่หนักแน่นมากกว่าการชม หมายเหตุ: ฉันจะใช้ "the Bridge" สำหรับส่วนที่สามอันลึกลับของ Model-View-? เพื่อหลีกเลี่ยงคำแนะนำจิตใต้สำนึกของสิ่งที่ "ควร" เป็น แบบ เป็นสิทธิของข้อมูล รับข้อมูลเกี่ยวกับการเปลี่ยนแปลงที่ร้องขอจาก Bridge …

14 design-patterns  mvc  mvvm  mvp 

ฉันกำลังสร้างแอปพลิเคชันใหม่และกำลังอ่านเกี่ยวกับสถาปัตยกรรมบริการไมโคร สถาปัตยกรรมเองนั้นมีความหมายอย่างมากจากมุมมองของการพัฒนาการปรับใช้และการจัดการวงจรชีวิต อย่างไรก็ตามปัญหาหนึ่งที่เกิดขึ้นคือเกี่ยวกับวิธีจัดการข้อมูลหลัก ตัวอย่างเช่นฉันมี 2 แอพ - พูดแอปขายและแอปจองตั๋ว สมมติว่าแอพทั้งสองนี้สร้างขึ้นเป็นบริการไมโครของตัวเอง อย่างไรก็ตามแอพทั้งสองนี้เมื่อมีการใช้งาน (สมมติว่ามีการใช้งานแยกกันว่า Sales ใช้ MongoDB และ Ticketing ใช้ MariaDB) จะต้องมีการเข้าถึงอินสแตนซ์ข้อมูลหลักเดียวกันเช่นบัญชีผลิตภัณฑ์ ซึ่งหมายความว่าจะมีแอปสำหรับเจ้าของข้อมูลเอนทิตีหลักที่กำหนด (เช่นบัญชีที่อาจเป็นแอปขาย) และผู้มีส่วนได้เสีย (เช่นแอปออกบัตรจะต้องมีข้อมูลเกี่ยวกับบัญชี) มีหลายวิธีที่สามารถทำได้: - การจำลองข้อมูลจากต้นแบบไปยังผู้มีส่วนร่วม - อ่านแบบซิงโครนัสจากฝ่ายที่สนใจไปที่ต้นแบบ (การพึ่งพาการซิงค์ไม่แนะนำโดยกระบวนทัศน์สถาปัตยกรรมไมโครบริการ) - พื้นที่เก็บข้อมูลส่วนกลาง แม้แต่ในบัญชีก็สามารถมีส่วนหลักซึ่งเป็นเรื่องปกติสำหรับทั้งการขายและการออกตั๋ว (เช่นชื่อบัญชีที่อยู่ ฯลฯ ) อย่างไรก็ตามบางแง่มุมของบัญชีอาจเกี่ยวข้องกับการขายเท่านั้นและอื่น ๆ ที่เกี่ยวข้องกับการออกตั๋วเท่านั้น ความคิด / แนวปฏิบัติที่ดีที่สุด / ความคิดเห็นเกี่ยวกับตัวเลือกใด ๆ ที่กล่าวถึงข้างต้น?

14 soa  services 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน2 ปีที่ผ่านมา บ่อยครั้งที่ OOP ถูกมองว่าเป็นกลยุทธ์ที่มีประสิทธิภาพในการจัดการความซับซ้อนในซอฟต์แวร์ มีการศึกษาใดที่ทดสอบความคิดนี้หรือไม่? มันพิสูจน์แล้วว่า OOP มักจะช่วยจัดการความซับซ้อนในโครงการขนาดใหญ่?

14 object-oriented  case-studies