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

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

12 design-patterns  architecture  facebook  reactjs 

ฉันเพิ่งสังเกตเห็นว่าการเพิ่ม [TestInitialize] ไปยังวิธีการที่ได้รับการป้องกันในชุดประกอบ. NET ไม่ได้รับความเคารพ แต่ถ้าฉันทำวิธีการแบบสาธารณะ ฉันสังเกตเห็นหลายครั้งในอดีตด้วยวิธีการทดสอบ เทคนิคการพูดมันเป็นเรื่องง่ายที่จะสะท้อนให้เห็นถึงวิธีการส่วนตัวเป็นวิธีสาธารณะ ตามความเป็นจริงแล้วการไตร่ตรองเป็นวิธีที่ใช้ในการทดสอบหน่วยวิธีส่วนตัว เหตุใดฉันจึงต้องทำให้วิธีการทดสอบหน่วยของฉันเป็นแบบสาธารณะทั้งหมด

12 .net  unit-testing 

หนึ่งจะเริ่มออกแบบคลาสนามธรรมในแอปพลิเคชันขนาดใหญ่ของพวกเขาที่สามารถเชื่อมต่อกับฐานข้อมูลหลายประเภทเช่น MySQL, SQLLite, MSSQL ฯลฯ ได้อย่างไร รูปแบบการออกแบบนี้เรียกว่าอะไรและเริ่มต้นตรงไหน สมมติว่าคุณต้องเขียนคลาสที่มีวิธีการดังต่อไปนี้ public class Database { public DatabaseType databaseType; public Database (DatabaseType databaseType){ this.databaseType = databaseType; } public void SaveToDatabase(){ // Save some data to the db } public void ReadFromDatabase(){ // Read some data from db } } //Application public class Foo { …

12 c#  database 

ฉันจะใช้ไลบรารีข้ามแพลตฟอร์มของฉัน (เช่นบน JRE) เพื่อดำเนินการในลักษณะที่ปลอดภัยต่อเธรดในการอ้างอิงวัตถุเพื่อให้ front-end ดั้งเดิมบนแพลตฟอร์มอื่นสามารถสังเกตวัตถุและใช้ประโยชน์จากรูปแบบที่สังเกตได้ พื้นหลังเล็กน้อย - มีแนวคิดเกี่ยวกับการเชื่อมโยงข้อมูลที่ใช้ในกรอบงานส่วนหน้า ใน C # และ Java สิ่งนี้เกี่ยวข้องกับลักษณะที่สังเกตได้ซึ่งให้คลาสความสามารถในการเริ่มเหตุการณ์เมื่อมีการเปลี่ยนแปลงเกิดขึ้นซึ่งตัวควบคุมหลายตัวหรือ "ผู้สังเกตการณ์" อาจสมัครสมาชิก วิธีนี้ผู้สังเกตการณ์ไม่จำเป็นต้องทำการสำรวจ / อ่านทรัพยากรเปรียบเทียบกับการปรับปรุง ฉันต้องการทำงานกับเครื่องมือวิเคราะห์ที่เปลี่ยนแปลงรายการข้อมูลเมื่อเวลาผ่านไป มันจะเป็นการดีที่จะสามารถให้ front-end สามารถสังเกตรายการเหล่านี้ได้ในขณะที่การวิเคราะห์กำลังทำงานอยู่ สำหรับฉันดูเหมือนว่าสิ่งนี้จะต้องใช้ส่วนหน้าเพื่อให้สามารถส่งวัตถุไปยังเครื่องมือวิเคราะห์ที่เขียนในห้องสมุดที่หวังว่าจะเป็นแบบข้ามแพลตฟอร์มและสามารถทำให้เธรดปลอดภัยอ่านวัตถุนั้นได้ มิฉะนั้นให้ห้องสมุดปฏิบัติตามสัญญาที่สังเกตได้ วิธีนี้ถูกจัดการในเอ็นจิน CLI สไตล์เก่าของ Unix คือการใช้ stdin / stdout / stderr และมีการอัพเดท post engine เป็นระยะ สิ่งนี้ต้องมีค่าใช้จ่ายมาตรฐานและการแยกวิเคราะห์ข้อความที่ฉันค่อนข้างจะหลีกเลี่ยงถ้าเป็นไปได้

12 multithreading  libraries  cross-platform  ui 

ฉันได้ทำการบำรุงรักษาแอพ Android แล้วและมีปัญหาบางอย่างที่ฉันได้รับการแก้ไขไม่มากก็น้อย แต่ก็ยังมีปัญหาอยู่เนื่องจาก Android OS เวอร์ชันต่าง ๆ ตัวอย่างเช่นการส่งคำขอเว็บด้วยคลาส MediaPlayer มีส่วนหัว HTTP ที่กำหนดเองที่ถูกตัดออกโดยระบบปฏิบัติการก่อนที่จะส่งคำขอ แต่เฉพาะใน Android 4.X (ฉันทดสอบอย่างละเอียด) และนั่นทำให้คุณสมบัตินี้ล้มเหลวเพราะต้องอาศัย บนส่วนหัวเหล่านั้น นี่เป็นปัญหาที่ทราบกันแล้วและฉันพยายามที่จะหลีกเลี่ยงมัน แต่มันจะเป็นการดีหรือไม่ที่จะมีการตรวจสอบตามเงื่อนไข if (OS.VERSION == 4) { knownIssueDialog(This feature will not work on your Android version... etc."); } เห็นได้ชัดว่าเราจะมีสิ่งนี้บันทึกไว้ในช่องทางการสนับสนุนของเรา แต่ฉันสงสัยว่ามันจะเป็นความคิดที่ดี (สมมติว่าทุกอย่างติดตาม) เพื่อให้ทราบปัญหาเหล่านี้ยังฝังอยู่ในซอฟต์แวร์และนำเสนอเมื่อใดก็ตามที่จำเป็น เช่นสิ่งที่ฉันอธิบายไว้ข้างต้น เราได้รับการวิจารณ์ที่ไม่ดีหลายครั้งและอีเมลสนับสนุนมากมายจากปัญหาเหล่านี้ดังนั้นในใจของฉันมันจะช่วยให้ทุกคนประหยัดเวลาและปวดหัวได้เพียงแค่ปิดกั้นคุณสมบัติที่ทราบว่าไม่ทำงานอย่างถูกต้อง ฉันเห็นปัญหาที่อาจเกิดขึ้นสองประการ: ผู้ใช้อาจไม่เคยเห็นอะไรแบบโต้ตอบ "ปัญหาที่ทราบ" มาก่อน; ผู้ใช้จำนวนมากอาจไม่เข้าใจความหมาย มีค่าใช้จ่ายในการพัฒนาอยู่เล็กน้อย - …

12 programming-practices  issue-tracking  user-experience 

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

12 object-oriented  memory  language-features  smalltalk 

เรากำลังทดสอบห้องสมุดภายใต้ C ++ 11 (เช่น-std=c++11) ห้องสมุดใช้auto_ptrและรูปแบบนี้: Foo* GetFoo() { autoptr<Foo> ptr(new Foo); // Initialize Foo ptr->Initialize(...); // Now configure remaining attributes ptr->SomeSetting(...); return ptr.release(); } เลิกใช้ C ++ 11 auto_ptrดังนั้นเราต้องการย้ายออกไป อย่างไรก็ตามรหัสสนับสนุนทั้ง C ++ 03 และ C ++ 11 จึงไม่ง่ายที่เป็น auto_ptryanking นอกจากนี้ยังมีมูลค่าการกล่าวถึงห้องสมุดที่ไม่มีการอ้างอิงภายนอก มันใช้ C ++ 03; และไม่ใช้ Autotools, Cmake, Boost, ... …

12 design  c++  c++11 

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

12 language-agnostic  history  side-effect  pure-function 

อินเทอร์เฟซที่ว่างเปล่าโดยทั่วไปจะพิจารณาการปฏิบัติที่ไม่ดีเท่าที่ฉันสามารถบอกได้ - โดยเฉพาะอย่างยิ่งเมื่อสิ่งต่าง ๆ เช่นแอตทริบิวต์ได้รับการสนับสนุนโดยภาษา อย่างไรก็ตามอินเทอร์เฟซถูกพิจารณาว่า 'ว่าง' ถ้ามันได้รับมาจากอินเทอร์เฟซอื่นหรือไม่ interface I1 { ... } interface I2 { ... } //unrelated to I1 interface I3 : I1, I2 { // empty body } สิ่งใดที่ใช้I3จะต้องนำไปปฏิบัติI1และI2และวัตถุจากคลาสที่แตกต่างกันซึ่งสืบทอดI3สามารถนำมาใช้แทนกันได้ (ดูด้านล่าง) ดังนั้นมันถูกต้องหรือI3 เปล่าที่จะเรียกว่าว่างเปล่า ? ถ้าเป็นเช่นนั้นจะมีวิธีใดที่ดีกว่าในการสร้างสถาปัตยกรรมนี้ // with I3 interface class A : I3 { ... } class B …

12 interfaces  inheritance 

มองผ่าน Java (optional operation)คอลเลกชันกรอบฉันพบค่อนข้างน้อยของอินเตอร์เฟซที่มีการแสดงความคิดเห็น วิธีการเหล่านี้อนุญาตให้นำคลาสไปใช้ผ่านUnsupportedOperationExceptionหากพวกเขาไม่ต้องการใช้วิธีนั้น ตัวอย่างนี้เป็นวิธีการในaddAllSet Interface ตอนนี้ตามที่ระบุไว้ในชุดคำถามนี้อินเทอร์เฟซเป็นสัญญาที่กำหนดสำหรับสิ่งที่ผู้ใช้สามารถคาดหวังได้ อินเทอร์เฟซมีความสำคัญเนื่องจากแยกสิ่งที่คลาสทำจากวิธีการใช้งาน สัญญาที่กำหนดสิ่งที่ลูกค้าสามารถคาดหวังปล่อยให้นักพัฒนาสามารถนำไปใช้ได้ทุกวิธีที่พวกเขาเลือกตราบใดที่พวกเขารักษาสัญญา และ อินเทอร์เฟซคือคำอธิบายของการกระทำที่วัตถุสามารถทำได้ ... ตัวอย่างเช่นเมื่อคุณพลิกสวิตช์ไฟแสงจะสว่างขึ้นคุณไม่สนใจว่ามันจะทำอย่างไร ในการเขียนโปรแกรมเชิงวัตถุอินเทอร์เฟซคือคำอธิบายของฟังก์ชันทั้งหมดที่วัตถุต้องมีเพื่อให้เป็น "X" และ ฉันคิดว่าวิธีการทำงานบนอินเตอร์เฟสนั้นดีกว่าอย่างมาก จากนั้นคุณสามารถเยาะเย้ยการพึ่งพาของคุณได้อย่างดีและทุกอย่างก็น้อยกว่ากันอย่างแน่นหนา จุดประสงค์ของอินเทอร์เฟซคืออะไร อินเตอร์เฟสคืออะไร อินเตอร์เฟส + ส่วนขยาย (มิกซ์อิน) เทียบกับคลาสพื้นฐาน ระบุว่าวัตถุประสงค์ของอินเทอร์เฟซคือการกำหนดสัญญาและทำให้การพึ่งพาของคุณควบคู่กันอย่างอิสระไม่ได้มีวิธีการบางอย่างที่จะUnsupportedOperationExceptionทำลายวัตถุประสงค์ มันหมายความว่าฉันไม่สามารถผ่านSetและใช้งานaddAllได้อีกต่อไป แต่ฉันต้องรู้ว่าSetฉันใช้งานอะไรบ้างฉันจึงสามารถรู้ได้ว่าฉันสามารถใช้addAllหรือไม่ นั่นดูเหมือนจะไร้ค่าสำหรับฉัน แล้วประเด็นUnsupportedOperationExceptionคืออะไร มันเป็นเพียงการสร้างรหัสดั้งเดิมและพวกเขาจำเป็นต้องทำความสะอาดอินเตอร์เฟสของพวกเขา? หรือว่ามันมีจุดประสงค์ที่ละเอียดอ่อนกว่าที่ฉันหลงหายไป?

12 java  interfaces  methods 

ฉันต้องการคำแนะนำเกี่ยวกับองค์กรของชุดโครงการ C ++ ที่เกี่ยวข้อง แต่เป็นอิสระที่เก็บไว้ในที่เก็บ (git) เดียว โครงการใช้ CMake สำหรับตัวอย่างที่ง่ายเรานึกภาพ 2 โครงการ A และ B ขึ้นอยู่กับ B. คนส่วนใหญ่ที่พัฒนา A จะได้รับ B ผ่านระบบบรรจุภัณฑ์ ดังนั้นพวกเขาจะรวบรวมเพียง A. อย่างไรก็ตามเราควรอนุญาตให้นักพัฒนาคอมไพล์ทั้ง A และ B เอง (และติดตั้ง) แยกกันหรือรวมกัน นี่คือข้อเสนอ: └── Repo1 ├── CMakeLists.txt (1) ├── A │ ├── CMakeLists.txt (2) │ ├── include │ │ ├── aaa.h …

12 c++  organization  code-organization  dependency-management  cmake 

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

12 data-structures  binary-tree 

ตามแผนภาพด้านล่างยกเว้นส่วนต่อประสานส่วนIterableที่เหลือทั้งหมดที่สร้างขึ้น (คลาสอินเตอร์เฟส / คลาส / นามธรรม) จะอยู่ในแพ็คเกจเดียวกันjava.util ทำไมต้องIterableนั่งในjava.langแพ็คเกจ? หมายเหตุ: ความตั้งใจคือการทำความเข้าใจกับแง่มุมของบรรจุภัณฑ์ของการเขียนโปรแกรมจาวา

12 java  api  packages  collections 

ฉันต้องการมีประสิทธิภาพมากขึ้นและต้องการใช้เครื่องมือ ops อย่างมีประสิทธิภาพ ด้วยความคิดนี้ฉันต้องการเรียนรู้เพิ่มเติมเกี่ยวกับการรวมกลุ่มอย่างต่อเนื่อง แต่ดูเหมือนว่ามีหลายสิ่งที่เกี่ยวข้อง จริง ๆ แล้วฉันทำงานกับชุด Jetbrains ในงานของฉัน (IntelliJ, WebStorm ... ) ดังนั้นฉันจึงต้องการใช้พวกเขาต่อไปและฉันต้องการใช้ TeamCity ซึ่งดูเหมือนจะเป็นเครื่องมือที่ยอดเยี่ยมกับปลั๊กอินจำนวนมากสำหรับการรวมอย่างต่อเนื่อง ปัญหาของฉันคือฉันไม่รู้ว่าอะไรคือความแตกต่างระหว่าง: อาคารอัตโนมัติ (TeamCity เป็นซอฟต์แวร์ประเภทนี้): ฉันรู้ว่าเราสามารถสร้างแอปพลิเคชันของเราด้วยพื้นที่เก็บข้อมูล VCS ระยะไกลและมันยอดเยี่ยม แต่จุดประสงค์หลักของมันคืออะไร? ข้อมูลประเภทใดมีความสำคัญขณะทำสิ่งนี้ ที่จริงแล้วฉันรู้แล้วว่าซอฟต์แวร์ของฉันสร้างขึ้นหรือไม่อยู่ในพื้นที่และเพื่อนร่วมทีมของฉันด้วย ดังนั้นอะไรคือเป้าหมายของการใช้โดยไม่ต้องปรับใช้ระบบอัตโนมัติ? การปรับใช้ระบบอัตโนมัติ (TeamCity ดูเหมือนจะไม่ทำอย่างง่ายดาย) บูรณาการอย่างต่อเนื่อง (ซึ่งดูเหมือนว่าจะเป็นการรวมกันของทั้งสองข้างต้น) การจัดส่งอย่างต่อเนื่อง (นี่คืออะไรจริง ๆ ทำไมมันแตกต่างจากการรวมอย่างต่อเนื่อง?) คุณช่วยฉันเข้าใจเรื่องนี้ให้มากขึ้นได้ไหม?

12 continuous-integration  continuous-delivery 

นายจ้างของฉันใช้การแข่งขันแบบทดสอบรายวัน หนึ่งวันเต็มจะทุ่มเทให้กับการเขียนแบบทดสอบหน่วย - แน่นอนเราทำการทดสอบเพิ่มเติมตลอดทั้งเดือน แต่นี่เป็นทั้งวัน - และ "ผู้ชนะ" ของการแข่งขันจะได้รับรางวัล อย่างไรก็ตามเราพบว่ามันยากที่จะตัดสินว่าใครเป็นผู้ชนะ เรากำหนดคะแนนสำหรับแต่ละกรณีทดสอบ ดังนั้นถ้าคุณเขียนการทดสอบหน่วยเช่นนี้ ... for (int i = 0; i < 100; i++) { assertTrue(i*i, square(i)); } คุณจะได้รับ 100 คะแนน เห็นได้ชัดว่านี่เป็นตัวอย่างง่าย ๆ แต่มันแสดงให้เห็นถึงปัญหากับการกำหนด "คะแนน" ให้กับแต่ละกรณีทดสอบ เราเป็นร้านค้า Java & Javascript เป็นหลัก ดังนั้นฉันจึงแนะนำการนับจำนวนสาขารหัสที่ทดสอบเป็นเมตริก เราสามารถนับจำนวนสาขาที่ทดสอบผ่านเครื่องมือครอบคลุมรหัสได้อย่างง่ายดาย (เช่น EclEmma) อย่างไรก็ตามไม่แน่ใจว่าเราจะทำอย่างไรกับการทดสอบซีลีเนียมของเราและรับรหัสที่ครอบคลุมในแหล่ง Javascript (ความคิดใด ๆ ?) ไม่มีใครมีข้อเสนอแนะใด ๆ …

12 java  javascript  unit-testing  selenium