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

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

37 recursion  loops 

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

37 python  terminology 

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

37 design  development-methodologies  methodology 

ฉันเคยเห็นมาแล้วในหลาย ๆ ที่ว่ามันเป็นภูมิปัญญาที่ยอมรับ1ว่าเป็นความรับผิดชอบของผู้โทรเพื่อให้แน่ใจว่าคุณอยู่ในเธรด UI เมื่ออัปเดตองค์ประกอบ UI (โดยเฉพาะใน Java Swing ที่คุณอยู่ในEvent Dispatch Thread ) . ทำไมเป็นเช่นนี้ Event Dispatch Thread เป็นปัญหาของมุมมองใน MVC / MVP / MVVM เพื่อจัดการที่ใดก็ได้ แต่มุมมองจะสร้างการเชื่อมต่ออย่างแน่นหนาระหว่างการนำไปใช้ของมุมมองและโมเดลการทำเกลียวของการปรับใช้มุมมองนั้น โดยเฉพาะสมมติว่าฉันมีแอปพลิเคชันที่ออกแบบมาให้ใช้งาน MVC ซึ่งใช้ Swing ถ้าโทรเป็นผู้รับผิดชอบสำหรับส่วนประกอบปรับปรุงในกระทู้ที่จัดกิจกรรมส่งแล้วถ้าฉันพยายามที่จะสลับออกสวิงดูการดำเนินงานของฉันสำหรับการดำเนินงาน JavaFX ผมต้องเปลี่ยนทุกรหัส Presenter / ควบคุมการใช้ด้าย JavaFX ประยุกต์ใช้แทน ดังนั้นฉันคิดว่าฉันมีสองคำถาม: เหตุใดจึงเป็นความรับผิดชอบของผู้โทรเพื่อให้มั่นใจในความปลอดภัยของเธรดส่วนประกอบ UI ข้อบกพร่องในการให้เหตุผลด้านบนของฉันอยู่ที่ไหน ฉันจะออกแบบแอปพลิเคชันของฉันให้มีเพศสัมพันธ์แบบหลวม ๆ เกี่ยวกับความปลอดภัยของเธรดเหล่านี้ได้อย่างไร แต่ยังคงปลอดภัยต่อเธรดอย่างเหมาะสม ให้ฉันเพิ่มรหัส MCVE Java เพื่อแสดงให้เห็นถึงสิ่งที่ฉันหมายถึงโดย …

37 mvc  multithreading  user-interface 

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

37 open-source 

ฉันกำลังล้างค่าการรวมในโครงการ C ++ ที่ฉันกำลังทำงานอยู่และฉันสงสัยอยู่เสมอว่าควรรวมส่วนหัวทั้งหมดที่ใช้โดยตรงในไฟล์ใดไฟล์หนึ่งหรือไม่หรือควรจะรวมเฉพาะขั้นต่ำเปล่าเท่านั้น นี่คือตัวอย่างEntity.hpp: #include "RenderObject.hpp" #include "Texture.hpp" struct Entity { Texture texture; RenderObject render(); } (สมมติว่าการประกาศล่วงหน้าสำหรับRenderObjectไม่ใช่ตัวเลือก) ตอนนี้ฉันรู้ว่าRenderObject.hppรวมถึงTexture.hpp- ฉันรู้ว่าเพราะแต่ละคนRenderObjectมีTextureสมาชิก ยังคงฉันอย่างชัดเจนรวมถึงTexture.hppในเพราะฉันไม่แน่ใจว่ามันเป็นความคิดที่ดีที่จะพึ่งพามันถูกรวมอยู่ในEntity.hppRenderObject.hpp ดังนั้น: เป็นการปฏิบัติที่ดีหรือไม่?

37 c++  c  headers  include 

ฉันมีการพูดคุยกับเพื่อนร่วมงานและท้ายที่สุดเราก็มีสัญชาติญาณที่ขัดแย้งกันเกี่ยวกับวัตถุประสงค์ของการทำคลาสย่อย สัญชาตญาณของฉันคือถ้าฟังก์ชั่นหลักของคลาสย่อยแสดงค่าที่เป็นไปได้ที่ จำกัด ของพาเรนต์มันก็คงไม่ควรเป็นคลาสย่อย เขาแย้งกับสัญชาตญาณตรงข้ามว่าคลาสย่อยหมายถึงวัตถุที่เป็น "เฉพาะ" มากกว่าดังนั้นความสัมพันธ์คลาสย่อยจึงเหมาะสมกว่า เพื่อให้สัญชาตญาณของฉันเป็นรูปธรรมมากขึ้นฉันคิดว่าถ้าฉันมี subclass ที่ขยายคลาสแม่ แต่รหัสเดียวที่แทนที่ subclass เป็นตัวสร้าง (ใช่ฉันรู้ว่าตัวสร้างไม่ได้โดยทั่วไป "แทนที่", ทนกับฉัน) แล้ว สิ่งที่จำเป็นจริงๆคือวิธีการช่วยเหลือ ตัวอย่างเช่นลองพิจารณาชั้นเรียนชีวิตจริงนี้: public class DataHelperBuilder { public string DatabaseEngine { get; set; } public string ConnectionString { get; set; } public DataHelperBuilder(string databaseEngine, string connectionString) { DatabaseEngine = databaseEngine; ConnectionString = connectionString; } …

37 design-patterns  object-oriented  inheritance  anti-patterns 

มีรูปแบบการออกแบบที่เป็นไปได้สำหรับโปรแกรมเชิงวัตถุหรือไม่? ฉันถามนี้เพราะเมื่อเร็ว ๆ นี้ผมเห็นการดำเนินการระดับกับDoor Lockมันเป็นส่วนหนึ่งของการทดสอบและคำตอบบอกว่ารหัสเป็นไปตามรูปแบบวัตถุ Null: class Lock { public: virtual void close() = 0; virtual void open() = 0; virtual bool is_open() const = 0; virtual ~Lock() { } }; class DummyLock : public Lock { private: DummyLock(); DummyLock(const DummyLock&) = delete; DummyLock& operator=(const DummyLock&) = delete; private: void …

37 design  design-patterns  object-oriented  object-oriented-design 

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

37 programming-languages  type-systems 

พิจารณาการออกแบบดังต่อไปนี้ public class Person { public virtual string Name { get; } public Person (string name) { this.Name = name; } } public class Karl : Person { public override string Name { get { return "Karl"; } } } public class John : Person { public override string Name …

37 programming-practices  inheritance  class-design  anti-patterns 

คุณสามารถค้นหารายการบล็อกบทความและเว็บไซต์ที่ไม่สิ้นสุดซึ่งส่งเสริมประโยชน์ของการทดสอบหน่วยซอร์สโค้ดของคุณ เกือบจะรับประกันได้ว่านักพัฒนาที่เขียนโปรแกรมคอมไพเลอร์สำหรับ Java, C ++, C # และภาษาที่พิมพ์อื่น ๆ ใช้การทดสอบหน่วยเพื่อตรวจสอบงานของพวกเขา ดังนั้นทำไมแม้จะมีความนิยมของมันคือการทดสอบขาดจากไวยากรณ์ของภาษาเหล่านี้หรือไม่ Microsoft แนะนำLINQให้กับC #ดังนั้นทำไมพวกเขาจึงไม่สามารถเพิ่มการทดสอบได้อีกด้วย ฉันไม่ต้องการคาดการณ์ว่าการเปลี่ยนแปลงภาษาเหล่านั้นจะเป็นเช่นไร แต่เพื่ออธิบายให้ชัดเจนว่าทำไมพวกเขาถึงไม่เริ่มต้นด้วย เป็นตัวอย่าง: เรารู้ว่าคุณสามารถเขียนforลูปโดยไม่มีไวยากรณ์ของforคำสั่ง คุณสามารถใช้whileหรือif/ gotoงบ มีคนตัดสินใจว่าforข้อความนั้นมีประสิทธิภาพมากกว่าและนำมาใช้เป็นภาษา ทำไมการทดสอบไม่ได้ทำตามวิวัฒนาการของภาษาโปรแกรมเดียวกัน?

37 programming-languages  unit-testing  syntax 

ฉันอ่านข้อความดั้งเดิมของApache License รุ่น 2.0และคำอธิบายเป็นภาษาอังกฤษธรรมดา ตกลงฉันคัดลอกคลาสที่จัดทำโดยThe Best Company ในโลกใบอนุญาตของพวกเขาและแก้ไขรหัสเล็กน้อย ไฟล์ต้นฉบับที่มีการเปลี่ยนแปลงของฉัน /* * Copyright (C) 2011 The Best Company in the World * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy …

37 open-source  source-code  apache-license  distribution 

คำถามนี้เกี่ยวกับว่าจะสร้างคลาสที่ซ้อนใน Java เป็นคลาสที่ซ้อนกันหรือคลาสซ้อนภายใน ฉันค้นหาแถว ๆ นี้และใน Stack Overflow แต่ไม่พบคำถามใด ๆ เกี่ยวกับความหมายของการออกแบบของการตัดสินใจนี้ คำถามที่ฉันพบกำลังถามเกี่ยวกับความแตกต่างระหว่างคลาสแบบคงที่และแบบซ้อนภายในซึ่งชัดเจนสำหรับฉัน อย่างไรก็ตามฉันยังไม่พบเหตุผลที่น่าเชื่อถือที่จะใช้คลาสที่ซ้อนกันแบบคงที่ใน Java - ยกเว้นคลาสที่ไม่ระบุชื่อซึ่งฉันไม่ได้พิจารณาสำหรับคำถามนี้ นี่คือความเข้าใจของฉันเกี่ยวกับผลของการใช้คลาสที่ซ้อนกันคงที่: การมีเพศสัมพันธ์น้อย:โดยทั่วไปแล้วเราจะได้แต่งงานกันน้อยลงเนื่องจากชั้นเรียนไม่สามารถเข้าถึงคุณลักษณะของชั้นนอกได้โดยตรง การมีเพศสัมพันธ์น้อยโดยทั่วไปหมายถึงคุณภาพของรหัสที่ดีขึ้นการทดสอบที่ง่ายขึ้นการปรับโครงสร้างใหม่และอื่น ๆ โสดClass:ตัวโหลดคลาสไม่จำเป็นต้องดูแลคลาสใหม่ทุกครั้งที่เราสร้างวัตถุของคลาสภายนอก เราเพิ่งได้รับวัตถุใหม่สำหรับคลาสเดียวกันซ้ำแล้วซ้ำอีก สำหรับชั้นในฉันมักจะพบว่าผู้คนพิจารณาการเข้าถึงคุณลักษณะของชั้นนอกเป็นมืออาชีพ ฉันขอแตกต่างกันในเรื่องนี้จากมุมมองของการออกแบบเนื่องจากการเข้าถึงโดยตรงหมายความว่าเรามีคลัปสูงและหากเราต้องการแยกคลาสที่ซ้อนกันออกเป็นคลาสระดับบนที่แยกต่างหากเราสามารถทำได้หลังจากเปลี่ยน มันเป็นคลาสที่ซ้อนกันคงที่ ดังนั้นคำถามของฉันมาถึงสิ่งนี้: ฉันคิดผิดว่าการเข้าถึงคุณลักษณะที่มีให้กับคลาสภายในแบบไม่คงที่ทำให้เกิดการเชื่อมต่อสูงดังนั้นจึงมีคุณภาพรหัสต่ำกว่าและฉันอนุมานจากสิ่งนี้ว่าคลาสที่ซ้อนกัน โดยทั่วไปจะคงที่? หรืออีกนัยหนึ่ง: มีเหตุผลที่น่าเชื่อถือไหมว่าทำไมคนเราถึงชอบชนชั้นในที่ซ้อนกัน?

37 java  class-design  class  static-keyword 

ฉันเพิ่งอ่านเอกสารไวท์ & ตัวอย่างจากMicrosoft "Roslyn"และแนวคิดน่าสนใจมาก จากสิ่งที่ฉันสามารถบอกได้มันเปิดกล่องดำที่เป็นคอมไพเลอร์และให้ส่วนต่อประสานที่เราสามารถใช้รับข้อมูลและตัวชี้วัดเกี่ยวกับโค้ดที่เขียนใน Visual Studio โรสลินดูเหมือนว่าจะมีความสามารถในการ "สคริปต์" โค้ดและรวบรวม / ดำเนินการได้ทันที (คล้ายกับ CodeDom) แต่ฉันได้พบการใช้งานที่ จำกัด สำหรับประเภทการทำงานในประสบการณ์ของฉัน ในขณะที่องค์ประกอบการวิเคราะห์รหัสและตัวชี้วัดเป็นพื้นที่ที่น่าสนใจ ... มันเป็นสิ่งที่มีมานานแล้วและมีผู้ให้บริการจำนวนมากที่ได้ลงทุนเงินเป็นจำนวนมากในการวิเคราะห์รหัสและเครื่องมือการสร้างใหม่ (เช่น ReSharper, CodeRush , nCover และอื่น ๆ ) และพวกเขาทำได้ดีมาก! เหตุใด บริษัท ใดจึงออกนอกเส้นทางของพวกเขาเพื่อนำสิ่งที่สามารถให้มาได้ในราคาเพียงเศษเสี้ยวของต้นทุนโดยการซื้อใบอนุญาตสำหรับหนึ่งในเครื่องมือที่มีอยู่ บางทีฉันอาจพลาดฟังก์ชั่นหลักของโครงการ Roslyn ที่วางไว้นอกโดเมนของเครื่องมือที่กล่าวถึง ...

37 .net  visual-studio  static-analysis 

ตามเอกสารของ Microsoft บทความ Wikipedia SOLID principe หรือสถาปนิกด้านไอทีส่วนใหญ่เราต้องตรวจสอบให้แน่ใจว่าแต่ละชั้นมีหน้าที่รับผิดชอบเพียงอย่างเดียว ฉันอยากจะรู้ว่าทำไมเพราะถ้าทุกคนดูเหมือนจะเห็นด้วยกับกฎนี้ดูเหมือนจะไม่มีใครเห็นด้วยกับเหตุผลของกฎนี้ บางคนกล่าวถึงการบำรุงรักษาที่ดีกว่าบางคนบอกว่าเป็นการทดสอบที่ง่ายหรือทำให้ชั้นเรียนมีความแข็งแกร่งมากขึ้นหรือมีความปลอดภัย อะไรถูกและจริงหมายถึงอะไร ทำไมจึงทำให้การบำรุงรักษาดีขึ้นการทดสอบง่ายขึ้นหรือรหัสมีเสถียรภาพมากขึ้น?

37 design-patterns  architecture  solid  single-responsibility