เหตุใดฉันจึงควรใช้การควบคุมเวอร์ชัน [ปิด]

ฉันกำลังอ่านบล็อกที่ผู้เขียนกล่าวถึงเรื่องนี้

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

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

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

นี่เป็นแนวคิดพื้นฐานของมันหรือว่าฉันเข้าใจผิดไปหมด?

ถ้าฉันถูกมันอาจจะไม่มีประโยชน์มากนักถ้าฉัน:

• ห้ามมีคนอื่นทำงานเกี่ยวกับรหัส
• อย่าวางแผนที่จะให้คนอื่นมีรหัส

คุณเคย:

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

ในกรณีเหล่านี้และไม่ต้องสงสัยเลยว่าระบบควบคุมเวอร์ชันควรทำให้ชีวิตของคุณง่ายขึ้น

การอ้างเพื่อนผิด: เครื่องมือที่มีอารยะสำหรับยุคที่ศิวิไลซ์

แม้ว่าคุณจะทำงานคนเดียว แต่ก็สามารถใช้ประโยชน์จากการควบคุมแหล่งที่มาได้ ด้วยเหตุผลเหล่านี้:

• คุณไม่เสียอะไรเลย ฉันไม่เคยแสดงความคิดเห็นเกี่ยวกับรหัสอีกเลย ฉันก็ลบมัน มันไม่เกะกะหน้าจอและไม่หายไปด้วย ฉันสามารถกู้คืนได้โดยตรวจสอบคอมมิตเก่า

• คุณสามารถทดลองได้ตามต้องการ หากไม่สามารถแก้ปัญหาได้ให้เปลี่ยนกลับ

• คุณสามารถดูโค้ดเวอร์ชันก่อนหน้าเพื่อดูว่ามีการแนะนำจุดบกพร่องเมื่อใดและที่ไหน git bisectดีมากในเรื่องนั้น

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

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

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

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

git init

ยินดีต้อนรับสู่คลับ.

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

คุณอาจใช้การควบคุมเวอร์ชันในขณะนี้แม้ว่าคุณจะไม่รู้ก็ตาม คุณมีโฟลเดอร์ที่ระบุว่า "XXX Php Code (ธันวาคม)" หรือ "XXX.php.bak.2" ไหม นี่คือรูปแบบของการควบคุมเวอร์ชันอยู่แล้ว ระบบควบคุมเวอร์ชันที่ดีจะดูแลสิ่งนี้ให้คุณโดยอัตโนมัติ คุณจะย้อนกลับไปยังช่วงเวลาใดก็ได้ (ที่คุณได้เช็คอินข้อมูลไว้) และสามารถดูสำเนาข้อมูลนั้นได้

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

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

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

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

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

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

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

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

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

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

สำหรับงานเดี่ยวแนะนำให้ใช้ Subversion หรือ Git ทุกคนมีอิสระที่จะชอบอย่างใดอย่างหนึ่ง แต่ก็ดีกว่าการไม่ใช้การควบคุมเวอร์ชันใด ๆ หนังสือดีๆคือ " Pragmatic Version Control using Subversion, 2nd Edition " โดย Mike Mason หรือ " Pragmatic Version Control Using Git " โดย Travis Swicegood

ผู้แต่งต้นฉบับ: Bill Karwin

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

มันเหมือนกับมีปุ่ม "เลิกทำ" ขนาดยักษ์ตลอดทางกลับไปที่โค้ดบรรทัดแรก

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

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

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

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

สิ่งที่ฉันชอบคือคอมไพล์

มีเหตุผลหลายประการในการใช้การควบคุมเวอร์ชันแม้ว่าคุณจะเป็นคนเดียวที่เคยสัมผัสรหัสก็ตาม

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

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

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

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

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

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

ความจริงที่ว่านักพัฒนาคนอื่น ๆ เข้าร่วมหรือไม่นั้นมีมุมฉากอย่างสิ้นเชิงกับความต้องการของระบบควบคุมเวอร์ชัน

คุณสามารถเป็นนักพัฒนาเพียงคนเดียว แต่ยังจะได้รับประโยชน์จาก:

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

ตอนนี้หากคุณมีกลุ่มที่พัฒนาในการควบคุมเวอร์ชัน codebase เดียวกันก็ยังมีความจำเป็นมากกว่า

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

เมื่อมีคนเข้ามาเกี่ยวข้องมากขึ้นเครื่องมือควบคุมเวอร์ชันที่คุณเลือกจะมีความเกี่ยวข้องมากขึ้นทั้งนี้ขึ้นอยู่กับรูปแบบของการพัฒนา

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

คุณอาจพบว่าคุณมีโปรแกรมเวอร์ชันที่ใช้งานได้

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

คุณเริ่มได้รับรายงานข้อบกพร่องที่มีผลต่อโค้ดบางอย่างที่คุณคิดว่าคุณไม่ได้แตะต้อง

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

การควบคุมแหล่งที่มามีประโยชน์มากมายแม้ว่าคุณจะเป็นนักพัฒนาเพียงคนเดียวก็ตาม

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

ประโยชน์บางประการ:

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

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

ฉันพบว่าตัวเองทำการ refactoring เชิงรุกมากขึ้นหลังจากใช้ source control เพราะฉันรู้เสมอว่าเวอร์ชันที่ใช้งานได้นั้นสามารถกู้คืนได้อย่างง่ายดาย

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

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

ในส่วนของฉันเองฉันจะไม่เก็บไฟล์หรือโฟลเดอร์ชื่อ 'project_old' อีกต่อไปเมื่อฉันตัดสินใจที่จะ refactor บางสิ่งบางอย่าง การเปลี่ยนแปลงใด ๆ ที่ฉันทำจะถูกจัดเก็บไว้ทีละน้อยและฉันจะสามารถย้อนกลับไปยังโปรเจ็กต์ที่ทำงานโดยรวมได้เสมอ ฉันไม่ค่อยใช้ FTP เพื่อปรับใช้ในตอนนี้เพราะฉันเพิ่งชำระเงินรหัสผ่าน ssh ดาวน์โหลดเฉพาะไฟล์ที่ฉันเปลี่ยนแปลงเท่านั้นและหากฉันต้องการโหลดซ้ำบนเซิร์ฟเวอร์แสดงว่าเทอร์มินัลอยู่ที่นั่นแล้ว

ฉันพบว่าการพูดคุยเกี่ยวกับ GIT นี้ให้คำแนะนำอย่างแท้จริง http://www.youtube.com/watch?v=4XpnKHJAok8

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

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

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

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

แต่สองสามสัปดาห์ที่ผ่านมาฉันได้พบกับเพื่อนคนหนึ่งที่กำลังเขียนโครงการงานอดิเรกขนาดใหญ่ด้วยตัวเขาเอง เขามีรหัสสิบหรือยี่สิบชุดโดยมีคำต่อท้ายเช่น "X1" "X2" "test" "เร็วกว่า" เป็นต้น

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

นี่คือปี 2019 ฉันพบการคัดค้านในวันที่สายญาตินี้เกี่ยวกับการใช้ Git ฉันเห็นการคัดค้านบางอย่างที่นี่ การสนทนานี้ได้ชี้แจงอย่างชัดเจนถึงความจำเป็นของการใช้การควบคุมแหล่งที่มาแทนที่จะทำสำเนาสำรองที่ตั้งชื่อ ประเด็นสำคัญประการหนึ่งคือการใช้การควบคุมแหล่งที่มาแม้ว่าเราจะมีโครงการนักพัฒนาเพียงรายเดียว ไม่มีใครสมบูรณ์แบบ. คุณทำผิดพลาด หากคุณเก่งและฉลาดเป็นพิเศษคุณจะต้องพัฒนาแอพที่ซับซ้อนมากขึ้น แต่คุณจะยังคงทำผิดพลาดและสิ่งนี้จะจัดการกับมัน Geez โอ้พีท! ฉันไม่เคยใช้ Linux แต่ฉันคิดว่าเราทุกคนเคารพความฉลาดทางเทคนิคที่ยอดเยี่ยมของ Linus Torvalds เขาตระหนักถึงความสำคัญของการควบคุมแหล่งที่มาและเขามีส่วนร่วมสำคัญในการเริ่มต้น Git นั่นคือจุดสรุปของเหตุผลทั้งหมดที่ให้ไว้ที่นี่ Torvalds เข้าใจ: การควบคุมแหล่งที่มามีความสำคัญมาก: ใช้การควบคุมแหล่งที่มา ขอบคุณทุกคนที่แสดงความคิดเห็นเกี่ยวกับหัวข้อที่ดำเนินมาอย่างยาวนานนี้