ฉันหวังว่านี่ไม่ใช่คำถามทั่วไปเกินไป ฉันสามารถใช้คำแนะนำที่ปรุงรสได้จริงๆ

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

พวกเขาขอให้ฉันเริ่มนำเสนอหลักการบางประการของการพัฒนาซอฟต์แวร์ที่ทันสมัยให้กับทีม พวกเขาต้องการให้ฉันแนะนำวิธีปฏิบัติและกลยุทธ์มาตรฐานอุตสาหกรรมบางประการเกี่ยวกับข้อกำหนดการเข้ารหัสการจัดการวงจรชีวิตรูปแบบการออกแบบระดับสูงและการควบคุมแหล่งที่มา ตรงไปตรงมามันเป็นงานที่ค่อนข้างน่ากลัวและฉันไม่แน่ใจว่าจะเริ่มต้นที่ไหน

ในตอนแรกฉันมีแนวโน้มที่จะสอนพวกเขาในบางแนวคิดหลักของThe Pragmatic ProgrammerหรือRefactoringของ Fowler ("Code Smells" ฯลฯ ) ฉันหวังว่าจะแนะนำวิธีการแบบ Agile จำนวนมาก แต่ท้ายที่สุดเพื่อให้มีประสิทธิภาพฉันคิดว่าฉันจะต้องฝึกฝนพื้นฐาน 5-7 หลัก กล่าวอีกนัยหนึ่งอะไรคือหลักการหรือวิธีปฏิบัติที่สำคัญที่สุดที่พวกเขาสามารถเริ่มใช้งานได้อย่างแนบเนียน

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

คำนำ

นี่เป็นงานที่น่ากลัวอย่างแน่นอนและมีพื้นที่มากมายที่จะครอบคลุม ดังนั้นฉันจึงแนะนำอย่างนอบน้อมว่านี่เป็นแนวทางที่ครอบคลุมสำหรับทีมของคุณด้วยตัวชี้ไปยังเครื่องมือที่เหมาะสมและสื่อการเรียนรู้

ข้อควรจำ: สิ่งเหล่านี้เป็นแนวทางและมีความตั้งใจที่จะนำมาปรับใช้หรือลดลงตามสถานการณ์

ระวัง:การทิ้งข้อมูลทั้งหมดนี้ไว้ในทีมในครั้งเดียวน่าจะล้มเหลวมากที่สุด คุณควรพยายามที่จะเลือกองค์ประกอบเชอร์รี่ที่จะช่วยให้คุณได้เหงื่อที่ดีที่สุดและแนะนำพวกเขาอย่างช้าๆทีละครั้ง

หมายเหตุ:ไม่ใช่ทั้งหมดนี้ใช้โดยตรงกับระบบการเขียนโปรแกรมภาพเช่น G2 สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับวิธีจัดการกับสิ่งเหล่านี้ให้ดูที่ส่วนท้ายที่ท้าย

บทสรุปผู้บริหารสำหรับคนใจร้อน

• กำหนดโครงสร้างโครงการที่เข้มงวดด้วย:
  • โครงการแม่แบบ ,
  • การประชุมการเข้ารหัส ,
  • คุ้นเคยระบบสร้าง ,
  • และชุดแนวทางการใช้งานสำหรับโครงสร้างพื้นฐานและเครื่องมือของคุณ
• ติดตั้งSCMที่ดีและตรวจสอบให้แน่ใจว่าพวกเขารู้วิธีใช้
• ชี้ไปที่IDEsที่ดีสำหรับเทคโนโลยีของพวกเขาและตรวจสอบให้แน่ใจว่าพวกเขารู้วิธีใช้พวกเขา
• ใช้เครื่องตรวจสอบคุณภาพรหัสและการรายงานอัตโนมัติในระบบบิลด์
• เชื่อมโยงระบบการสร้างเข้ากับการรวมอย่างต่อเนื่องและระบบการตรวจสอบอย่างต่อเนื่อง
• ด้วยความช่วยเหลือของดังกล่าวข้างต้นระบุคุณภาพรหัส "ฮอตสปอต"และrefactor

ตอนนี้สำหรับรุ่นยาว ... โปรดระวังตัวเอง!

ความแข็งแกร่ง (บ่อยครั้ง) ดี

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

ความแข็งแกร่ง = กระบวนการ / ขั้นตอน

การพัฒนาซอฟต์แวร์ต้องการกระบวนการและขั้นตอนที่ดีด้วยเหตุผลเดียวกันกับที่โรงงานเคมีหรือโรงงานมีคู่มือขั้นตอนการฝึกซ้อมและแนวทางฉุกเฉิน: การป้องกันผลลัพธ์ที่ไม่ดีการคาดการณ์ที่เพิ่มขึ้นเพิ่มผลผลิตสูงสุด ...

ความแข็งแกร่งมาในการดูแล แต่!

ความแข็งแกร่งของโครงสร้างโครงการ

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

ความแข็งแกร่งของระบบ Build

ถ้าแต่ละโครงการมีลักษณะที่แตกต่างกันมีโอกาสที่ดีที่พวกเขายัง สร้างความแตกต่าง งานสร้างไม่ควรต้องการการวิจัยมากเกินไปหรือการคาดเดามากเกินไป คุณต้องการที่จะสามารถที่จะทำในสิ่งที่เป็นที่ยอมรับและไม่จำเป็นต้องกังวลเกี่ยวกับข้อมูลเฉพาะ: configure; make install, ant, mvn installฯลฯ ...

การนำระบบบิลด์เดียวกันกลับมาใช้ใหม่และทำให้มีการพัฒนาตลอดเวลายังช่วยให้มั่นใจในระดับคุณภาพที่สอดคล้องกัน

คุณต้องมีความรวดเร็วREADMEในการชี้เฉพาะโครงการและให้คำแนะนำผู้ใช้ / นักพัฒนา / นักวิจัยอย่างสง่างามหากมี

นอกจากนี้ยังช่วยอำนวยความสะดวกในส่วนอื่น ๆ ของโครงสร้างพื้นฐานการสร้างของคุณเช่น:

• บูรณาการอย่างต่อเนื่อง ,
• การตรวจสอบอย่างต่อเนื่อง

ดังนั้นโปรดสร้างงานของคุณ (เช่นโครงการของคุณ) ให้ทันสมัย ​​แต่ทำให้เข้มงวดขึ้นเมื่อเวลาผ่านไปและมีประสิทธิภาพมากขึ้นในการรายงานการละเมิดและการปฏิบัติที่ไม่ดี

อย่าบูรณาการล้อและนำสิ่งที่คุณได้ทำไปแล้ว

อ่านหนังสือที่แนะนำ:

• การรวมอย่างต่อเนื่อง: การปรับปรุงคุณภาพซอฟต์แวร์และลดความเสี่ยง (Duval, Matyas, Glover, 2007)
• การส่งมอบอย่างต่อเนื่อง: ปล่อย Sotware ออกสู่ตลาดผ่าน Build, Test และ Deployment Automation (Humble, Farley, 2010)

ความแข็งแกร่งในการเลือกภาษาโปรแกรม

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

ทำให้สแต็คเทคโนโลยีของคุณง่ายและการบำรุงรักษาและทักษะที่จำเป็นให้กว้างที่สุด: แกนกลางที่แข็งแกร่ง

ความเข้มงวดของอนุสัญญาและแนวทางการเข้ารหัส

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

กฎไร้สาระที่ทำให้ชีวิตยากขึ้นหรือห้ามการกระทำที่ชัดเจนในขอบเขตที่การกระทำที่ถูกปฏิเสธโดยอาศัยการละเมิดเพียงครั้งเดียวเป็นภาระ อย่างไรก็ตาม:

• กฎพื้นฐานที่คิดมาอย่างดีจะเอาเสียงหอนและความคิดออกไปมากมาย: ไม่มีใครควรแตกภายใต้สถานการณ์ใด

• และชุดของกฎที่แนะนำให้คำแนะนำเพิ่มเติม

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

บางภาษาบังคับใช้สิ่งนี้ด้วยการออกแบบ:

• Java มีวัตถุประสงค์เพื่อลดจำนวนของอึที่น่าเบื่อที่คุณสามารถเขียนได้ (แม้ว่าจะไม่ต้องสงสัยเลยว่าหลายคนสามารถทำได้)

• โครงสร้างบล็อกของ Python โดยการเยื้องเป็นอีกแนวคิดหนึ่งในแง่นี้

• ไปด้วยgofmtเครื่องมือที่จะนำการอภิปรายและความพยายาม ( และอัตตา !! ) ออกไปโดยสิ้นเชิงกับสไตล์: วิ่งgofmtก่อนที่คุณจะกระทำ

ตรวจสอบให้แน่ใจว่ารหัสเน่าไม่สามารถผ่านได้ การประชุมรหัส , บูรณาการอย่างต่อเนื่องและการตรวจสอบอย่างต่อเนื่อง , การเขียนโปรแกรมคู่และตรวจสอบรหัสเป็นคลังแสงของคุณกับปีศาจนี้

นอกจากนี้ตามที่คุณเห็นด้านล่างรหัสคือเอกสารประกอบและเป็นอีกพื้นที่หนึ่งที่อนุสัญญาส่งเสริมการอ่านและความชัดเจน

ความแข็งแกร่งของเอกสาร

เอกสารประกอบไปด้วยรหัส รหัสตัวเองเป็นเอกสาร แต่จะต้องมีคำแนะนำที่ชัดเจนเกี่ยวกับวิธีการสร้างใช้และบำรุงรักษาสิ่งต่าง ๆ

การใช้จุดควบคุมเดียวสำหรับเอกสารประกอบ (เช่น WikiWiki หรือ DMS) เป็นสิ่งที่ดี สร้างช่องว่างสำหรับโครงการช่องว่างสำหรับการสุ่มและการทดลองเพิ่มเติม ให้ช่องว่างทั้งหมดนำกฎและระเบียบทั่วไปกลับมาใช้ซ้ำ พยายามทำให้มันเป็นส่วนหนึ่งของจิตวิญญาณของทีม

คำแนะนำส่วนใหญ่ที่ใช้กับรหัสและเครื่องมือก็ใช้กับเอกสารประกอบ

ความแข็งแกร่งในความคิดเห็นของรหัส

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

ความแข็งแกร่งในบันทึกการกระทำ

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

มีการผูกมัดด้วยเหตุผลและเหตุผลนั้น ISN'T ไม่ได้แสดงอย่างชัดเจนโดยรหัสของคุณและบันทึกการคอมมิทบรรทัดเดียวที่คุณป้อน มีมากกว่านั้น

บรรทัดของรหัสแต่ละคนมีเรื่องราวและประวัติศาสตร์ ความแตกต่างสามารถบอกเล่าประวัติของมันได้ แต่คุณต้องเขียนเรื่องราวของมัน

เหตุใดฉันจึงอัปเดตบรรทัดนี้ -> เนื่องจากอินเทอร์เฟซเปลี่ยนไป

ทำไมอินเทอร์เฟซเปลี่ยน? -> เนื่องจากไลบรารี่ L1 กำลังกำหนดว่าอัปเดตแล้ว

เหตุใดจึงมีการอัปเดตห้องสมุด -> เนื่องจากไลบรารี่ L2 นั้นเราต้องการฟีเจอร์ F ขึ้นอยู่กับไลบรารี่ L1

และฟีเจอร์ X คืออะไร? -> ดูภารกิจ 3456 ในตัวติดตามปัญหา

มันไม่ใช่ตัวเลือก SCM ของฉันและอาจไม่ใช่สิ่งที่ดีที่สุดสำหรับห้องปฏิบัติการของคุณเช่นกัน แต่Gitได้รับสิทธินี้และพยายามที่จะบังคับให้คุณเขียนบันทึกที่ดีกว่ามากที่สุดระบบ SCMs อื่น ๆ โดยใช้และshort logs long logsเชื่อมโยง ID งาน (ใช่คุณจำเป็นต้องใช้) และปล่อยให้สรุปทั่วไปสำหรับshortlogและขยายในบันทึกยาว: เขียนเซ็ตของเรื่อง

เป็นบันทึก:มีไว้ที่นี่เพื่อติดตามและบันทึกการอัปเดต

Rule of Thumb:หากคุณกำลังค้นหาบางอย่างเกี่ยวกับการเปลี่ยนแปลงนี้ในภายหลังมีแนวโน้มที่จะตอบคำถามของคุณหรือไม่

โครงการเอกสารและรหัสยังมีชีวิตอยู่

ทำให้พวกเขาซิงค์มิฉะนั้นพวกเขาจะไม่สร้างเอนทิตี้ของ symbiotic นั้นอีกต่อไป มันทำงานได้อย่างมหัศจรรย์เมื่อคุณ:

• ล้างคอมมิทบันทึกใน SCM ของคุณพร้อมลิงค์ไปยัง ID งานในตัวติดตามปัญหาของคุณ
• ที่ตัวตั๋วของผู้ติดตามตัวนี้เชื่อมโยงกับการเปลี่ยนแปลงใน SCM ของคุณ (และอาจเป็นไปได้กับการสร้างในระบบ CI ของคุณ)
• และระบบเอกสารที่เชื่อมโยงไปยังสิ่งเหล่านี้ทั้งหมด

รหัสและเอกสารจะต้องเหนียว

ความแข็งแกร่งในการทดสอบ

กฎของ Thumb:

• รหัสใหม่ใด ๆ จะมาพร้อมกับการทดสอบหน่วย (อย่างน้อย)
• รหัสมรดกที่ได้รับการปรับสภาพใหม่จะมาพร้อมกับการทดสอบหน่วย

แน่นอนความต้องการเหล่านี้:

• เพื่อทดสอบสิ่งที่มีค่า (หรือเสียเวลาและพลังงาน)
• ที่จะเขียนดีและแสดงความคิดเห็น (เช่นเดียวกับรหัสอื่น ๆ ที่คุณเช็คอิน)

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

แน่นอนคุณควรไปต่อและมีการทดสอบการรวมและ การทดสอบการถดถอยสำหรับแต่ละข้อผิดพลาดที่คุณทำซ้ำได้

ความแข็งแกร่งในการใช้งานของเครื่องมือ

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

นอกเหนือจากนั้นให้สมาชิกใช้สิ่งที่พวกเขาต้องการตราบใดที่พวกเขาทั้งหมด:

• การผลิต ,
• ไม่ต้องการความช่วยเหลือเป็นประจำ
• ไม่สม่ำเสมอการปรับโครงสร้างพื้นฐานโดยทั่วไปของคุณ ,
• ไม่รบกวนโครงสร้างพื้นฐานของคุณ (โดยการแก้ไขพื้นที่ทั่วไปเช่นรหัสระบบการสร้างเอกสาร ... )
• ไม่ส่งผลกระทบต่อการทำงานของคนอื่น ,
• สามารถที่จะทันเวลาการดำเนินการใด ๆ ที่ได้รับการร้องขอ

หากไม่ใช่ในกรณีนี้ให้บังคับใช้ว่าพวกเขากลับเป็นค่าเริ่มต้น

ความแข็งแกร่งเทียบกับความคล่องตัวการปรับตัวการสร้างต้นแบบและกรณีฉุกเฉิน

ความยืดหยุ่นสามารถทำได้ดี ให้คนบางครั้งใช้สับเป็นวิธีที่รวดเร็ว-N-สกปรกหรือเครื่องมือที่ชื่นชอบสัตว์เลี้ยงที่จะได้งานทำ ดี ไม่เคยปล่อยให้มันกลายเป็นนิสัยและไม่เคยปล่อยให้รหัสนี้กลายเป็น codebase ที่เกิดขึ้นจริงที่จะสนับสนุน

Team Spirit Matters

พัฒนาสำนึกใน Codebase ของคุณ

• พัฒนาความรู้สึกภาคภูมิใจในรหัส
  • ใช้แผ่นผนัง
    • กระดานผู้นำสำหรับเกมบูรณาการอย่างต่อเนื่อง
    • wallboards สำหรับการจัดการปัญหาและการนับข้อบกพร่อง
  • ใช้ติดตามปัญหา / บั๊ก

หลีกเลี่ยงเกมตำหนิ

• ห้ามใช้บูรณาการ / เกมการตรวจสอบอย่างต่อเนื่องต่อเนื่อง: มันส่งเสริมที่ดีมีมารยาทและการแข่งขันการผลิต
• ติดตามข้อบกพร่อง: มันเป็นเพียงการดูแลที่ดี
• ทำการระบุสาเหตุที่แท้จริง: มันเป็นเพียงกระบวนการพิสูจน์อักษรในอนาคต
• แต่ไม่ได้กำหนดความผิด : มันเป็นเคาน์เตอร์ที่มีประสิทธิผล

มันเกี่ยวกับรหัสไม่ใช่เกี่ยวกับผู้พัฒนา

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

เป็นความขัดแย้ง: คุณต้องส่งเสริมการเขียนโปรแกรม ego-lessสำหรับสถานที่ทำงานที่มีสุขภาพดี แต่ต้องพึ่งพา ego เพื่อจุดประสงค์ในการสร้างแรงบันดาลใจ

จากนักวิทยาศาสตร์ถึงโปรแกรมเมอร์

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

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

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

การบำรุงรักษารหัสเป็นส่วนหนึ่งของงานวิจัย

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

ทำให้ชัดเจนว่าการปรับโครงสร้างโค้ดให้คงที่และการรีเฟรชคงที่จะป้องกันโค้ดเน่าและลดหนี้ทางเทคนิคและอำนวยความสะดวกในการใช้งานในอนาคตและการปรับตัวของงานสำหรับโครงการอื่น ๆ

ทำไมทั้งหมดนี้ ??!

ทำไมเราถึงต้องกังวลกับสิ่งต่าง ๆ ข้างต้น? สำหรับคุณภาพรหัส หรือว่าเป็น รหัสคุณภาพ ...

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

คุณจะรู้ได้อย่างไรว่าเป้าหมายอยู่ใกล้แค่เอื้อม

คุณภาพสามารถวัดได้

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

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

แต่ถ้ารหัสของฉันเสียแล้ว

จากทั้งหมดที่กล่าวมาเป็นเรื่องสนุกและน่ารักเหมือนการไปเที่ยว Never Land แต่มันไม่ใช่เรื่องง่ายที่จะทำเมื่อคุณมีโค้ดอึ (กองไอน้ำและมีกลิ่นเหม็น) อยู่แล้วและทีมลังเลที่จะเปลี่ยนแปลง

นี่คือความลับ: คุณจำเป็นต้องเริ่มที่ไหนสักแห่ง

เรื่องส่วนตัว:ในโครงการเราทำงานร่วมกับ codebase ที่มีน้ำหนักตั้งแต่ 650,000+ Java LOC, มากกว่า 200,000 บรรทัดของ JSPs, 40,000+ JavaScript LOC และ 400+ MBs ของการพึ่งพาไบนารี

หลังจากผ่านไปประมาณ 18 เดือนมี 500,000 Java LOC (MOSTLY CLEAN) , JSPs 150,000 บรรทัด, และ 38,000 JavaScript LOC โดยมีการอ้างอิงลงไปจนถึง 100MB แทบจะไม่ (และสิ่งเหล่านี้ไม่ได้อยู่ใน SCM ของเราอีกต่อไป!)

พวกเราทำได้อย่างไร เราทำทุกอย่างที่กล่าวมา หรือพยายามอย่างหนัก

มันเป็นความพยายามของทีม แต่เราค่อยๆฉีดกฎระเบียบและเครื่องมือในการตรวจสอบอัตราการเต้นของหัวใจของผลิตภัณฑ์ของเราอย่างช้า ๆขณะที่ "ลดไขมัน" อย่างเร่งรีบ: รหัสอึการพึ่งพาที่ไร้ประโยชน์ ... เราไม่ได้หยุดพัฒนาทั้งหมด ทำสิ่งนี้: เรามีช่วงเวลาแห่งความสงบและสัมพัทธ์เป็นครั้งคราวซึ่งเรามีอิสระที่จะคลั่งไคล้ codebase และฉีกมันออกเป็นส่วนใหญ่ แต่ส่วนใหญ่เราทำทั้งหมดโดยการเริ่มต้นโหมด "การทบทวนและ refactor" ทุกโอกาสที่เราได้รับ : ในระหว่างการสร้าง, ในระหว่างอาหารกลางวัน, ในระหว่างการแก้ไขข้อผิดพลาดในช่วงบ่ายวันศุกร์ ...

มี "งาน" ที่ยิ่งใหญ่บางส่วน ... การเปลี่ยนระบบการสร้างของเราจาก Ant build ยักษ์ของ 8500+ XML LOC เป็น Maven build แบบโมดูลที่หลากหลายเป็นหนึ่งในนั้น จากนั้นเราได้:

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

อีกอย่างคือการฉีด "เครื่องมือสายพาน - เครื่องมือ" แม้ว่าเราจะพยายามลดการพึ่งพา: Google Guava และ Apache Commons ลดขนาดโค้ดของคุณลงและลดพื้นผิวสำหรับข้อบกพร่องในรหัสของคุณเป็นจำนวนมาก

นอกจากนี้เรายังชักชวนแผนกไอทีของเราที่อาจใช้เครื่องมือใหม่ของเรา (JIRA, Fisheye, Crucible, Confluence, Jenkins) ได้ดีกว่าที่ใช้อยู่ เรายังคงต้องจัดการกับบางอย่างที่เราดูถูก (QC, Sharepoint และ SupportWorks ... ) แต่มันเป็นประสบการณ์ที่ได้รับการปรับปรุงโดยรวมโดยที่เหลืออีกห้อง

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

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

วงจรการสร้างโค้ดสปาเก็ตตี้ที่เพิ่มขึ้นอย่างลับสุดยอดเพื่อคุณภาพที่ยอดเยี่ยม

       +-----------------+      +-----------------+
       |  A N A L Y Z E  +----->| I D E N T I F Y |
       +-----------------+      +---------+-------+
                ^                           |
                |                           v
       +--------+--------+      +-----------------+
       |    C L E A N    +<-----|      F I X      |
       +-----------------+      +-----------------+

เมื่อคุณมีเครื่องมือที่มีคุณภาพที่ toolbelt ของคุณ:

1. วิเคราะห์รหัสของคุณด้วยเครื่องมือตรวจสอบคุณภาพรหัส

   Linters, ตัววิเคราะห์แบบสแตติกหรืออะไรที่มีคุณ

2. ระบุของคุณที่สำคัญฮอตสปอตและผลไม้แขวนต่ำ

   การละเมิดมีระดับความรุนแรงและคลาสขนาดใหญ่ที่มีระดับความรุนแรงสูงเป็นธงสีแดงขนาดใหญ่เช่นนี้จะปรากฏเป็น "ฮอตสปอต" ในมุมมองประเภทหม้อน้ำ / ฮีทแมป

3. แก้ไขฮอตสปอตก่อน

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

4. ทำความสะอาดการละเมิดในระดับต่ำที่มีเรตติ้ง codebase อัตโนมัติ

   ปรับปรุงอัตราส่วนสัญญาณต่อเสียงรบกวนเพื่อให้คุณสามารถเห็นการละเมิดที่สำคัญในเรดาร์ของคุณตามที่ปรากฏ บ่อยครั้งที่มีกองทัพขนาดใหญ่ที่มีการละเมิดเล็กน้อยในตอนแรกหากพวกเขาไม่เคยได้รับการดูแลและ codebase ของคุณถูกปล่อยให้เป็นอิสระ พวกเขาไม่ได้แสดง "ความเสี่ยง" ที่แท้จริง แต่จะทำให้การอ่านและการบำรุงรักษาของรหัสนั้นด้อยลง แก้ไขพวกเขาในขณะที่คุณพบพวกเขาในขณะที่ทำงานหรือโดยการทำความสะอาดเควสขนาดใหญ่ที่มีรหัสอัตโนมัติกวาดถ้าเป็นไปได้ ระวังการกวาดอัตโนมัติขนาดใหญ่ถ้าคุณไม่มีชุดทดสอบและระบบการรวมที่ดี ตรวจสอบให้แน่ใจว่าเห็นด้วยกับเพื่อนร่วมงานในเวลาที่เหมาะสมเพื่อเรียกใช้พวกเขาเพื่อลดความรำคาญ

5. ทำซ้ำจนกว่าคุณจะพอใจ

   หากคุณยังคงใช้งานผลิตภัณฑ์นี้อยู่จะเป็นการพัฒนาอย่างต่อเนื่อง

เคล็ดลับง่ายๆสำหรับการดูแลบ้านที่ดี

• เมื่ออยู่ในโหมดแก้ไขด่วนตามคำขอการสนับสนุนลูกค้า:

  • เป็นวิธีปฏิบัติที่ดีที่สุดที่จะไม่แก้ไขปัญหาอื่น ๆ เนื่องจากคุณอาจแนะนำประเด็นใหม่โดยไม่เต็มใจ
  • ไปที่มันซีลสไตล์: เข้าฆ่าแมลงออกไปและส่งปะของคุณ มันเป็นการผ่าตัดและยุทธวิธี

• แต่สำหรับกรณีอื่น ๆ ทั้งหมดถ้าคุณเปิดไฟล์ให้ทำหน้าที่:

  • แน่นอน: ตรวจสอบ (จดบันทึกรายงานปัญหาไฟล์)
  • อาจจะ: ทำความสะอาดมัน (การสะสางสไตล์และการละเมิดเล็กน้อย)
  • นึกคิด: refactorมัน (จัดระเบียบส่วนใหญ่และเพื่อนบ้านของพวกเขา)

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

ภาคผนวก: การจัดการสภาพแวดล้อมการเขียนโปรแกรมด้วยภาพ

Walled Gardens of Bespoke Programming Systems

ระบบการตั้งโปรแกรมที่หลากหลายเช่น OP2 G2 เป็นสัตว์ที่แตกต่างกัน ...

• ไม่มีที่มา "รหัส"

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

• ไม่มีสัญญาตกลง

  นอกเหนือจากของตัวเองนั่นคือ คุณมักถูก จำกัด โดยสภาพแวดล้อมการเขียนโปรแกรมดีบักเกอร์ของตนเองล่ามของตนเองเครื่องมือเอกสารและรูปแบบของตนเอง พวกเขามี กำแพงล้อมรอบสวนยกเว้นในที่สุดหากพวกเขาดึงดูดความสนใจของใครบางคนที่มีแรงจูงใจมากพอที่จะทำวิศวกรรมรูปแบบของพวกเขาและสร้างเครื่องมือภายนอก - หากใบอนุญาตอนุญาต

• ขาดเอกสาร

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

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

เรื่องเล็ก ๆ น้อยส่วนตัว 2:จริงๆแล้วฉันทำงานด้วยตัวเอง ฉันไม่ได้ทำการเชื่อมโยงกับคำขอของ OP แต่โครงการของฉันเป็นชุดของซอฟต์แวร์ประมวลผลข้อมูลขนาดใหญ่และการเชื่อมต่อข้อมูลระหว่างกัน (ส่วนใหญ่ใช้สำหรับการวิจัยทางชีวภาพสารสนเทศการดูแลสุขภาพและเครื่องสำอาง ความฉลาดหรือโดเมนใดก็ตามที่แสดงถึงการติดตามข้อมูลการวิจัยจำนวนมากทุกชนิดและการเตรียมเวิร์กโฟลว์การประมวลผลข้อมูลและ ETL) หนึ่งในแอปพลิเคชั่นเหล่านี้คือ IDE เชิงวิชวลที่ใช้ระฆังและนกหวีดปกติ: อินเตอร์เฟสลากและวาง, พื้นที่ทำงานโปรเจ็กต์เวอร์ชัน (ใช้ไฟล์ข้อความและ XML สำหรับพื้นที่เก็บข้อมูลเมตาดาต้า), ไดรเวอร์ที่ถอดได้หลายแหล่ง canvas ไปยังการออกแบบ pipelines เพื่อประมวลผลข้อมูลจากแหล่งข้อมูล N และในท้ายที่สุดจะสร้าง M outputed transforms และการสร้างภาพเงาที่เป็นไปได้และรายงานออนไลน์ที่ซับซ้อน (และการโต้ตอบ) ระบบการเขียนโปรแกรมวิชวลแบบ bespoke ทั่วไปของคุณซึ่งมีอาการของโรค NIH เล็กน้อยภายใต้ข้ออ้างในการออกแบบระบบที่ปรับให้เข้ากับความต้องการของผู้ใช้

และอย่างที่คุณคาดหวังมันเป็นระบบที่ดีมีความยืดหยุ่นค่อนข้างมากสำหรับความต้องการของมัน แต่บางครั้งก็ค่อนข้าง over-the-top ดังนั้นคุณสงสัยว่า "ทำไมไม่ใช้เครื่องมือบรรทัดคำสั่งแทน?" และน่าเสียดายที่เป็นผู้นำในขนาดกลาง ทีมที่ทำงานในโครงการขนาดใหญ่ให้กับผู้คนมากมายต่างใช้มันด้วยวิธีปฏิบัติที่ "ดีที่สุด" ที่แตกต่างกัน

เยี่ยมมากพวกเราถึงวาระแล้ว! - เราทำอะไรเกี่ยวกับมัน

ในท้ายที่สุดทั้งหมดข้างต้นยังคงถือ หากคุณไม่สามารถแยกการเขียนโปรแกรมส่วนใหญ่ออกจากระบบนี้เพื่อใช้เครื่องมือและภาษากระแสหลักมากขึ้นคุณต้อง "ปรับ" ให้เข้ากับข้อ จำกัด ของระบบของคุณ

เกี่ยวกับการกำหนดเวอร์ชันและการจัดเก็บ

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

แต่ถึงกระนั้นหากพวกเขามีฟังก์ชั่นดังกล่าวบางทีทางออกของคุณคือปฏิบัติตามแนวทางมาตรฐานอุตสาหกรรมที่เรารักด้านบนและโอนไปยังระบบการเขียนโปรแกรมนี้ !!

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

เกี่ยวกับการทดสอบ

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

แน่นอนว่ามันเป็นงานแฮ็คและไม่เป็นไปตามมาตรฐานของการเขียนโปรแกรม "ปกติ" แต่ความคิดคือการปรับให้เข้ากับระบบในขณะที่พยายามรักษากระบวนการพัฒนาซอฟต์แวร์ระดับมืออาชีพ

ถนนนั้นยาวและสูงชัน ...

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

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

วิธีแก้ปัญหา:เมื่อนี่ไม่ใช่ตัวเลือกให้ลองติดตั้งเฟรมเวิร์กส่วนกลางนี้ใหม่ใน "กล่อง" ของคุณ ความคิดคือการวางพิมพ์เขียวของแนวปฏิบัติที่ดีที่สุดที่เป็นมาตรฐานอุตสาหกรรมไว้ด้านบนของระบบการเขียนโปรแกรมของคุณและทำให้ดีที่สุด คำแนะนำยังคงใช้: กำหนดโครงสร้างและแนวทางปฏิบัติที่ดีที่สุดส่งเสริมความสอดคล้อง

น่าเสียดายที่สิ่งนี้บ่งบอกว่าคุณอาจต้องดำน้ำและทำงานขาจำนวนมหาศาล ดังนั้น...

คำพูดสุดท้ายที่มีชื่อเสียงและคำขอต่ำต้อย:

• บันทึกเอกสารทุกอย่างที่คุณทำ
• แบ่งปันประสบการณ์ของคุณ
• โอเพนซอร์สเครื่องมือใด ๆ ที่คุณเขียน

เมื่อทำสิ่งนี้ทั้งหมดคุณจะ:

• ไม่เพียงเพิ่มโอกาสในการได้รับการสนับสนุนจากผู้คนในสถานการณ์ที่คล้ายคลึงกัน
• แต่ยังให้ความช่วยเหลือแก่ผู้อื่นและส่งเสริมการสนทนารอบกองเทคโนโลยีของคุณ

ใครจะรู้คุณอาจจะเป็นจุดเริ่มต้นที่ดีของชุมชนที่มีชีวิตชีวาใหม่ของการปิดบังภาษา X หากไม่มีให้เริ่มเลย!

• ถามคำถามเกี่ยวกับกองมากเกิน ,
• แม้อาจจะเขียนข้อเสนอสำหรับ StackExchange เว็บไซต์ใหม่ใน พื้นที่ 51

บางทีมันอาจจะสวยงามอยู่ข้างในแต่ไม่มีใครมีเบาะแสดังนั้นให้ช่วยลดกำแพงที่น่าเกลียดนี้และปล่อยให้คนอื่นมอง!

มากขั้นตอนแรกจะมีการเปิดตัวของระบบการควบคุมเวอร์ชัน (SVN, Git, Mercurial, TFS, ฯลฯ ) สิ่งนี้จะต้องมีสำหรับโครงการที่จะมีแฟคตอริ่งอีกครั้ง

แก้ไข:เกี่ยวกับ VSC - ทุกแพ็คเกจควบคุมซอร์สสามารถจัดการไบนารีแม้ว่าจะมีข้อ จำกัด อยู่บ้าง เครื่องมือส่วนใหญ่ในตลาดมีความสามารถในการใช้โปรแกรมดูและแก้ไขความแตกต่างที่กำหนดเองใช้ความสามารถนี้ ไฟล์ต้นฉบับไบนารีไม่ใช่ข้ออ้างที่จะไม่ใช้การควบคุมเวอร์ชัน

มีโพสต์ที่คล้ายกันเกี่ยวกับวิธีการจัดการกับรหัสเดิมก็อาจจะมีการอ้างอิงที่ดีในการติดตาม - คำแนะนำในการทำงานกับรหัสเดิม

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

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

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

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

ฉันเชื่อว่าพวกเขาเป็นคนที่ฉลาดมาก แต่การเป็นนักพัฒนาที่ดีนั้นต้องใช้เวลามาก พวกเขาพร้อมที่จะใช้เวลาในกิจกรรมที่ไม่ใช่ธุรกิจหลักของพวกเขาหรือไม่? IMHO นี่ไม่ใช่วิธีที่จะทำให้ได้ผลลัพธ์ที่ดีที่สุด

ว้าว. ดูเหมือนว่าคุณจะมีความท้าทายที่ยิ่งใหญ่รออยู่ข้างหน้าคุณ! ฉันจะทำบางสิ่งตามบรรทัดต่อไปนี้:

• ครั้งแรกของทั้งหมด: จัดลำดับความสำคัญ สิ่งใดที่คุณต้องการประสบความสำเร็จเป็นอันดับแรก อะไรคือสิ่งสำคัญที่สุดสำหรับสถานะปัจจุบันของโครงการ สิ่งที่คุณจะได้รับมากที่สุดจากจำนวนที่ต้องใช้ในการเดินทาง
• ตรวจสอบให้แน่ใจว่าคุณมีระบบควบคุมเวอร์ชัน GitหรือMercurialเป็นต้น
• รับระบบการรวมอย่างต่อเนื่องบางประเภท(เช่นเจนกินส์ ) และทำงาน
• รับระบบติดตามบั๊กและทำงาน ตั๊กแตนตำข้าวค่อนข้างดีในความคิดของฉัน
• ดูการวิเคราะห์โค้ดแบบสแตติก (หากมีบางสิ่งที่ใช้ได้สำหรับภาษาที่คุณกำลังทำงานด้วย)
• พยายามที่จะบรรลุความมั่นคงในทุกสิ่งตั้งแต่การตั้งชื่อตัวแปรไปจนถึงข้อกำหนดรหัสทั่วไปและแนวทางในฐานรหัส
• ได้รับระบบภายใต้การทดสอบ นี่เป็นสิ่งสำคัญอย่างยิ่งสำหรับระบบมรดกขนาดใหญ่เช่นนี้ในความคิดของฉัน ใช้กรณีทดสอบเพื่อบันทึกพฤติกรรมที่มีอยู่ไม่ว่าพฤติกรรมนั้นจะรู้สึกแปลกหรือไม่ก็ตาม (โดยปกติจะมีเหตุผลว่าทำไมโค้ดถึงมีลักษณะที่แน่นอนว่าทำไมอาจจะดีหรือไม่ดีหรือทั้งคู่; P) Michael Feathers ทำงานอย่างมีประสิทธิภาพด้วยรหัสมรดกเป็นแหล่งข้อมูลที่ยอดเยี่ยมสำหรับสิ่งนี้

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

คุณสามารถตรวจสอบกายวิภาคศาสตร์ของคุณได้ทุกอย่างตามที่คุณต้องการและแม้ว่ามันอาจจะมีการเปลี่ยนแปลงตามปกติเมื่อมันลงมาถึงข้างในหัวทั้งหมดนี้ก็ดูเหมือนกัน ไม่ไม่ไม่ชักเย่อ คุณไม่มีทางรู้ว่ามันอาจจะติดอยู่กับอะไร

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

บางสิ่งที่จะมุ่งเน้น:

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

• ค้นหากรณีที่มีฟังก์ชั่นการทำงานซ้ำ ๆ กัน ทำงานเพื่อการรวมกัน

• เตือนทุกคนเป็นครั้งคราวว่าการเปลี่ยนแปลงเหล่านี้มีขึ้นเพื่อทำให้ชีวิตง่ายขึ้นไม่ยากขึ้น การเปลี่ยนเป็นสิ่งที่เจ็บปวด แต่มันก็เพื่อจุดประสงค์ที่ดีและยิ่งทุกคนอยู่บนเรือมากเท่าไหร่ก็จะได้รับประโยชน์มากขึ้นเท่านั้น

หลังจากดูGensym G2สักเล็กน้อยดูเหมือนว่าวิธีการแก้ไขปัญหานี้จะขึ้นอยู่กับว่าฐานของโค้ดมีลักษณะเป็นอย่างไร:

หรือสิ่งนี้:

เมื่อเทียบกับสิ่งนี้มารยาทของเบียร์ 99 ขวด :

beer-bottles()

i:integer =99;
j:integer;
constant:integer =-1;

begin
for i=99 down to 1
    do
    j = (i+constant);
        if (i=1) then begin
            post"[i] bottle of beer on the wall";
            post" [i] bottle of beer";
            post" Take one down and pass it around ";
            post" No bottle of beer on the wall"; 
        end 
        else begin
            post"[i] bottles of beer on the wall";
            post" [i] bottles of beer";
            post" Take one down and pass it around ";
            if (i=2) then 
                post" [j] bottle of beer on the wall"
           else
                post" [j] bottles of beer on the wall"; 
           end
    end
end

ในกรณีหลังคุณกำลังทำงานกับซอร์สโค้ดซึ่งเป็นปริมาณที่ทราบได้อย่างมีประสิทธิภาพและคำตอบอื่น ๆ บางคำเสนอคำแนะนำที่ดีมากสำหรับการจัดการกับมัน

หากฐานรหัสส่วนใหญ่เป็นรุ่นหลังหรือแม้ว่าจะเป็นก้อนขนาดใหญ่คุณจะพบปัญหาที่น่าสนใจของการมีรหัสที่อาจไม่สามารถ refactored เนื่องจากมีความเชี่ยวชาญเป็นพิเศษหรือแย่กว่านั้นบางสิ่งที่ดูเหมือน มันอาจจะถอดออกได้ แต่ถ้ามันเป็นเอกสารอย่างถูกต้องคุณไม่ทราบว่าคุณกำลังลบรหัสที่สำคัญ (คิดว่าบางสิ่งบางอย่างตามแนวของการดำเนินการ scram ) ที่ดูเหมือนจะไม่เป็นอย่างรวดเร็ว

แม้ว่าจะเห็นได้ชัดว่าสิ่งสำคัญอันดับแรกของคุณจะได้รับการจัดเรียงของการควบคุมเวอร์ชันออนไลน์บางเป็นแหลมออกElYusubovและมันไม่ปรากฏว่าการควบคุมรุ่นได้รับการสนับสนุนตั้งแต่รุ่น 8.3 เนื่องจาก G2 เป็นการผสมผสานระหว่างวิธีการทางภาษาที่แตกต่างกันสองสามประการคุณจึงอาจพบว่าวิธีนี้มีประสิทธิภาพมากที่สุดในการใช้การควบคุมเวอร์ชันที่ให้มาโดยไม่ได้พยายามค้นหาสิ่งอื่นและทำให้มันใช้งานได้

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

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

เมื่อคุณมีการทดสอบหน่วยในจำนวนที่เป็นธรรมของรหัสคุณสามารถเริ่มเข้าใกล้ refactoring ในลักษณะเช่นที่แนะนำโดยเฮย์เล็ม ; อย่างไรก็ตามโปรดจำไว้ว่าคุณกำลังเผชิญกับบางสิ่งที่มีไว้สำหรับการพัฒนาระบบผู้เชี่ยวชาญและการปรับโครงสร้างใหม่อาจเป็นการต่อสู้ที่ยากลำบาก นี่คือสภาพแวดล้อมที่มีบางสิ่งบางอย่างที่จะกล่าวว่าไม่ได้เขียนรหัสทั่วไปอย่างมากในบางครั้ง

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

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

รหัสยากที่จะเข้าใจ? ตรวจสอบ ฐานรหัสขนาดใหญ่? ตรวจสอบ

ปัญหาที่แท้จริงคือการที่คนออกจากและเมื่อคนใหม่เข้าร่วมองค์กรมีความสับสนโดยทั่วไป นอกจากนี้ยังมีปัญหาของความคาดหวังที่ไม่สมจริงและปัญหาคุณภาพของรหัส

นี่คือสิ่งที่ฉันจะจัดการตามลำดับ:

1. สำรองข้อมูลทั้งเซิร์ฟเวอร์และรุ่นในเครื่อง
2. ตั้งค่าตัวติดตามบั๊ก
3. ตั้งค่าระบบการกำหนดเวอร์ชัน
4. ตั้งค่า FAQ / Wiki
5. การซักซ้อมครั้งแรกของนักวิทยาศาสตร์ / โปรแกรมเมอร์ทั้งหมด
   • เตือนพวกเขาถึงกฎ 80/20 20% ของข้อบกพร่องเป็นสาเหตุของปัญหา 80%
   • มุ่งเน้นไปที่ปัญหาที่ใหญ่ที่สุดและเก็บคำขอปรับปรุงและปิด
   • จุดประสงค์ที่นี่ไม่ได้ทำให้ผู้คนจำนวนมากกลัว แต่เป็นรายการของความสำเร็จเล็ก ๆ ท้ายที่สุดคุณต้องพิสูจน์คุณค่าของคุณเช่นกัน
6. ตั้งค่าระบบการสร้าง
   • เริ่มทำงานเพื่อรับบิลด์ที่เชื่อถือได้ (อาจใช้เวลาสักครู่)
   • ระบุและตั้งชื่อทุกโครงการ
   • ระบุวงจรอ้างอิง
   • หากมีไบนารีจากโปรเจ็กต์โอเพนซอร์สบางตัวพยายามรับซอร์ส
7. ระบุว่ารหัส G2 สามารถทำให้เป็นโมดูลได้อย่างไรเช่น API บริการ
8. ระบุวิธีการที่สามารถทดสอบและบันทึกรหัส G2 ได้
9. ตั้งค่าระบบตรวจสอบโค้ด
10. การซักไซ้ที่สอง
    • โมดูลในอุดมคติมีลักษณะอย่างไร
    • วิธีปิดล้อมรหัสเก่า
    • วิธีการห่อโมดูลใหม่รอบ ๆ โค้ดเก่า (ดูรูปแบบ Strangler http://agilefromthegroundup.blogspot.com.au/2011/03/strangulation-pattern-of-choice-for.html )
11. ระบุทีมถอดรหัสที่ดีกว่าโปรแกรมเมอร์และทำงานกับพวกเขาเพื่อห่อโมดูลของพวกเขา
12. บทวิจารณ์โค้ดอยู่ที่ขั้นตอนนี้เพื่อปรับปรุงการสื่อสารและเอกสารประกอบ ทำให้มันง่ายในช่วงนี้ สังคายนาปัญหากระบวนการใด ๆ
13. แผ่ขยายระบบไปยังโปรแกรมเมอร์อื่น ๆ ปล่อยให้สมาชิกในทีมร้าวเป็นเพื่อนพี่เลี้ยงที่เหลือ โปรดจำไว้ว่าการปรับขนาดเป็นปัญหาที่นี่ คุณอยู่ในบทบาทการจัดการอย่างมีประสิทธิภาพ

คำถามเช่นนี้คือเหตุผลทั้งหมดที่โครงการSoftware Carpentryมีอยู่

ในช่วง 14 ปีที่ผ่านมาเราได้สอนทักษะการพัฒนาซอฟต์แวร์ขั้นพื้นฐานสำหรับนักวิทยาศาสตร์และวิศวกร: การควบคุมเวอร์ชันการทดสอบวิธีการทำให้เป็นโมดูลและอื่น ๆ สื่อทั้งหมดของเรามีให้ใช้อย่างอิสระภายใต้ใบอนุญาต Creative Commons และเราเปิดเวิร์คช็อปสองวันฟรีสองโหลทุกปีเพื่อช่วยให้ผู้คนเริ่มต้นใช้งาน

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

ฉันขอแนะนำ"การรักษาความถูกต้องในโปรแกรมวิทยาศาสตร์" ของ Paul Dubois (การคำนวณในวิทยาศาสตร์และวิศวกรรม , พฤษภาคม - มิถุนายน 2005), ซึ่งอธิบายวิธีการ "การป้องกันในเชิงลึก" ที่รวมการปฏิบัติที่แตกต่างกันหลายสิบในตรรกะที่สอดคล้องกัน ทาง

ฉันคิดว่าก่อนอื่นคุณต้องล้างสถานการณ์ของคุณ พวกเขาต้องการอะไรจากคุณ

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

ฉันคิดว่าความต้องการหลักที่นี่คือ "บันทึกความรู้ในระบบ" ดังนั้นคุณต้องไปขุดมัน!

ภารกิจแรกคือการเขียนเอกสาร

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

คุณควรเริ่มถามว่าพวกเขาต้องการไปที่ไหน?

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

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

ขณะวิเคราะห์และเขียนเอกสารอ่านใช้และโฆษณารูปแบบ GoF Design! :-)

... 2 เซนต์ของฉัน

ฉันเพิ่งทำการนำเสนอตามหลักการ SOLID ของ Robert Martin สำหรับเพื่อนร่วมงานของฉัน ฉันไม่รู้ว่าหลักการเหล่านี้แปลเป็น G2 ได้ดีเพียงใด แต่เมื่อคุณมองหาพื้นฐาน 5-7 หลักหลักการเหล่านี้จึงดูเหมือนเป็นชุดที่จัดตั้งขึ้นอย่างดีเพื่อเริ่มต้นด้วย หากคุณต้องการปัดเศษขึ้นเป็น 7 คุณสามารถเริ่มต้นด้วย DRY แล้วโยนใน Fail-Fast

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

การควบคุมแหล่งที่มาการสร้างใหม่และ devs ที่ได้รับการฝึกอบรมมากขึ้นล้วนเป็นข้อเสนอแนะที่ดี แต่ถ้านี่เป็นครั้งแรกที่คุณต้องจัดการกับปัญหาประเภทนี้อย่างช้าๆและการเปลี่ยนแปลงที่ควบคุมไม่สามารถเน้นได้เพียงพอ

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

หลักการสำคัญที่สุดสำหรับการทำงานในสถานการณ์เช่นนี้คือ:

1. ใจเย็น ๆ หลุมที่ใช้เวลาขุด 20 ปีจะไม่ถูกเติมเต็มในอีกไม่กี่สัปดาห์

2. เป็นบวก ต่อต้านสิ่งล่อใจที่จะบ่นและบ่น

3. เน้นการปฏิบัติ ดูการเปลี่ยนแปลงเชิงบวกที่คุณสามารถทำได้ในหนึ่งวันและทำอย่างนั้นวันนี้ มีระบบควบคุมเวอร์ชันหรือยัง? ใช้งานและฝึกอบรมผู้คน จากนั้นดูและดูว่าคุณสามารถทำการทดสอบอัตโนมัติ (การทดสอบหน่วยหรือสิ่งที่คล้ายกัน) ล้าง. ทำซ้ำ

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

5. ทำแผนที่อาณาเขตของคุณ ฉันมีเทคนิคในการทำแผนที่รหัสฐานขนาดใหญ่แบบดั้งเดิม ฉันลอกแบบ repo สร้างสำเนาที่ใช้งานได้จากนั้นฉันพยายามเปลี่ยนบางสิ่งและดูว่ามีอะไรแตก โดยการตรวจสอบการมีเพศสัมพันธ์ (ผ่านสถานะทั่วโลกหรือ API ที่ขาดหรือขาด API ที่สอดคล้องกันหรือ abstractions หรือส่วนต่อประสานกับโปรแกรม) และโดยการอ่านรหัสที่แตกหักเมื่อฉันเปลี่ยนสิ่งต่าง ๆ ฉันค้นพบ cruft ฉันถามคำถามที่นำไปสู่ ข้อมูลเชิงลึกจากส่วนที่เหลือของทีม (โอ้เราเสริมว่าเพราะ Boss X 5 ปีที่ผ่านมาเรียกร้องให้มันไม่เคยทำงาน!) เมื่อเวลาผ่านไปคุณจะได้รับแผนที่จิตของดินแดน เมื่อคุณรู้ว่ามันใหญ่แค่ไหนคุณก็พอจะสร้างแผนที่และกลับบ้านได้แล้ว สนับสนุนให้ผู้อื่นทำแผนที่อาณาเขตของฐาน code ยักษ์ของคุณและเพื่อสร้างความรู้ด้านเทคนิคของทีม บางคนหยุดชะงักที่ "เอกสาร" เพราะมันไม่คล่องแคล่ว อะไรก็ตาม ฉันทำงานในสภาพแวดล้อมทางวิทยาศาสตร์ด้วยและเอกสารเป็นสิ่งที่สำคัญสำหรับฉัน

6. สร้างแอพเล็ก ๆ เมื่อทำงานกับ codebase แบบดั้งเดิมฉันพบว่าฉันติดดิน ฉันได้วิญญาณของฉันกลับมาโดยการสร้างแอพตัวช่วยน้อย บางทีแอพเหล่านั้นอาจช่วยให้คุณอ่านและทำความเข้าใจและปรับเปลี่ยนฐานรหัส G2 ขนาดยักษ์ บางทีคุณสามารถสร้างเครื่องมือ mini หรือเครื่องมือแยกวิเคราะห์ที่จะช่วยคุณทำงานในสภาพแวดล้อมของคุณ มีหลายกรณีที่การเขียนโปรแกรม Meta และการสร้างเครื่องมือไม่เพียง แต่จะช่วยให้คุณหลุดพ้นจากการหยุดชะงักขนาดยักษ์ที่โค้ดเบสดั้งเดิมกำหนดไว้กับคุณ แต่ยังทำให้สมองของคุณมีความสามารถในการบินโดยไม่ จำกัด ภาษา G2 ของคุณ เขียนเครื่องมือและผู้ช่วยของคุณในภาษาใดก็ได้ที่คุณสามารถทำได้เร็วที่สุดและดีที่สุดสำหรับฉันภาษาเหล่านั้น ได้แก่ Python และ Delphi หากคุณเป็นผู้ชาย Perl หรือว่าคุณชอบการเขียนโปรแกรมใน C ++ หรือ C # จริงๆให้เขียนเครื่องมือช่วยเหลือของคุณเป็นภาษานั้น

1. การควบคุมการแก้ไขใหม่ : แสดงให้ผู้เชี่ยวชาญด้านโดเมนทราบถึงประโยชน์ของความสามารถในการย้อนกลับดูว่าใครเปลี่ยนอะไร ฯลฯ (นี่เป็นไฟล์ที่ยากกว่าสำหรับไฟล์ไบนารีทั้งหมด แต่ถ้าเนื้อหานั้นเป็นรหัสจริงแน่นอนว่ามี G2-to- อยู่บ้าง ตัวแปลงข้อความที่สามารถเปิดใช้งาน diffs ได้)

2. บูรณาการและทดสอบอย่างต่อเนื่อง : ให้ผู้เชี่ยวชาญด้านโดเมนมีส่วนร่วมในการสร้างการทดสอบแบบครบวงจร (ง่ายขึ้นเนื่องจากต้องมีอินพุตและเอาต์พุตที่คาดหวังอยู่แล้ว) และการทดสอบหน่วยขนาดเล็ก (ยากกว่าเพราะรหัสสปาเก็ตตี้อาจเกี่ยวข้องกับตัวแปรทั่วโลกจำนวนมาก) ครอบคลุมฟังก์ชั่นการใช้งานเกือบทั้งหมดและกรณีใช้งาน

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

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

"ตัวโปรแกรมเองเป็นแบบจำลองทางกายภาพของโรงงานแปรรูปสารเคมีที่ซับซ้อน ... "

"เนื่องจาก G2 นั้นไม่ใช่รหัส แต่เป็นรหัสอัตโนมัติที่เขียนโดย GUI ที่มีชื่อเสียงบางคน ... " - Erik Reppen

สมมติว่าเป้าหมายหลักของซอฟต์แวร์ของคุณคือการจำลอง (อาจปรับให้เหมาะสมใช้การประมาณค่าพารามิเตอร์ตาม) โรงงานเคมีที่ซับซ้อนหรือบางส่วนของหนึ่ง ... จากนั้นฉันอยากจะแนะนำข้อแตกต่าง:

คุณอาจพิจารณาใช้ภาษาจำลองทางคณิตศาสตร์ระดับสูงเพื่อแยกสาระสำคัญแบบจำลองทางคณิตศาสตร์หลักออกจากซอฟต์แวร์ที่เขียนด้วยมือ

สิ่งที่ภาษาการสร้างแบบจำลองคือการแยกคำอธิบายของปัญหาจากอัลกอริทึมที่ใช้ในการแก้ปัญหา อัลกอริทึมเหล่านี้มักใช้กับการจำลอง / การปรับให้เหมาะสมที่สุดของคลาสที่กำหนด (เช่นกระบวนการทางเคมี) ซึ่งในกรณีนี้พวกเขาไม่ควรคิดค้นและดูแลรักษาในบ้าน

แพ็คเกจการค้าสามแบบที่ใช้กันอย่างแพร่หลายในอุตสาหกรรมของคุณคือ: gPROMS, Aspen Custom Modeller และ (หากแบบจำลองของคุณไม่รวมปรากฏการณ์ที่กระจายไปตามโดเมนพิเศษ) มีแพ็คเกจซอฟต์แวร์ที่ใช้ Modelica เช่น Dymola

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

โปรแกรมเหล่านี้ส่วนใหญ่ควรอนุญาตให้คุณ 'เริ่มต้นเล็ก' และพอร์ตชิ้นส่วนเล็ก ๆ (รุ่นย่อย) ของรหัสเสาหินของคุณในรูปแบบของพวกเขาโดยเรียกว่าภายนอก นี่อาจเป็นวิธีที่ดีในการบำรุงรักษาระบบการทำงานและตรวจสอบทีละชิ้น

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

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

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

เพื่อให้ได้มุมมองคุณอาจรู้สึกทึ่งกับการลดขนาด เช่น 200,000 LoC สามารถแสดงในสมการ 5,000 เส้นได้ (โอเคฉันเดาได้ที่นี่ แต่ฉันสามารถลองให้คุณได้รับข้อความรับรองจากเพื่อน ๆ ในธุรกิจ) บวกกับฟังก์ชั่นโมดูลขนาดเล็กจำนวนน้อยที่เขียนในบางสิ่งเช่น C (ตัวอย่างเช่นการคำนวณคุณสมบัติทางกายภาพ - แม้ว่าจะมีแพ็กเกจชั้นวางอีกครั้งขึ้นอยู่กับกระบวนการทางเคมีของคุณ) นี่เป็นเพราะคุณทิ้งโค้ดอัลกอริธึมและปล่อยให้ 'สแต็ค' ของตัวแก้ปัญหาทางคณิตศาสตร์ทั่วไปทำงานหนัก เมื่อคุณจำลองการทำงานคุณสามารถทำสิ่งต่างๆได้มากขึ้นเช่นการปรับกระบวนการให้เหมาะสมโดยไม่ต้องเปลี่ยนบรรทัดของโค้ด

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

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

ฉันจะทิ้งสิ่งต่อไปนี้:

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

2. นักวิทยาศาสตร์เขียน / ทดสอบอัลกอริทึม นักวิทยาศาสตร์ที่ต้องการเขียนอัลกอริธึมของตนเองใน 1-3 ภาษาที่ทุกคนสามารถตกลงกันเพื่อให้คุณแปลงเป็นรหัสหลัก ที่ทำให้การทดสอบสิ่งที่พวกเขาพวกเขา นอกเหนือจากนั้นพวกเขาจะต้องช่วยคุณแยกสิ่งที่สำคัญทางวิทยาศาสตร์กับสิ่งที่ดีที่พระเจ้ารู้สำหรับสิ่งก่อสร้าง codebase ถูก hosed มีการเฉือนและการเผาไหม้มากมายที่ต้องทำ ให้ตัวเลือกแก่พวกเขาเพื่อมอบสิ่งที่เป็นเวอร์ชันการทำงานซึ่งใช้สิ่งที่พวกเขารู้ดีที่สุดเพื่อให้คุณสามารถทำสิ่งที่คุณทำได้ดีที่สุด ติดความรู้ของพวกเขาในกล่องที่พวกเขารับผิดชอบ แต่คุณสามารถทำงานกับ

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

4. มองหาคนที่แก้ไขปัญหานี้หรือปัญหาที่คล้ายกัน ใช้เวลาค้นคว้าอย่างจริงจัง พวกเหล่านี้ได้ยินเกี่ยวกับ G2 จากใครบางคน

5. รูปแบบการออกแบบ อะแดปเตอร์ ใช้ 'em ใช้ 'em มากในสถานการณ์เช่นนี้

6. เรียนรู้สิ่งที่คุณสามารถของวิทยาศาสตร์ ยิ่งคุณรู้มากเท่าไหร่คุณก็ยิ่งสามารถกำหนดเจตนาในโค้ดได้ดีเท่านั้น

ทำการวิเคราะห์ก่อน

ฉันจะทำการวิเคราะห์ก่อนตัดสินใจว่าจะสอนอะไร หาจุดปวดที่ใหญ่ที่สุด ใช้สิ่งเหล่านี้เพื่อจัดลำดับความสำคัญของสิ่งที่ควรปฏิบัติ

แนะนำเพียงการเปลี่ยนแปลงเล็กน้อยในเวลา(ในสถานการณ์ที่คล้ายกันที่ฉันได้ 2-3 การปฏิบัติทุก 2 สัปดาห์)

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

• ทำไมจึงต้อง จำกัด จำนวนการเปลี่ยนแปลง

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

เพิ่มการประชุมสรุปรายสัปดาห์เพื่อหารือเกี่ยวกับวิธีปฏิบัติที่ได้รับผลกระทบ

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

การปฏิบัติบางอย่างมีความสำคัญ

การใช้ระบบควบคุมเวอร์ชัน (IMO) อย่างเหมาะสมนั้นสำคัญกว่าทุกสิ่งทุกอย่าง การปิดด้านหลังเป็นบทเรียนในการทำให้เป็นโมดูล, การเชื่อมต่อ / การทำงานร่วมกันและการติดตามตั๋ว / คุณลักษณะ

ลบแนวทางปฏิบัติที่ไม่ทำงาน

อย่ากลัวที่จะกำจัดการปฏิบัติที่ไม่ได้ผล หากมีค่าใช้จ่ายสูงและแทบไม่มีประโยชน์ให้ถอดการฝึกออก

การปรับปรุงเป็นกระบวนการ

ถ่ายทอดว่าการปรับปรุงอย่างยั่งยืนและต่อเนื่องเป็นกระบวนการ ระบุจุดปวดที่ใหญ่ที่สุดใช้วิธีแก้ปัญหารอ / โค้ชแล้วทำซ้ำ มันจะรู้สึกช้าลงอย่างช้า ๆ ในตอนแรกจนกว่าคุณจะสร้างแรงผลักดัน ให้ทุกคนจดจ่อกับการปรับปรุงที่กำลังจะมาถึงและการปรับปรุงที่ประสบความสำเร็จแล้ว

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

ฉัน (ถ้าฉันสามารถ) เรียนรู้บทเรียนอย่างหนักเป็นการส่วนตัวและแนะนำแนวคิดหลักที่คุณต้องการเป็นวิธีการแก้ปัญหาในอุตสาหกรรมซอฟต์แวร์

เช่นนักพัฒนาสองคนมีสำเนาที่แตกต่างกันและจบลงด้วยการปรับใช้รีลีสที่ยังไม่ได้ทดสอบ -> แนะนำการควบคุมเวอร์ชันการแบรนช์และการทดสอบ

บางคนลบโค้ดสองสามบรรทัดที่ไม่เข้าใจและทำให้ไฟดับ -> แนะนำ DDD

หากคุณไม่ได้แชร์บทเรียนอย่างหนักกับคุณในรายละเอียดที่เพียงพอเพียงแค่แสดงตัวอย่างของคุณเองว่าสิ่งต่าง ๆ ผิดพลาดอย่างไรเมื่อไม่ปฏิบัติตามวินัยนี้

การควบคุมซอร์สโค้ดเป็นขั้นตอนที่ 1 ตามที่ระบุไว้หลายครั้งแล้ว ในขณะที่คนที่คุณทำงานด้วยอาจไม่ใช่นักพัฒนามืออาชีพและพวกเขาจะไม่ตอบสนองต่อองค์กรขนาดใหญ่หรือจัมโบ้จัมโบ้แบบเปรียว พวกมันไม่ใช่ลิงโค๊ดระดับต่ำและพยายามที่จะปฏิบัติต่อพวกเขาเช่นนั้นโดยการบังคับให้พวกเขาทำในสิ่งที่ 'ทางของคุณ' จะไม่บิน

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

ในขณะที่คุณกำลังทำเช่นนั้นค้นหาผลไม้แขวนลอยต่ำอื่น ๆ และแก้ไขปัญหาเหล่านั้น

เหนือสิ่งอื่นใดฟังสิ่งที่พวกเขาพูดและพยายามปรับปรุงสถานการณ์ของพวกเขา ไม่ต้องกังวลเกี่ยวกับการพยายามประทับตราของคุณในสิ่งที่พวกเขาทำ

โชคดี!