EP นี้กลับมาอ่าน Chapter 9 ของหนังสือ A Philosophy of Software Design นะครับ เรื่อง Better Together Or Better Apart? ซึ่งให้คำแนะนำว่าถ้าเรามีโค้ดที่เราไม่แน่ใจว่า ควรจะเก็บไว้ด้วยกันหรือแยกมันออกเป็นส่วนย่อยๆ จะดีกว่า เราควรจะดูที่ว่า หากรวมหรือแยกแล้วทำให้ complexity ลดลงหรือไม่ครับ

ไปฟังรายละเอียดใน EP นี้กันครับ

EP นี้ผมชวนไปฟังบทสัมภาษณ์คุณศราวุทธ์ แสงอรุณ Head of Automation Engineering ที่ Krungsri Nimble กันครับ ตอนแรกตั้งใจสัมภาษณ์ให้นักศึกษาวิชา Software Quality Assurance and Testing ที่สอนอยู่ฟัง แต่คิดว่ามีประโยชน์มาก เลยนำมาเผยแพร่ให้ฟังกันทางนี้ด้วยครับ เราคุยกันเรื่อง Software quality, QA roles and skills และ career path ของ QA ครับ

รายละเอียดไปฟังกันใน EP นี้เลยครับ

EP นี้หยิบเอาบทความเรื่อง "Pair Programming: Best Practices and Tools" มาเล่าให้ฟังกันครับ ผมคิดว่า pair programming น่าจะเป็นหลักการที่ยังใช้กันไม่แพร่หลายนักในประเทศไทย แต่มีบริษัทขนาดใหญ่บางบริษัทที่ใช้อยู่เป็นประจำ (เช่น Thoughtworks เท่าที่เคยได้ยิน) ใน EP นี้มาดูกันว่า pair programming คืออะไร มีประโยชน์อย่างไร ความเข้าใจผิดๆ เกี่ยวกับเรื่องนี้มีอย่างไรบ้าง และวิธีการที่จะทำ pair programming ให้ดีมีอะไรบ้างครับ

ไปฟังกันใน EP นี้ได้เลยครับ

บทความ: https://dev.to/documatic/pair-programming-best-practices-and-tools-154j

EP นี้ยังอยู่กับหนังสือ A Philosophy of Software Design ใน Chapter 8 เรื่อง Pull Complexity Downwards กันครับ ผู้เขียนบอกว่าเวลาเราเขียนโมดูลใดๆ แล้วเจอกับจุดที่ยากๆ ต้องตัดสินใจหรือกำหนดค่าใดๆ เราควรจะต้องพยายามที่สุดที่จะจัดการความยากเหล่านั้นภายในโมดูลเอง แทนที่จะโยนออกไปให้คนที่ใช้งานต้องเป็นคนตัดสินใจหรือรับผิดชอบ ซึ่งการทำแบบนี้จะทำให้โมดูลเรา deep ขึ้น แต่ interface มันง่ายลง และใช้งานง่ายขึ้นครับ

รายละเอียดเป็นไง ไปฟังกันใน EP นี้ครับ

EP นี้อ่านหนังสือ A Philosophy of Software Design ใน Chapter 7 เรื่อง Different Layers, Different Abstraction กันครับ ผู้เขียนยกปัญหาอีกเรื่องที่มักพบได้บ่อยในการพัฒนาซอฟต์แวร์ คือ โค้ดที่เขียนในคนละชั้น (layer) ของการทำงาน แต่กลับมี abstraction (ตัวอย่างเช่น รูปแบบลักษณะการทำงาน การมองข้อมูล) ที่เหมือนกัน โดยผู้เขียนแบ่งเป็น 4 รูปแบบ พร้อมแนะนำวิธีการป้องกันหรือแก้ไขปัญหาเหล่านี้มาให้ด้วยครับ

EP นี้หยิบบทความจาก IEEE Software เรื่อง "The Next Frontier in Software Development: AI-Augmented Software Development Processes" มาเล่าให้ฟังกันครับ คุณ Ipek Ozkaya ซึ่งเป็นบรรณาธิการวารสาร IEEE Software ได้ให้ความเห็นว่าการทำงานที่เป็น AI-Augmented Software Development หรือมีเครื่องมือ AI มาช่วยในการพัฒนาซอฟต์แวร์นั้น อาจจะยังไม่ใช่จุดเปลี่ยนสำคัญ เพราะเครื่องมือเหล่านี้มีมาอย่างต่อเนื่องยาวนานก่อนยุคของ LLMs เช่น ChatGPT หรือ GitHub Copilot แต่ต้องเป็นการเปลี่ยนแปลงกระบวนการพัฒนาซอฟต์แวร์ (software development process) จึงจะทำให้มีการเปลี่ยนแปลงขนาดใหญ่ (ระดับ X10 ได้จริงๆ ครับ)

รายละเอียดเป็นอย่างไร ไปฟังกันใน EP นี้ครับ

บทความ: https://www.computer.org/csdl/magazine/so/2023/04/10176194/1OAJtH6yQak

EP นี้พามาอ่าน Chapter 6 General-Purpose Modules are Deeper ในหนังสือ A Philosophy of Software Design กันครับ ในบทนี้ผู้เขียนพยายามโน้วน้ามให้เห็นว่า เรามักจะชินกับการเขียนโมดูล คลาส หรือ เมธอด ที่ specific หรือ specialized มากๆ (ซึ่งบางทีอาจเกิดขึ้นโดยไม่รู้ตัว) แต่จริงๆ แล้วการพยายามทำให้โมดูล/คลาส/เมธอด เหล่านั้นทำงานได้กว้างขึ้น หลากหลายขึ้น หรือที่หนังสือเรียกว่า general-purpose นั้น จะทำให้เกิด information hiding ได้มากขึ้น ใช้งานได้หลากหลายขึ้น และลด cognitive load ของคนอ่านโค้ดลงได้มากกว่าครับ

ไปฟังเนื้อหากันใน EP นี้ครับ

EP นี้เป็นเรื่องต่อเนื่องจาก EP ที่แล้วครับ วิธีการหนึ่งที่เราสามารถลดความซับซ้อนของโค้ดตามหลักการ deep module - simple interface ก็คือการทำ information hiding หรือ การซ่อนข้อมูลไว้ในโมดูล นั่นเอง เช่น หากมีการทำงานที่ต้องทำต่อเนื่องกันหลายๆ ขั้นตอน เราก็ไม่ควรแยกขั้นตอนเหล่านั้นออกมาเป็นหลายโมดูล เพราะจะทำให้โมดูลเหล่านั้นมี dependency กัน และใช้งานยากขึ้น เป็นต้น

มาฟังรายละเอียดทั้งหมดใน EP นี้ครับ

EP นี้เป็น EP พิเศษครับ เพราะเป็น EP ที่ผมทำ Podcast นี้ครบ 2 ปีพอดี! วันนี้พามาอ่านหนังสือ A Philosophy of Software Design กันต่อใน Chapter 4 เรื่อง Modules Should be Deep ซึ่งอธิบายให้เห็นว่า เราควรออกแบบโมดูลในซอฟต์แวร์ให้มี interface ที่เข้าใจง่ายแต่ซ่อน implementation ที่ซับซ้อนไว้ด้านใน ซึ่งจะเรียกว่า "deep modules" ข้อดีของ deep modules คือการซ่อนความซับซ้อน ทำให้ผู้ใช้งานโมดูลของเรา (โปรแกรมเมอร์คนอื่น) และการดูแลรักษาซอฟต์แวร์ ทำได้ง่ายมากขึ้น

รายละเอียดจะเป็นอย่างไร ไปฟังกันใน EP นี้ครับ

EP นี้หยิบเรื่อง cognitive load ของ developer มาคุยกันครับ (ขอบคุณคุณเบน (https://blog.coursesquare.co/author/ben/) ที่แนะนำบทความนะครับ) โค้ดที่ดีคือโค้ดที่มี cognitive load ต่ำๆ เพราะทำให้คนมาอ่าน เข้าใจ และดูแล​ โค้ดเราต่อได้ง่ายๆ แต่การทำให้โค้ดมี cognitive load ต่ำๆ ไม่ใช่เรื่องง่ายเท่าไหร่ครับ ใน EP นี้เรามาดูกันว่าวิธีที่ลด cognitive load ของโค้ด มีอะไรบ้าง

ไปฟังกันใน EP นี้เลยครับ

บทความ: https://github.com/zakirullin/cognitive-load