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

ใน Java 8 อินเทอร์เฟซสามารถมีวิธีการใช้งานวิธีการแบบคงที่และวิธีการที่เรียกว่า "เริ่มต้น" (ซึ่งชั้นเรียนการดำเนินการไม่จำเป็นต้องแทนที่) ในมุมมองของฉัน (อาจไร้เดียงสา) ไม่จำเป็นต้องละเมิดส่วนต่อประสานเช่นนี้ การเชื่อมต่อเป็นสัญญาที่คุณต้องปฏิบัติตามเสมอและนี่คือแนวคิดที่เรียบง่ายและบริสุทธิ์ ตอนนี้มันเป็นการผสมผสานของหลายสิ่งหลายอย่าง ในความเห็นของฉัน: วิธีการคงที่ไม่ได้เป็นของอินเตอร์เฟซ พวกมันอยู่ในคลาสยูทิลิตี้ ไม่ควรอนุญาตวิธีการ "เริ่มต้น" ในอินเทอร์เฟซเลย คุณสามารถใช้คลาสนามธรรมสำหรับวัตถุประสงค์นี้ได้เสมอ ในระยะสั้น: ก่อน Java 8: คุณสามารถใช้คลาสนามธรรมและคลาสปกติเพื่อจัดเตรียมเมธอด static และ default บทบาทของอินเตอร์เฟสชัดเจน วิธีการทั้งหมดในอินเทอร์เฟซควรจะ overriden โดยการใช้คลาส คุณไม่สามารถเพิ่มวิธีการใหม่ในอินเทอร์เฟซโดยไม่ต้องปรับเปลี่ยนการใช้งานทั้งหมด แต่นี่เป็นสิ่งที่ดีจริงๆ หลังจาก Java 8: ไม่มีความแตกต่างระหว่างอินเทอร์เฟซและคลาสนามธรรม (นอกเหนือจากมรดกหลายรายการ) ในความเป็นจริงคุณสามารถเลียนแบบคลาสปกติด้วยอินเทอร์เฟซ เมื่อตั้งโปรแกรมการใช้งานโปรแกรมเมอร์อาจลืมแทนที่วิธีการเริ่มต้น มีข้อผิดพลาดในการคอมไพล์ถ้าคลาสพยายามใช้อินเตอร์เฟสสองอินเตอร์เฟสขึ้นไปที่มีเมธอดดีฟอลต์ที่มีลายเซ็นเดียวกัน โดยการเพิ่มวิธีการเริ่มต้นให้กับส่วนติดต่อทุกชั้นใช้งานโดยอัตโนมัติสืบทอดพฤติกรรมนี้ คลาสเหล่านี้บางคลาสอาจไม่ได้รับการออกแบบโดยคำนึงถึงฟังก์ชันการทำงานใหม่และอาจทำให้เกิดปัญหาได้ ตัวอย่างเช่นถ้ามีคนเพิ่มวิธีการเริ่มต้นใหม่default void foo()ให้กับอินเทอร์เฟซIxจากนั้นชั้นเรียนCxดำเนินการIxและมีfooวิธีการส่วนตัวที่มีลายเซ็นเดียวกันจะไม่รวบรวม อะไรคือสาเหตุหลักที่ทำให้เกิดการเปลี่ยนแปลงครั้งใหญ่และพวกเขาจะได้ประโยชน์อะไรบ้าง (ถ้ามี)

99 java  programming-languages  interfaces  java8 

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

99 c++  performance 

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

99 java  language-design  exceptions  error-handling 

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

99 object-oriented  testing  tdd 

ดังที่ฉันเข้าใจใน Java หน่วยความจำสแต็คจะเก็บข้อมูลพื้นฐานและวิธีการเรียกใช้และหน่วยความจำฮีปใช้เพื่อจัดเก็บวัตถุ สมมติว่าฉันมีชั้นเรียน class A { int a ; String b; //getters and setters } ดั้งเดิมaในชั้นเรียนAจะถูกเก็บไว้ที่ไหน เหตุใดหน่วยความจำฮีปจึงมีอยู่ทั้งหมด ทำไมเราไม่เก็บทุกอย่างไว้ในกองซ้อน? เมื่อวัตถุได้รับการรวบรวมขยะสแต็กที่เกี่ยวข้องกับวัตถุที่ถูกทำลายจะถูกจัดเก็บหรือไม่?

99 java  memory  garbage-collection  stack  heap 

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

99 culture  mentor 

ใช่ใช่ผมทราบว่า'\n'เขียนขึ้นบรรทัดใหม่ในระบบปฏิบัติการยูนิกซ์ในขณะที่สำหรับ Windows '\r\n'มีลำดับสองตัวอักษร: ทั้งหมดนี้เป็นสิ่งที่ดีมากในทฤษฎี แต่คำถามของฉันคือทำไม ? เหตุใดอักขระการคืนตลับหมึกจึงมีความพิเศษใน Windows หาก UNIX สามารถทำได้ในกรณีที่\nใช้ Windows สองตัวเพื่อทำสิ่งนี้ ฉันกำลังอ่านหนังสือ Python ของ David Beazley และเขาพูดว่า: ตัวอย่างเช่นบน Windows การเขียนตัวอักษร '\ n' จริง ๆ แล้วจะส่งออกลำดับสองตัวอักษร '\ r \ n' (และเมื่ออ่านไฟล์กลับมา '\ r \ n' จะถูกแปลกลับเป็น '\ n' เดียว ตัวอักษร) ทำไมต้องใช้ความพยายามพิเศษ ฉันจะซื่อสัตย์ ฉันรู้จักความแตกต่างมาเป็นเวลานาน แต่ไม่เคยใส่ใจที่จะถามว่าทำไม ฉันหวังว่าจะได้รับคำตอบในวันนี้ ขอบคุณที่สละเวลา.

99 windows  linux  file-handling 

ดูเหมือนว่าเว็บเบราว์เซอร์ทั่วไปส่วนใหญ่ (Firefox, Chrome, Safari) ได้รับการพัฒนาโดยใช้ C ++ มันเป็นอย่างนั้นเหรอ?

99 programming-languages  c++  browser  web 

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

98 unit-testing  testing  continuous-integration  integration-tests 

คุณมีคลาส X และคุณเขียนการทดสอบหน่วยบางอย่างที่ตรวจสอบพฤติกรรม X1 นอกจากนี้ยังมีคลาส A ซึ่งใช้ X เป็นตัวอ้างอิง เมื่อคุณเขียนการทดสอบหน่วยสำหรับ A คุณจำลอง X ในคำอื่น ๆ ในขณะที่การทดสอบหน่วย A คุณตั้งค่า (สมมุติ) พฤติกรรมของจำลองของ X ให้เป็น X1 เวลาผ่านไปผู้คนใช้ระบบของคุณต้องการการเปลี่ยนแปลง X วิวัฒนาการ: คุณแก้ไข X เพื่อแสดงพฤติกรรม X2 เห็นได้ชัดว่าการทดสอบหน่วยสำหรับ X จะล้มเหลวและคุณจะต้องปรับตัว แต่อะไรกับ A? การทดสอบหน่วยสำหรับ A จะไม่ล้มเหลวเมื่อปรับเปลี่ยนพฤติกรรมของ X (เนื่องจากการเยาะเย้ยของ X) วิธีการตรวจสอบว่าผลลัพธ์ของ A จะแตกต่างกันเมื่อทำงานด้วย X "จริง" (แก้ไข) X ฉันคาดหวังคำตอบตามบรรทัดของ: "นั่นไม่ใช่จุดประสงค์ของการทดสอบหน่วย" …

98 unit-testing  testing  mocking 

คำถามนี้เกิดขึ้นในหนึ่งในชั้นเรียนวิทยาลัยของฉัน อาจารย์เพียง แต่ให้คำตอบว่ามันเป็นอธิบายเพิ่มเติม แต่มันดูเหมือนกับว่า<b>และ<i>ค่อนข้างชัดเจนในความหมายของพวกเขาและง่ายต่อการพิมพ์กว่าและ<strong><em> อะไรคือข้อโต้แย้งอย่างเป็นทางการสำหรับการคัดค้านแท็กเหล่านี้

98 html  deprecation 

แอปพลิเคชัน Java ส่วนใหญ่จะไม่เหมือนกับแอปพลิเคชัน C / C ++ Swing อาจได้รับการออกแบบโดยมีจุดประสงค์เพื่อให้ได้รูปลักษณ์ที่แตกต่าง แต่จากสิ่งที่ฉันได้อ่าน SWT นั้นพยายามที่จะ 'look native' และไม่ประสบความสำเร็จ คำถามของฉันคือ: ทำไมมันจึงเป็นเรื่องยากสำหรับนักพัฒนาของภาษา Java ในการออกแบบระบบ GUI ที่สำเนาว่ารูปลักษณ์ของ GUIs พื้นเมือง? GUIs ดั้งเดิมต่างกันอย่างไร มันไม่ใช่แค่เรื่องของการออกแบบปุ่มที่ดูเหมือนปุ่ม 'ดั้งเดิม' ใช่ไหม หรือลึกไปกว่านั้น?

98 java  gui 

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

98 design-patterns  python 

คำinvertหรือcontrolไม่ได้ใช้เลยเพื่อกำหนด Inversion of Control ในคำจำกัดความที่ฉันเคยเห็น คำนิยาม วิกิพีเดีย การผกผันของการควบคุม (IoC) เป็นเทคนิคการเขียนโปรแกรมแสดงไว้ที่นี่ในแง่ของการเขียนโปรแกรมเชิงวัตถุซึ่งการเชื่อมต่อวัตถุถูกผูกไว้ในเวลาทำงานโดยวัตถุประกอบและโดยทั่วไปจะไม่รู้จักในเวลารวบรวมโดยใช้การวิเคราะห์แบบคงที่ ~ http://en.wikipedia.org/wiki/Inversion_of_control Martin Fowler การผกผันของการควบคุมเป็นรูปแบบทั่วไปในชุมชน Java ที่ช่วยให้สายไฟภาชนะบรรจุที่มีน้ำหนักเบาหรือประกอบชิ้นส่วนจากโครงการที่แตกต่างกันในการประยุกต์ใช้เหนียว ~ อิงจาก http://www.martinfowler.com/articles/inject.html (reworded) แล้วทำไม Inversion of Control ถึงชื่อว่า Inversion of Control? การควบคุมแบบใดที่กลับด้านและเกิดอะไรขึ้น มีวิธีกำหนด Inversion of Control โดยใช้คำศัพท์: กลับหัวและควบคุม ?

98 naming  definition  ioc-containers  inversion-of-control 

ฉันเคยเห็นคนจำนวนมากบ่นเกี่ยวกับการใช้คำฟุ่มเฟื่อยในภาษาโปรแกรม ฉันพบว่าภายในขอบเขตบางอย่างยิ่งภาษาการเขียนโปรแกรม verbose ยิ่งดีกว่าก็คือการเข้าใจ ฉันคิดว่าการใช้คำฟุ่มเฟื่อยยังตอกย้ำการเขียนที่ชัดเจนAPIสำหรับภาษานั้น ข้อเสียเดียวที่ฉันคิดได้ก็คือมันทำให้คุณพิมพ์ได้มากขึ้น แต่ฉันหมายความว่าคนส่วนใหญ่ใช้ IDE ที่ทำงานทุกอย่างให้คุณ ดังนั้นข้อเสียที่เป็นไปได้ของภาษาการเขียนโปรแกรม verbose คืออะไร?

98 programming-languages