คำถามติดแท็ก design

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

107 design  design-patterns 

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

103 design  unit-testing  testing  tdd 

ใน Code Complete หน้า 25 มีการกล่าวกันว่าเป็นความคิดที่ดีที่จะสามารถแทนที่คลาสส่วนติดต่อผู้ใช้ทั่วไปด้วยบรรทัดคำสั่งหนึ่งได้อย่างง่ายดาย รู้ถึงข้อดีของการทดสอบแล้วจะเกิดปัญหาอะไรขึ้น งานพิเศษนี้จะได้ผลตอบแทนจริงสำหรับเว็บและโครงการมือถือ โครงการขนาดกลางและเล็ก ใช้กฎเดียวกันนี้อย่างไร เกิดอะไรขึ้นถ้ามันทำให้การออกแบบของคุณซับซ้อนมากขึ้น?

92 design  architecture  user-interface  command-line 

ตัวอย่างเช่นเครื่องมือSysInternals "FileMon" จากอดีตมีไดรเวอร์โหมดเคอร์เนลที่มีซอร์สโค้ดทั้งหมดในไฟล์ 4,000 บรรทัด เช่นเดียวกันสำหรับโปรแกรม ping แรกที่เคยเขียน (~ 2,000 LOC)

88 design  c  source-code 

ในบทความนี้โดย Alex Papadimoulis คุณสามารถดูตัวอย่างนี้: private void attachSupplementalDocuments() { if (stateCode == "AZ" || stateCode == "TX") { //SR008-04X/I are always required in these states attachDocument("SR008-04X"); attachDocument("SR008-04XI"); } if (ledgerAmnt >= 500000) { //Ledger of 500K or more requires AUTHLDG-1A attachDocument("AUTHLDG-1A"); } if (coInsuredCount >= 5 && orgStatusCode != "CORP") { …

87 design 

ฉันได้เขียนโปรแกรมมานานกว่า 9 ปีและตามคำแนะนำของครูผู้สอนโปรแกรมคนแรกของฉันฉันมักจะทำให้main()ฟังก์ชั่นของฉันสั้นมาก ตอนแรกฉันไม่รู้ว่าทำไม ฉันแค่เชื่อฟังโดยไม่เข้าใจมากนักเพื่อความสุขใจของอาจารย์ หลังจากได้รับประสบการณ์ฉันรู้ว่าถ้าฉันออกแบบรหัสของฉันอย่างถูกต้องมีmain()ฟังก์ชั่นสั้น ๆแค่เกิดขึ้น การเขียนโค้ดที่ทำให้เป็นโมดูลและทำตามหลักการความรับผิดชอบเดียวทำให้รหัสของฉันถูกออกแบบเป็น "ช่อ" และmain()ทำหน้าที่เป็นตัวเร่งปฏิกิริยาเพื่อให้โปรแกรมทำงาน กรอไปข้างหน้าเมื่อไม่กี่สัปดาห์ที่ผ่านมาฉันมองไปที่โค้ด souce ของ Python และฉันพบmain()ฟังก์ชัน: /* Minimal main program -- everything is loaded from the library */ ... int main(int argc, char **argv) { ... return Py_Main(argc, argv); } งูหลามเย็ด main()ฟังก์ชั่นสั้น== รหัสที่ดี ครูการเขียนโปรแกรมถูกต้อง อยากดูลึกกว่านี้ฉันลองดู Py_Main ครบถ้วนถูกกำหนดไว้ดังนี้: /* Main program */ …

87 design  code-quality 

มักจะได้ยินว่า OOP นั้นสอดคล้องกับวิธีที่ผู้คนคิดเกี่ยวกับโลก แต่ฉันจะไม่เห็นด้วยอย่างยิ่งกับข้อความนี้: เรา (หรืออย่างน้อยฉัน) สร้างแนวคิดโลกในแง่ของความสัมพันธ์ระหว่างสิ่งต่าง ๆ ที่เราพบ แต่จุดเน้นของ OOP คือการออกแบบคลาสบุคคลและลำดับชั้นของพวกเขา โปรดสังเกตว่าในชีวิตประจำวันความสัมพันธ์และการกระทำมีอยู่ส่วนใหญ่ระหว่างวัตถุที่จะเป็นอินสแตนซ์ของคลาสที่ไม่เกี่ยวข้องใน OOP ตัวอย่างของความสัมพันธ์เช่น: "หน้าจอของฉันอยู่ด้านบนของตาราง"; "ฉัน (มนุษย์) กำลังนั่งอยู่บนเก้าอี้"; "รถยนต์อยู่บนถนน"; "ฉันพิมพ์บนแป้นพิมพ์"; "เครื่องชงกาแฟต้มน้ำ" "ข้อความจะปรากฏในหน้าต่างเทอร์มินัล" เราคิดในแง่ของ bivalent (บางครั้ง trivalent เช่นใน "ฉันให้คุณดอกไม้") คำกริยาที่กริยาคือการกระทำ (ความสัมพันธ์) ที่ทำงานบนวัตถุสองชิ้นเพื่อสร้างผลลัพธ์ / การกระทำบางอย่าง โฟกัสอยู่ในการดำเนินการและทั้งสอง (หรือสาม) [ไวยากรณ์] วัตถุมีความสำคัญเท่าเทียมกัน เปรียบเทียบกับ OOP ที่คุณต้องค้นหาวัตถุหนึ่ง (คำนาม) ก่อนและบอกให้ดำเนินการบางอย่างกับวัตถุอื่น วิธีการคิดเปลี่ยนจากการกระทำ / คำกริยาที่ใช้กับคำนามเป็นคำนามปฏิบัติการบนคำนาม - ราวกับว่าทุกอย่างถูกพูดด้วยเสียงเฉยๆหรือสะท้อนเสียงเช่น "ข้อความแสดงโดยหน้าต่างเทอร์มินัล" หรืออาจจะ …

86 design  design-patterns  object-oriented 

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

84 design 

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

83 design  project-management  estimation  technical-debt 

ฉันรู้สึกว่าฉันเก่งในการเขียนโค้ดเป็นบิตและชิ้นส่วน แต่งานออกแบบของฉันดูดจริงๆ คำถามคือฉันจะปรับปรุงการออกแบบของฉันได้อย่างไรและจะกลายเป็นนักออกแบบที่ดีขึ้นได้อย่างไร ฉันคิดว่าโรงเรียนและวิทยาลัยทำงานได้ดีในการสอนผู้คนถึงวิธีการแก้ปัญหาทางคณิตศาสตร์ได้ดี แต่ขอยอมรับความจริงที่ว่าแอปพลิเคชันส่วนใหญ่ที่สร้างขึ้นที่โรงเรียนมักมีความยาวประมาณ 1,000 - 2,000 บรรทัดซึ่งหมายความว่าส่วนใหญ่เป็นการฝึกหัดทางวิชาการ ซึ่งไม่ได้สะท้อนความซับซ้อนของซอฟต์แวร์ในโลกแห่งความเป็นจริงโดยเรียงตามบรรทัดโค้ดสองสามแสนถึงล้าน นี่คือที่ฉันเชื่อว่าแม้โครงการอย่าง topcoder / project euler ก็จะไม่ได้รับความช่วยเหลือมากนักพวกเขาอาจทำให้ความสามารถในการแก้ปัญหาทางคณิตศาสตร์ของคุณคมชัดขึ้น แต่คุณอาจเป็นโปรแกรมเมอร์เชิงวิชาการ คนที่มีความสนใจในสิ่งที่ดีและสะอาดที่ไม่สนใจในเรื่องธรรมดาและมีขนดกที่ผู้เขียนโปรแกรมประยุกต์ส่วนใหญ่ใช้เป็นประจำ ดังนั้นคำถามของฉันคือฉันจะพัฒนาทักษะการออกแบบได้อย่างไร นั่นคือความสามารถในการออกแบบแอพพลิเคชั่นขนาดเล็ก / ขนาดกลางที่จะเข้าไปในโค้ดสองสามพันบรรทัด? ฉันจะเรียนรู้ทักษะการออกแบบที่จะช่วยให้ฉันสร้างชุดแก้ไข html ที่ดีขึ้นได้อย่างไรหรือโปรแกรมกราฟิกบางอย่างเช่น gimp

83 design  skills 

เมื่อออกแบบระบบฉันมักจะประสบกับปัญหาการมีโมดูลจำนวนมาก (การบันทึก, acces ฐานข้อมูล, ฯลฯ ) ถูกใช้โดยโมดูลอื่น ๆ คำถามคือฉันจะไปเกี่ยวกับการให้ส่วนประกอบเหล่านี้กับส่วนประกอบอื่น ๆ ได้อย่างไร คำตอบสองคำตอบที่ดูเหมือนจะเป็นไปได้คือการฉีดขึ้นรูปหรือใช้รูปแบบของโรงงาน อย่างไรก็ตามทั้งคู่ดูเหมือนผิด: โรงงานทำการทดสอบความเจ็บปวดและไม่อนุญาตให้สลับการใช้งานได้ง่าย พวกเขายังไม่ได้อ้างอิงที่ชัดเจน (เช่นคุณกำลังตรวจสอบวิธีการโดยไม่คำนึงถึงความจริงที่ว่ามันเรียกวิธีการที่เรียกวิธีการที่เรียกวิธีการที่ใช้ฐานข้อมูล) การฉีด Dependecy จะสร้างรายการอาร์กิวเมนต์ตัวสร้างอย่างหนาแน่นและทำให้มีบางแง่มุมทั่วโค้ดของคุณ สถานการณ์ทั่วไปคือที่คอนสตรัคเตอร์ของคลาสมากกว่าครึ่งมีลักษณะเช่นนี้(....., LoggingProvider l, DbSessionProvider db, ExceptionFactory d, UserSession sess, Descriptions d) นี่เป็นสถานการณ์ทั่วไปที่ฉันมีปัญหากับ: ฉันมีคลาสยกเว้นซึ่งใช้คำอธิบายข้อผิดพลาดที่โหลดจากฐานข้อมูลโดยใช้แบบสอบถามที่มีพารามิเตอร์ของการตั้งค่าภาษาผู้ใช้ซึ่งอยู่ในวัตถุเซสชันผู้ใช้ ดังนั้นเพื่อสร้างข้อยกเว้นใหม่ฉันต้องการคำอธิบายซึ่งต้องการเซสชันฐานข้อมูลและเซสชันผู้ใช้ ดังนั้นฉันถึงวาระที่จะลากวัตถุเหล่านี้ทั้งหมดในวิธีการทั้งหมดของฉันในกรณีที่ฉันอาจต้องโยนข้อยกเว้น ฉันจะจัดการปัญหาดังกล่าวได้อย่างไร?

81 design  dependency-injection  dependencies 

เมื่อฉันเริ่มเรียนรู้ PHP ครั้งแรก (ประมาณ 5 หรือ 6 ปีก่อน) ฉันเรียนรู้เกี่ยวกับAjaxและฉันผ่าน "ขั้นตอน": เซิร์ฟเวอร์ของคุณส่งคืนข้อมูล HTML และคุณวางไว้ในinnerHTML ของ DOM คุณเรียนรู้เกี่ยวกับรูปแบบการถ่ายโอนข้อมูลเช่น XML (และพูดว่า "oooh นั่นคือสิ่งที่มันใช้สำหรับ") แล้ว JSON คุณส่งคืน JSON และสร้าง UI ของคุณโดยใช้รหัสวานิลลา JavaScript คุณย้ายไปที่ jQuery คุณเรียนรู้เกี่ยวกับ API, ส่วนหัว, รหัสสถานะ HTTP, REST , CORSและBootstrap คุณเรียนรู้SPAและเฟรมเวิร์กส่วนหน้า ( React , Vue.jsและAngularJS ) และมาตรฐาน JSON API คุณได้รับรหัสดั้งเดิมขององค์กรและจากการตรวจสอบพบว่าพวกเขาทำสิ่งที่อธิบายไว้ในขั้นตอนที่ 1 ขณะที่ฉันทำงานกับ …

77 design  ajax 

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

76 design 

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

74 design  object-oriented  javascript  reactjs  upgrade 

เมื่อ Murray Gell-Mann ถูกถามว่า Richard Feynman จัดการเพื่อแก้ไขปัญหาที่ยากมากมายได้อย่างไร Gell-Mann ตอบว่า Feynman มีอัลกอริทึม: จดบันทึกปัญหา คิดหนักจริง เขียนวิธีการแก้ปัญหา Gell-Mann พยายามอธิบายว่า Feynman เป็นนักแก้ปัญหาที่แตกต่างกันและไม่มีความเข้าใจที่จะได้รับจากการศึกษาวิธีการของเขา ฉันรู้สึกแบบเดียวกันกับการจัดการความซับซ้อนในโครงการซอฟต์แวร์ขนาดกลาง / ใหญ่ ผู้คนที่ดีนั้นดีโดยกำเนิดและจัดการกับเลเยอร์และสแต็ค abstractions ต่าง ๆ เพื่อให้ทุกอย่างสามารถจัดการได้โดยไม่ต้องแนะนำ cruft ที่ไม่เกี่ยวข้องใด ๆ ดังนั้นอัลกอริทึมไฟน์แมนเป็นวิธีเดียวที่จะจัดการความซับซ้อนโดยไม่ตั้งใจหรือมีวิธีการที่วิศวกรซอฟต์แวร์สามารถนำไปใช้กับความซับซ้อนที่เกิดขึ้นโดยบังเอิญได้หรือไม่?

74 design  project-management  software  complexity