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

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

13 terminology 

ฉันมีคลาสซึ่งล้อมคลาสอื่นที่เป็นประเภทพื้นฐานทั่วไป เนื่องจากอินเตอร์เฟสประเภทฐานมีขนาดค่อนข้างใหญ่จึงเกี่ยวข้องกับการเขียนฟังก์ชั่นการส่งผ่านจำนวนมาก ฉันกำลังมองหาวิธีที่จะหลีกเลี่ยงปัญหานี้ ลองทำตัวอย่าง: Car / \ Volvo VolvoWithTrailer ตอนนี้ฉันต้องติดตั้งฟังก์ชั่นแต่ละอย่างในอินเทอร์เฟซสำหรับรถยนต์ของ VolvoWithTrailer และเรียกใช้ฟังก์ชั่นที่เหมาะสมบนวัตถุที่ห่อหุ้มวอลโว่ยกเว้นอาจ GetMaxSpeed ​​() ซึ่งจะคืนสิ่งที่ต่ำกว่า โดยทั่วไปฉันจะมีฟังก์ชั่นมากมายเช่น int VolvoWithTrailer::GetNumSeats() { return mVolvo.GetNumSeats() } วิธีที่ชัดเจนในการแก้ไขปัญหานี้คือการทำให้ VolvoWithTrailer เป็น subclass ของ Volvo Car | Volvo | VolvoWithTrailer แต่ดูเหมือนว่าจะละเมิดหลักการของการสนับสนุนการแต่งมากกว่ามรดก ฉันจะหลีกเลี่ยงการเขียนโปรแกรมเสริมเหล่านี้ได้อย่างไร (ภาษาคือ C ++) หรือ - ถ้านั่นคือตำแหน่งของคุณ - ทำไมฉันต้องเขียนพวกเขา / แค่ใช้การสืบทอด? มีแม่แบบเวทย์มนตร์ที่สามารถช่วยได้หรือไม่?

13 c++  inheritance  templates  composition 

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

13 design-patterns  object-oriented  solid  design 

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

13 parallelism  multithreading  locks 

ใหม่ไปที่ C ++! ดังนั้นฉันจึงอ่านสิ่งนี้: http://www.learncpp.com/cpp-tutorial/110-a-first-look-at-the-preprocessor/ หัวยาม เนื่องจากไฟล์ส่วนหัวสามารถรวมไฟล์ส่วนหัวอื่น ๆ จึงเป็นไปได้ที่จะสิ้นสุดในสถานการณ์ที่ไฟล์ส่วนหัวรวมหลายครั้ง ดังนั้นเราจึงกำหนดให้ตัวประมวลผลล่วงหน้าเพื่อหลีกเลี่ยงปัญหานี้ แต่ฉันไม่แน่ใจ - ทำไมคอมไพเลอร์ไม่สามารถทำได้เพียงแค่ ... ไม่นำเข้าสิ่งเดียวกันสองครั้ง เนื่องจากการ์ดส่วนหัวนั้นเป็นทางเลือก (แต่เห็นได้ชัดว่าเป็นการปฏิบัติที่ดี) มันทำให้ฉันคิดว่ามีสถานการณ์เมื่อคุณต้องการนำเข้าบางสิ่งบางอย่าง แม้ว่าฉันจะไม่สามารถนึกถึงสถานการณ์ดังกล่าวได้เลย ความคิดใด ๆ

13 c++  compiler 

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

13 licensing  open-source  intellectual-property 

เมื่อฉันเขียนรหัสเช่นนี้โดยที่ obj เป็นตัวแปรท้องถิ่น: if (obj is IMyInterface) { var result = (IMyInterface)obj; // .... } Resharper เสนอให้เปลี่ยนเป็นรหัสดังนี้: var result = obj as IMyInterface; if (result != null) { // ... } ฉันชอบแบบเก่าเนื่องจากไม่มีข้อยกเว้นสำหรับการอ้างอิงเป็นโมฆะโดยไม่ได้ตั้งใจ เหตุผลอะไรที่ทำให้เลือกรูปแบบอื่น? ทำไม Resharper จึงแนะนำสิ่งนี้

13 c#  resharper 

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

13 licensing  gpl  mit-license 

ปัญหา: นักพัฒนาสองคน => สามความคิดเห็นต่อการเยื้อง, การจัดฟันในบรรทัดใหม่หรือไม่ ฯลฯ เรามักจะทำงานกับคนสามหรือสี่คนในโครงการของเราและแต่ละคนก็มีสไตล์โค้ดของตัวเอง ฉันรู้ว่าวิธีแก้ปัญหาทั่วไปคือการยอมรับสไตล์โค้ดทุกคนต้องใช้ แต่ฉันไม่ต้องการบังคับให้โปรแกรมเมอร์สร้างสรรค์ในชุดที่ไม่เหมาะกับพวกเขา ดังนั้นคำถามคือ: มีวิธีให้โปรแกรมเมอร์แต่ละคนใช้สไตล์ของตนเอง แต่มีฐานรหัสทั่วไปภายในพื้นที่เก็บข้อมูลหรือไม่ ฉันคิดว่าบาง git / svn / ปลั๊กอินใด ๆ ซึ่งการเปลี่ยนแปลงระหว่างสไตล์ส่วนตัวและทั่วไปในการชำระเงินและกระทำ ดูเหมือนว่าฉันว่าส่วนที่ยุ่งยากในวิธีนี้คือการสนับสนุนความแตกต่างที่ถูกต้องระหว่างเวอร์ชันของไฟล์

13 coding-style 

ฉันมีคำถามเกี่ยวกับแนวทางปฏิบัติที่เหมาะสมที่สุดในการหมุนรหัสฟอร์กกิ้ง ฉันได้รับอนุญาตให้ใช้รหัสฐานภายใต้Creative Commons Attribution-NonCommercial-ShareAlike 3.0และได้ทำการเปลี่ยนแปลงที่สำคัญเพื่อให้เหมาะกับความต้องการของฉัน ฉันรู้สึกว่าเวอร์ชันของฉันจะมีประโยชน์ต่อผู้อื่นและต้องการแจกจ่ายซ้ำ ฉันไม่แน่ใจว่าฉันมีเสรีภาพในการแจกจ่ายต่อหรืออะไรที่ยอมรับได้ ฉันสามารถเปลี่ยนชื่อโครงการได้หรือไม่ ฉันควรเริ่ม v.1 ใหม่หรือทำต่อจากหมายเลขเวอร์ชันดั้งเดิมหรือไม่ อะไรคือการพิจารณาให้มีการระบุแหล่งที่มาที่เหมาะสมกับผู้เขียนต้นฉบับ? ฉันควรปรึกษาผู้เขียนและขออนุญาตก่อนที่จะปล่อย (แม้ว่าเขาจะรู้อยู่แล้ว)?

13 open-source  forking  creative-commons 

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

13 open-source  builds  software-patches 

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

13 binary-tree  graph-traversal 

ฉันเขียนคลาสนี้ที่ทำบางสิ่ง (บางทีนี่อาจเป็นการละเมิดหลักการความรับผิดชอบเดี่ยว) ตอนนี้ฉันรู้แล้วว่าบางส่วนของโครงการต้องการตรรกะชิ้นหนึ่งและวิธีที่ฉันจะเปิดเผยก็คือการดึงคลาสออกจากระบบเดิมภายใต้การทดสอบของฉัน ฉันคาดหวังว่าจะสามารถทำได้โดยไม่ต้องเปลี่ยนรหัสทดสอบใด ๆ แต่เมื่อฉันเสร็จคุณสามารถยืนยันว่าการทดสอบไม่ใช่การทดสอบหน่วยอีกต่อไป มันจะทำการทดสอบคลาสเดิมและคลาสที่ฉันแยกออกมา กล่าวอีกนัยหนึ่งฉันจะมีหนึ่งกรณีทดสอบ แต่สองระบบภายใต้การทดสอบ ฉันควร refactor รหัสทดสอบของฉันหลังจากที่ฉันทำเสร็จแล้ว? IE: สร้าง ExtractedClassTest และย้ายการทดสอบที่เกี่ยวข้องทั้งหมดจาก OriginalClassTest ลงไปหรือไม่ ดูเหมือนว่าอาจมีความเสี่ยงเล็กน้อย: ฉันอาจสูญเสียความครอบคลุมบางส่วนในกระบวนการอาจไม่ง่ายเหมือนการย้ายการทดสอบและฉันสิ้นสุดการเขียนรหัสการทดสอบบางอย่างที่ฉันรู้ว่าเคยทำงาน แต่อาจไม่ได้อีกต่อไป เป็นต้น ในทางกลับกันถ้าฉันปล่อยให้ OriginalClassTest ตามเดิมฉันสามารถเห็นว่านี่เป็นปัญหาการบำรุงรักษาทดสอบ มันจะสับสนเล็กน้อยในการค้นหาที่การทดสอบของ ExtractedClass ความประทับใจแรกของคุณก็คือมันไม่มีอยู่จริง เมื่อเวลาผ่านไปด้วยการปรับโครงสร้างรหัสการผลิตจำนวนมากสิ่งนี้อาจกลายเป็นปัญหาร้ายแรง ฉันใหม่สำหรับ TDD ดังนั้นฉันต้องการคำแนะนำจากผู้เชี่ยวชาญ ขอบคุณ!

13 programming-practices  unit-testing  tdd  integration-tests 

ฉันเพิ่งเปิดตัว Java Library ขนาดเล็กที่มีคลาสและเมธอดไม่กี่ตัว ตั้งแต่ฉันสร้างโครงการด้วย Maven ฉันจึงใช้ห้องสมุดบุคคลที่สามหลายแห่งเพื่อบรรลุเป้าหมายโดยเฉพาะ: commons-lang3 (สำหรับบางสิ่ง Java ทั่วไป) slf4j-api (สำหรับการบันทึก) คอมมอนส์ - io (สำหรับไฟล์เล็ก ๆ น้อย ๆ - ฉันอ่านไฟล์หนึ่งครั้ง) ฉันไม่ต้องการให้ห้องสมุดของฉันปรากฏในสายตาของคนอื่น ฉันควรพยายามลบการพึ่งพาห้องสมุดเหล่านี้เพื่อลดปริมาณการปล่อยหรือไม่ คำแนะนำเกี่ยวกับห้องสมุดประเภทใดควรหลีกเลี่ยงเมื่อพิจารณาการใช้เพิ่มเติมในอนาคต

13 java  libraries  maven 

สำหรับคำปราศรัยรางวัลทัวริงปี 1990เฟอร์นันโดเจคอร์บัตโตระบุเหตุผลว่าทำไมระบบที่ซับซ้อนจะล้มเหลวอย่างหลีกเลี่ยงไม่ได้ ในบทสรุปของเขาเขาให้คำแนะนำสำหรับการลดความน่าจะเป็นของความล้มเหลว เขาแสดงความคิดเดียวดังนี้: [U] se ของภาษาที่มีข้อ จำกัด สำหรับการออกแบบหรือการสังเคราะห์เป็นวิธีการที่ทรงพลัง การไม่อนุญาตให้โปรแกรมเมอร์หรือผู้ออกแบบแสดงความคิดเห็นที่ไม่เกี่ยวข้องทำให้โดเมนของข้อผิดพลาดที่อาจเกิดขึ้นมี จำกัด มากขึ้น เขาหมายถึงอะไรโดย "ภาษา จำกัด " สำหรับช่วงเวลาที่ผมถือว่าการเขียนโปรแกรม จำกัด อย่างไรก็ตามการเขียนโปรแกรมข้อ จำกัด เกี่ยวกับการ จำกัด พื้นที่โซลูชันของโปรแกรม มันเป็นเครื่องมือที่ช่วยให้โปรแกรมเมอร์ คุณสมบัติCorbatóหมายถึงดูเหมือนว่าจะเป็นสิ่งที่ จำกัด โปรแกรมเมอร์จริงๆหรืออย่างน้อยก็ทำให้เธอมีแนวโน้มที่จะเขียนรหัส terser มากขึ้น ความคิดที่สองของฉันคือการที่เขาจะหมายถึงการเขียนโปรแกรมภาษาอนุรักษ์นิยม Corbatóได้รับรางวัลทัวริงของเขาสำหรับงานที่ทำในปี 1960 และ 1970 เป็นความเข้าใจของฉันที่เขาจัดการกับการ์ดเจาะจำนวนมาก ฉันไม่เคยเห็น punch card ดังนั้นฉันไม่ทราบวิธีการตั้งโปรแกรมอย่างแน่นอน แต่ฉันอาจเดาว่าการเขียนโปรแกรม punch card นั้นมีความเป็นอิสระอย่างมาก ฉันสงสัยว่าการตรวจสอบประเภทการวิเคราะห์แบบคงที่และอื่น ๆ นั้นไม่มีอยู่จริง ดังนั้นอาจเป็นCorbatóอาจหมายถึงความคิดของภาษาที่ จำกัด นักพัฒนาจากการทำผิดพลาดโง่? ดูเหมือนจะไม่เป็นเช่นนั้น …

13 programming-languages