การพัฒนาซอฟต์แวร์มีปัญหาที่น่าสงสัย แม้จะมีหลักการ KISS (Keep It Simple, Stupid) ที่เป็นที่รู้จักกันดี แต่นักพัฒนามักเลือกใช้แนวทางที่ซับซ้อนแทนที่จะใช้วิธีง่าย ๆ ที่ใช้งานได้ดีเหมือนกัน แนวโน้มนี้ได้จุดประกายการถกเถียงอย่างรุนแรงในชุมชนเทคโนโลยี โดยหลายคนตั้งคำถามว่าความหลงใหลในความซับซ้อนของเรานั้นช่วยหรือทำร้ายอุตสาหกรรมนี้
การตลาดทำให้ความซับซ้อนดูน่าสนใจ
อุตสาหกรรมเทคโนโลยีได้เปลี่ยนความซับซ้อนให้กลายเป็นจุดขาย เครื่องมือง่าย ๆ เช่นคำสั่ง cat พื้นฐานในระบบ Unix ทำงานได้อย่างสมบูรณ์แบบตามวัตถุประสงค์ที่ตั้งไว้ แต่กลับยากที่จะนำมาทำการตลาด บริษัทต่าง ๆ ต้องการฟีเจอร์เพื่อโฆษณา การประชุมเพื่อส่งเสริม และคำศัพท์เทคนิคเพื่อสร้างความตื่นเต้น แนวทางง่าย ๆ ไม่สามารถสร้างกระแสการตลาดเหมือนกับเฟรมเวิร์กที่เต็มไปด้วยฟีเจอร์และมีระบบนิเวศของตัวเอง
แนวทางที่ขับเคลื่อนด้วยการตลาดนี้ส่งผลต่อวิธีคิดของนักพัฒนาเกี่ยวกับงานของพวกเขา ระบบที่ซับซ้อนเป็นสัญลักษณ์ของความเชี่ยวชาญและนวัตกรรม ทำให้นักพัฒนารู้สึกเหมือนกำลังทำงานในสิ่งที่สำคัญ การสนทนาในชุมชนเผยให้เห็นว่าสิ่งนี้สร้างวงจรที่ความซับซ้อนกลายเป็นสัญลักษณ์แห่งสถานะมากกว่าความจำเป็น
ปัจจัยหลักที่ทำให้ซอฟต์แวร์มีความซับซ้อน:
- แรงกดดันจากการตลาดในการเพิ่มฟีเจอร์และสร้างความแตกต่างให้กับผลิตภัณฑ์
- พลวัตของทีมที่ต้องการ abstraction แบบ "future-proof"
- ข้อจำกัดของระบบเก่าที่บังคับให้ต้องแก้ไขแบบชั่วคราวแทนการสร้างใหม่
- ความพึงพอใจในการสร้างสรรค์จากการแก้ปัญหาที่ซับซ้อน
- การแสดงสถานะผ่านโซลูชันทางเทคนิคที่ซับซ้อน
- ข้อจำกัดด้านเวลา/งงบประมาณที่ทำให้ต้องเลือกการแก้ไขแบบเร็วแทนโซลูชันที่สวยงาม
การถกเถียงระหว่าง React กับ Vanilla JavaScript
หนึ่งในตัวอย่างที่ถกเถียงกันมากที่สุดในการสนทนาของชุมชนคือการเปรียบเทียบระหว่าง React กับ JavaScript ธรรมดา React นำเสนอแนวคิดต่าง ๆ เช่น rendering models, hooks, state libraries และ build pipelines ซึ่งเป็นภาระทางจิตใจที่มากสำหรับนักพัฒนาที่ต้องจัดการ นักวิจารณ์โต้แย้งว่าการใช้ vanilla JavaScript ตามที่จำเป็นมักให้แนวทางที่ง่ายกว่า
อย่างไรก็ตาม ชุมชนได้โต้แย้งมุมมองนี้ นักพัฒนาหลายคนชี้ให้เห็นว่าการใช้ vanilla JavaScript เล็กน้อยนั้นกลายเป็นโค้ดเบสที่ซับซ้อนและยุ่งเหยิงอย่างรวดเร็ว ซึ่งยากต่อการดูแลรักษามากกว่าเฟรมเวิร์กที่มีโครงสร้าง ความจริงคือทั้งสองแนวทางมีที่ของมัน แต่แรงกดดันในการใช้เฟรมเวิร์กที่เป็นกระแสบางครั้งนำไปสู่การใช้มากเกินไปสำหรับโปรเจกต์ง่าย ๆ
ข้อดีข้อเสียของ React เทียบกับ Vanilla JavaScript:
| แนวทาง | ข้อดี | ข้อเสีย |
|---|---|---|
| React Framework | ระบบคอมโพเนนต์ที่มีโครงสร้าง รูปแบบที่ได้รับการยอมรับ การทำงานร่วมกันในทีม | เส้นโค้งการเรียนรู้ ความซับซ้อนในการ build อาจใช้มากเกินความจำเป็น |
| Vanilla JavaScript | ควบคุมได้โดยตรง โอเวอร์เฮดน้อยที่สุด เรียบง่ายสำหรับงานพื้นฐาน | อาจยุ่งเหยิงเมื่อขยายขนาด ต้องจัดการสถานะด้วยตนเองมากขึ้น |
จิตวิทยาเบื้องหลังการติดความซับซ้อน
ปัจจัยทางจิตวิทยาหลายประการผลักดันให้นักพัฒนาไปสู่แนวทางที่ซับซ้อน ความท้าทายเชิงสร้างสรรค์ในการสร้างระบบที่ซับซ้อนให้ความพึงพอใจทางปัญญา เหมือนกับการแก้ปริศนาที่ยิ่งใหญ่ นอกจากนี้ยังมีการหลั่งสาร dopamine จากช่วงเวลา eureka! เมื่อโค้ดที่ซับซ้อนในที่สุดก็ทำงานได้
ซอฟต์แวร์มีหลักการ Peter Principle หากโค้ดส่วนหนึ่งเข้าใจได้ จะมีคนขยายมันเพื่อใช้กับปัญหาของตัวเอง หากเข้าใจไม่ได้ พวกเขาจะเขียนโค้ดของตัวเองแทน โค้ดมีแนวโน้มที่จะถูกขยายไปจนถึงระดับที่เข้าใจไม่ได้
พลวัตของทีมก็มีบทบาทเช่นกัน ในองค์กรขนาดใหญ่ นักพัฒนาเพิ่มชั้นของการทำนายเพื่อทำให้โค้ดพร้อมสำหรับอนาคตหรือรองรับข้อกำหนดที่แตกต่างกัน สมาชิกในทีมแต่ละคนเพิ่มลายเซ็นของตัวเองลงในโค้ดเบส สร้างระบบที่ไม่มีใครเข้าใจอย่างสมบูรณ์
ต้นทุนของความซับซ้อน
การสนทนาในชุมชนเผยให้เห็นว่าความซับซ้อนมักเกิดจากข้อจำกัดในทางปฏิบัติมากกว่าอีโก้ของนักพัฒนา ระบบเก่าและหนี้ทางเทคนิคบังคับให้นักพัฒนาเพิ่มแพตช์แทนที่จะสร้างใหม่ตั้งแต่ต้น แรงกดดันด้านเวลาและงบประมาณทำให้การแก้ไขด่วนดูน่าสนใจกว่าแนวทางที่สง่างาม
ไม่เหมือนสาขาวิศวกรรมอื่น ๆ ที่ความซับซ้อนส่งผลโดยตรงต่อต้นทุนและความน่าเชื่อถือ ความซับซ้อนของซอฟต์แวร์มักซ่อนอยู่จากผู้ใช้งาน อัลกอริทึมที่ช้าอาจเพิ่มเวลาตอบสนองเป็นมิลลิวินาทีโดยไม่มีใครสังเกตเห็น ในขณะที่ผลิตภัณฑ์ทางกายภาพที่มีส่วนประกอบที่ไม่จำเป็นจะเห็นได้ชัดว่าเป็นการสิ้นเปลือง
การหาสมดุลที่เหมาะสม
แนวทางแก้ไขไม่ใช่การหลีกเลี่ยงความซับซ้อนทั้งหมด แต่เป็นการให้แน่ใจว่ามันมีจุดประสงค์ที่แท้จริง ระบบง่าย ๆ ทำงานได้ดีสำหรับปัญหาที่ตรงไปตรงมา แต่ความท้าทายที่ซับซ้อนมักต้องการเครื่องมือที่ซับซ้อน สิ่งสำคัญคือการจับคู่แนวทางแก้ไขกับปัญหาที่แท้จริงแทนที่จะเลือกเครื่องมือตามความนิยมหรือความน่าสนใจทางการตลาด
เมื่ออุตสาหกรรมซอฟต์แวร์เติบโตขึ้น นักพัฒนาเริ่มตระหนักถึงต้นทุนที่แท้จริงของความซับซ้อนที่ไม่จำเป็น โปรเจกต์ที่ประสบความสำเร็จมากที่สุดมักรวมเครื่องมือที่ทรงพลังเข้ากับอินเทอร์เฟซที่ง่ายและชัดเจน ซ่อนความซับซ้อนจากผู้ใช้ในขณะที่ให้ฟังก์ชันการทำงานที่พวกเขาต้องการ
การถกเถียงเรื่องความซับซ้อนในการพัฒนาซอฟต์แวร์สะท้อนคำถามที่กว้างขึ้นเกี่ยวกับวิธีที่เราสร้างและดูแลรักษาระบบดิจิทัล แม้ว่าความซับซ้อนจะเป็นส่วนหนึ่งของการพัฒนาซอฟต์แวร์เสมอ แต่ชุมชนกำลังให้ความสำคัญมากขึ้นกับการให้แน่ใจว่าความซับซ้อนนั้นให้บริการผู้ใช้มากกว่าการตอบสนองอีโก้ของนักพัฒนาเท่านั้น