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

ในJavaScript ส่วนที่ดี Douglas Crockford เขียนว่า: JavaScript มีสองชุดของผู้ประกอบการเท่าเทียมกัน: ===และ!==และฝาแฝดที่ชั่วร้ายของพวกเขาและ== !=คนดีทำงานในแบบที่คุณคาดหวัง หากทั้งสองตัวถูกดำเนินการเป็นประเภทเดียวกันและมีค่าเหมือนกันแล้ว===ผลิตtrueและการผลิต!== falseฝาแฝดที่ชั่วร้ายทำสิ่งที่ถูกต้องเมื่อตัวถูกดำเนินการเป็นประเภทเดียวกัน แต่ถ้าพวกมันต่างชนิดกันพวกมันพยายามที่จะบีบบังคับค่า กฎที่พวกเขาทำมีความซับซ้อนและไม่น่าจดจำ นี่คือบางกรณีที่น่าสนใจ: '' == '0' // false 0 == '' // true 0 == '0' // true false == 'false' // false false == '0' // true false == undefined // false false == null // false null …

276 javascript  code-quality 

การจัดฟันแบบหยิกควรอยู่ในแนวของตนเองหรือไม่? คุณคิดยังไงกับเรื่องนี้? if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); } หรือมันควรจะเป็น if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); } หรือแม้กระทั่ง if (you.hasAnswer()) you.postAnswer(); else you.doSomething(); โปรดสร้างสรรค์! อธิบายว่าทำไมแบ่งปันประสบการณ์สำรองข้อมูลด้วยข้อเท็จจริงและการอ้างอิง

273 coding-style  code-formatting 

ในการพัฒนาเว็บยุคใหม่ฉันเจอรูปแบบนี้บ่อยขึ้นกว่าเดิม ดูเหมือนว่านี้: <div class="table"> <div class="row"> <div class="cell"></div> <div class="cell"></div> <div class="cell"></div> </div> </div> และใน CSS มีบางสิ่งที่คล้ายกัน: .table { display: table; } .row { display: table-row; } .cell { display: table-cell; } * (ชื่อคลาสเป็นเพียงตัวอย่างเท่านั้นในชีวิตจริงชื่อเหล่านี้เป็นชื่อคลาสปกติที่สะท้อนถึงองค์ประกอบ) ฉันเพิ่งพยายามทำสิ่งนี้ด้วยตัวเองเพราะ ... คุณรู้ไหมทุกคนทำมัน แต่ฉันก็ยังไม่เข้าใจ เราจะทำเช่นนี้ทำไม? หากคุณต้องการโต๊ะจากนั้นก็ทำการทำลาย<table>และทำมัน ใช่แม้ว่ามันจะเป็นรูปแบบ นั่นคือสิ่งที่ตารางมีไว้สำหรับ - การจัดวางสิ่งต่าง ๆ ในแบบตาราง คำอธิบายที่ดีที่สุดที่ฉันมีคือตอนนี้ทุกคนเคยได้ยินมนต์ของ "ไม่ใช้ตารางสำหรับการจัดวาง" ดังนั้นพวกเขาจึงติดตามมันอย่างสุ่มสี่สุ่มห้า แต่พวกเขายังคงต้องการตารางสำหรับการจัดวาง …

269 html  css 

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

267 testing  teamwork  debugging  bug 

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

266 skills  junior-programmer  senior-developer 

HTML4 / XHTML1 อนุญาตเฉพาะ GET และ POST ในรูปแบบตอนนี้ดูเหมือนว่า HTML5 จะทำเช่นเดียวกัน มีข้อเสนอให้เพิ่มสองสิ่งนี้ แต่ดูเหมือนจะไม่ดึงดูดความสนใจ อะไรคือเหตุผลทางเทคนิคหรือทางการเมืองสำหรับการไม่รวม PUT และ DELETE ในร่างข้อกำหนด HTML5

265 html  html5 

ทัศนวิสัยprivateของฟิลด์คลาส / คุณสมบัติ / แอ็ตทริบิวต์มีประโยชน์หรือไม่? ใน OOP ไม่ช้าก็เร็วคุณจะสร้างคลาสย่อยของคลาสและในกรณีนั้นมันเป็นเรื่องดีที่จะเข้าใจและสามารถปรับใช้งานได้อย่างสมบูรณ์ หนึ่งในสิ่งแรกที่ฉันทำเมื่อฉันคลาสย่อยคลาสคือการเปลี่ยนprivateวิธีการprotectedมากมาย แต่ซ่อนรายละเอียดจากโลกภายนอกเป็นสำคัญดังนั้นเราจึงจำเป็นและไม่เพียงprotectedpublic คำถามของฉันคือ: คุณรู้เกี่ยวกับกรณีการใช้งานที่สำคัญprivateแทนที่จะprotectedเป็นเครื่องมือที่ดีหรือสองตัวเลือก " protected& public" เพียงพอสำหรับภาษา OOP หรือไม่?

265 object-oriented  encapsulation  access-modifiers 

C # ช่วยให้การใช้#region/ #endregionคำหลักเพื่อให้พื้นที่ของรหัสพับในการแก้ไข เมื่อใดก็ตามที่ฉันทำสิ่งนี้แม้ว่าฉันจะทำมันเพื่อซ่อนโค้ดขนาดใหญ่ที่อาจได้รับการ refactored เป็นคลาสหรือวิธีการอื่น ตัวอย่างเช่นฉันได้เห็นวิธีการที่มีรหัส 500 บรรทัดที่มี 3 หรือ 4 ภูมิภาคเพื่อให้สามารถจัดการได้ การใช้พื้นที่อย่างรอบคอบเป็นสัญญาณของปัญหาหรือไม่? ดูเหมือนว่าจะเป็นเช่นนั้นกับฉัน

264 c#  code-smell 

คำแนะนำของ Babel สำหรับ ES6พูดว่า: letvarเป็นใหม่ เห็นได้ชัดว่าแตกต่างเพียงว่าvarได้รับการกำหนดขอบเขตในปัจจุบันฟังก์ชั่นในขณะที่letได้รับการกำหนดขอบเขตในปัจจุบันบล็อก มีตัวอย่างที่ดีใน คำตอบนี้ ฉันไม่เห็นเหตุผลที่จะใช้varในรหัส ES6 แม้ว่าคุณต้องการกำหนดขอบเขตตัวแปรที่กำหนดให้กับฟังก์ชันทั้งหมดคุณสามารถทำได้ด้วยletการใส่การประกาศที่ด้านบนของบล็อกฟังก์ชันซึ่งเป็นสิ่งที่คุณควรทำด้วยvarอย่างไรก็ตามเพื่อระบุขอบเขตที่แท้จริง และถ้าคุณต้องการกำหนดขอบเขตบางสิ่งให้ละเอียดยิ่งขึ้นในforบล็อกหรือบางอย่างคุณก็สามารถทำได้เช่นกัน ดังนั้นสัญชาตญาณของฉันคือหยุดใช้varทั้งหมดเมื่อเขียนรหัส ES6 คำถามของฉันคือฉันผิดเกี่ยวกับเรื่องนี้? มีกรณีที่ถูกต้องตามกฎหมายที่varจะได้รับความนิยมมากกว่าlet?

261 javascript  es6 

ฉันตั้งใจจะจ้างโปรแกรมเมอร์รุ่นเยาว์ 2-3 คนออกจากวิทยาลัย นอกเหนือจากเงินสดแล้วสิ่งที่สำคัญที่สุดสำหรับโปรแกรมเมอร์หนุ่มคืออะไร? มันเป็นเกมที่ทำงานหรือไม่? ฉันต้องการความคิดสร้างสรรค์ ... ฉันต้องการความคิดที่ดี

257 management  junior-programmer 

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

257 teaching 

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

250 state  globals 

หากออบเจ็กต์ที่ไม่เปลี่ยนรูปแบบนั้นดีง่ายและให้ประโยชน์ในการเขียนโปรแกรมพร้อมกันเหตุใดโปรแกรมเมอร์จึงต้องสร้างออบเจ็กต์ที่เปลี่ยนแปลงไม่ได้² ฉันมีประสบการณ์สี่ปีในการเขียนโปรแกรม Java และอย่างที่ฉันเห็นสิ่งแรกที่ผู้คนทำหลังจากสร้างคลาสคือสร้าง getters และ setters ใน IDE (ทำให้มันไม่แน่นอน) มีการขาดการรับรู้หรือเราสามารถใช้วัตถุที่เปลี่ยนแปลงได้ในสถานการณ์ส่วนใหญ่หรือไม่? ¹ วัตถุที่ไม่เปลี่ยนรูปนั้นเป็นวัตถุที่ไม่สามารถแก้ไขสถานะได้หลังจากสร้างขึ้นแล้ว ² วัตถุที่ไม่แน่นอนเป็นวัตถุที่สามารถแก้ไขได้หลังจากที่มันถูกสร้างขึ้น

250 object-oriented  immutability 

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

245 language-agnostic  skills 

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

243 java  object-oriented  programming-practices  performance