คำถามติดแท็ก version-control

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

26 version-control  git  branching 

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

25 version-control  git  svn  branching 

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

25 version-control  git  gitflow 

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

25 version-control  tdd  workflows  personal-projects 

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

25 version-control  teamwork  continuous-integration  builds  branching 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัพเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน5 ปีที่ผ่านมา บริบท: ฉันอยู่ในชั้นปีที่ 3 ของวิทยาลัย นักเรียนแบ่งออกเป็นกลุ่มละ 4 คนเกือบทุกคนจะทำงานภายใต้หน้าต่าง (ยกเว้นบางคนที่อยู่บน linux) เป็นส่วนหนึ่งของหลักสูตรของโรงเรียนเราจะเริ่มต้นทำงานในโครงการสำหรับลูกค้าจริง แต่ฉันและทีมอื่นกำลังสงสัยว่าวิธีใดที่ดีที่สุดสำหรับการแบ่งปันรหัสของเรากับแต่ละอื่น ๆ ฉันทำงานพาร์ทไทม์เป็นเวลา 3 ปีและมีประสบการณ์มากมายในการใช้ทั้งคอมไพล์และ Mercurial ในโปรเจคที่แตกต่างกันดังนั้นฉันจึงไม่มีปัญหาในการใช้ระบบใดระบบหนึ่งหรือระบบอื่น อย่างไรก็ตามเพื่อนร่วมทีมของฉันไม่เคยใช้ระบบควบคุมเวอร์ชันมาก่อน นอกจากนี้ยังมีทีมอื่นที่พยายามใช้ SVN แต่มีปัญหาใหญ่และอยากลองใช้อย่างอื่นดังนั้นพวกเขาจึงถามความคิดเห็นของฉัน ความคิดของฉัน: ฉันได้ยินมาว่า Mercurial + TortoiseHg มีการรวมที่ดีขึ้นภายใต้ windows แต่ฉันสงสัยว่าแนวคิดของหัวหน้าที่ไม่ระบุชื่ออาจทำให้พวกเขาสับสนแม้ว่าฉันจะอธิบาย ในทางกลับกันฉันพบว่ากิ่ง git นั้นง่ายกว่าสำหรับผู้เริ่มต้นที่จะเข้าใจ (แยกการทำงานที่ชัดเจนสำหรับโปรแกรมเมอร์แต่ละคน) แต่ไม่สามารถทำงานได้ดีในหน้าต่าง

25 version-control  git  mercurial 

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

25 version-control 

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา ฉันเข้าใจแนวคิดพื้นฐานของ Git / Github ส่วนใหญ่แล้วในตอนนี้อย่างไรก็ตามฉันยังคงมีปัญหาในการเข้าใจภาพรวมที่ใหญ่ขึ้น นี่คือบางสิ่งที่ฉันสามารถทำให้ทำงานได้จนถึงตอนนี้: ผลักดันมุ่งมั่น ทำงานกับสาขา รวม Github กับ Travis CI ซึ่งเป็นระบบการรวมอย่างต่อเนื่อง Via Travis CI สร้างโดยอัตโนมัติทุกคอมมิทถึงมาสเตอร์และวางจำหน่ายเป็น ZIP บน Github ภายใต้รีลีส อย่างไรก็ตามฉันเพิ่งทำงานกับโปรเจ็กต์เวอร์ชันอัลฟ่า / เบต้าเท่านั้นดังนั้นฉันจึงไม่เคยเห็นเวอร์ชันที่เผยแพร่ในทางปฏิบัติเลย ดังนั้นฉันต้องการเรียนรู้เพิ่มเติมเกี่ยวกับการกำหนดรุ่นการบำรุงรักษารุ่นแยกต่างหากการแก้ไขด่วนรุ่น ฯลฯ ฉันจะมั่นใจได้อย่างไรว่าสิ่งต่าง ๆ ต่อไปนี้เกิดขึ้น: มีเวอร์ชันของโครงการต่าง ๆ ของฉันเช่นเวอร์ชัน 1.1.0 และ 2.0.0 มีความสามารถในการผลักดันโปรแกรมแก้ไขด่วนในรุ่นเรียงลำดับของกระแทกกับรุ่น 1.1.1 หรือ 2.0.1 เป็นต้น สร้างระบบการรวมอย่างต่อเนื่องสร้างรุ่นนั้นโดยอัตโนมัติเมื่อกระทำและหากสำเร็จให้เผยแพร่รุ่นสำหรับรุ่นนั้นโดยเฉพาะ ฉันสงสัยระหว่างตัวเลือกต่อไปนี้: …

24 version-control  git  github  continuous-integration 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา ฉันทำงานเป็นหัวหน้าทีม / นักพัฒนาในสภาพแวดล้อมขององค์กรทางการเงินขนาดใหญ่สำหรับส่วนที่ดีขึ้นของสามปี กระบวนการผลิตของเราเป็นฝันร้ายเพราะมันหมุนรอบ Clearcase เรามีกลุ่มการจัดการการเปลี่ยนแปลงที่ดำเนินการเผยแพร่ทั้งหมดและผู้ที่จะอนุญาตให้ใช้รหัสในการผลิตที่นำมาจากมันเท่านั้น หนึ่งในสิ่งแรกที่ฉันทำเมื่อเข้าร่วมคือการตั้งทีมของฉันกับ Git ทุกคนเห็นพ้องต้องกันว่า Clearcase นั้นแย่มากและไม่สามารถจัดการเรื่องการควบคุมแหล่งข้อมูลได้ทุกวัน ดังนั้นเราจึงตั้งค่าพื้นที่เก็บข้อมูลแบบ "ไม่เป็นทางการ" บนเครื่องท้องถิ่นของฉันและฉันเขียนสคริปต์เพื่อซิงค์ repos คอมไพล์และเคลียร์เคสของเราในช่วงเวลาที่วางจำหน่าย คำพูดนี้แพร่กระจายไปยังทีมอื่น ๆ และหลายคนได้นำกระบวนการเดียวกันมาใช้ การใช้คอมไพล์ในลักษณะ "ไม่เป็นทางการ" สำหรับกิจกรรมประจำวันและ "เป็นทางการ" โดยใช้ Clearcase สำหรับการเผยแพร่ ฉันกลายเป็นคนที่แต่งตัวประหลาดไปแล้วสำหรับปัญหาใด ๆ กับ Git ดังนั้นฉันจึงมีการประชุมสัปดาห์นี้กับ SVP ในการเปลี่ยนแปลงโครงสร้างพื้นฐานที่ต้องการให้ฉันอธิบายถึงข้อดีของ Git ให้เธอฟัง เห็นได้ชัดว่า Word เข้ามาหาเธอบ่อยครั้งใน Clearcase ของฉัน หากเธอยอมรับข้อโต้แย้งของฉันฉันจะได้รับการช่วยเหลือที่นายจ้างของฉันกำจัดตัวเองจากสิ่งที่น่ารังเกียจนี้ ประสบการณ์ของฉันกับผู้บริหารบอกพวกเขาว่าก) ต้องการคำอธิบายสั้น …

24 version-control  business-process 

ฉันเพิ่งเริ่มวางโค้ดของฉันภายใต้การควบคุมเวอร์ชัน (ในแล็บที่ฉันทำงานอยู่ภายใต้ SVN และรหัสของฉันเองใน GitHub (เห็นได้ชัดกับ git) ก่อนที่จะใช้การควบคุมเวอร์ชันฉันเคยทำอะไรแบบนี้ ฉันมีโฟลเดอร์ชื่อห้องสมุดในหลาย ๆ โฟลเดอร์ที่มีหมายเลขเวอร์ชัน ทุกครั้งที่ฉันต้องการเริ่มทำงานกับเวอร์ชันที่ใหม่กว่าฉันจะทำสำเนาของเวอร์ชันล่าสุดเปลี่ยนชื่อเป็นเวอร์ชันใหม่และเริ่มนำไปใช้ อย่างไรก็ตามวิธีนี้ดูเหมือนจะซ้ำซ้อนเมื่อโฟลเดอร์อยู่ภายใต้การควบคุมเวอร์ชัน นอกเหนือจากความซ้ำซ้อนหากมีคนต้องการรับรุ่นล่าสุดพวกเขาจะดาวน์โหลดทุกรุ่นถ้าเขาเพียงแค่imports / clones ตอนนี้ฉันเห็นหลายวิธีในการทำเช่นนี้ด้วยการควบคุมเวอร์ชัน แต่เนื่องจากฉันใหม่สำหรับมันฉันไม่ทราบว่าจะบำรุงรักษาได้ดีกว่า วิธีที่ 1: ใช้แท็ก หากฉันเข้าใจแท็กอย่างถูกต้องคุณจะมีสาขาหลักของคุณคุณยอมรับการเปลี่ยนแปลงใด ๆ ที่คุณได้รับและแท็กด้วยเวอร์ชัน จากนั้นเมื่อคุณต้องการได้รับสำเนาที่ใช้งานได้คุณจะได้รับแท็กที่แน่นอน (ช่วยแก้ให้ด้วยนะถ้าฉันผิด) วิธีที่ 2: เวอร์ชันการแยกสาขา ในวิธีนี้สาขาหลักจะเป็นสาขาการพัฒนา ทุก ๆ ครั้งที่มีการสร้างเวอร์ชันที่เสถียร (สมมติว่าv1.2.0) คุณสร้างสาขาสำหรับเวอร์ชันนั้นและไม่ผูกมัด ด้วยวิธีนี้หากคุณต้องการดาวน์โหลดเวอร์ชันใดรุ่นหนึ่งคุณจะได้รับรหัสจากสาขานั้น แม้ว่าฉันจะบอกว่าคุณไม่เคยยอมทำ แต่ก็เป็นไปได้ที่จะแก้ไขข้อผิดพลาดและผูกมัดกับสาขาของรุ่นเก่าเพื่อให้รุ่นเก่าทำงานต่อไป ตัวอย่างเช่นหากรุ่นปัจจุบันคือv2.0แต่มีคนที่ต้องการใช้v1.2คุณสามารถรับสาขาอื่นจากv1.2คือv1.2.1และกระทำการแก้ไขข้อบกพร่องหรือเพียงแค่ทำให้รุ่นเดียวกันv1.2และเพียงแค่แก้ไขข้อผิดพลาด ดังนั้นกิ่งจะเป็นดังนี้: v1.2.1 v1.2.2 / / v1.0.0 v1.2.0--------- v2.0.0 / / / …

24 version-control  git  svn  branching  release-management 

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา Git เป็นระบบควบคุมเวอร์ชันที่ยอดเยี่ยม หากเราแยกความจริงที่ว่ามันไม่มีการสนับสนุน GUI ที่ยอดเยี่ยมมันดีและรวดเร็วจริงๆ แต่การควบคุมแหล่งที่มาเช่น Clearcase ได้รับการสนับสนุนอย่างมากสำหรับลูกค้าองค์กร บริษัท ต่าง ๆ ลงทุนจำนวนมหาศาลสำหรับเซิร์ฟเวอร์และ licesense แหล่งควบคุม ในบรรดา บริษัท ขนาดใหญ่ส่วนใหญ่อย่าง Google นั้นใช้ Git ผ่านระบบควบคุมเวอร์ชันอื่น ๆ แต่ บริษัท นี้มีกลุ่มโอเพ่นซอร์สที่แข็งแกร่งซึ่งให้การพัฒนาและสนับสนุนเครื่องมืออย่างสม่ำเสมอ (พวกเขาอาจมี Git รุ่นที่กำหนดเองของพวกเขาเอง) ในขณะเดียวกัน บริษัท ขนาดใหญ่ก็ไม่ได้กังวลเกี่ยวกับการยอมรับโครงการโอเพ่นซอร์สและทำให้พวกเขาเกี่ยวข้องกับพวกเขา Git เป็นเครื่องมือที่เชื่อถือได้สำหรับสภาพแวดล้อมขององค์กรโดยเฉพาะบนแพลตฟอร์ม Windows หรือไม่? การสนับสนุนเป็นปัญหาสำหรับ Git เนื่องจากเป็นผลิตภัณฑ์โอเพ่นซอร์ส มี บริษัท ใดบ้างที่ให้บริการโซลูชั่นและการสนับสนุน? ค่าใช้จ่ายของเซิร์ฟเวอร์เป็นอย่างไรเมื่อเปรียบเทียบกับการควบคุมเวอร์ชันอื่นเช่น Clear-case?

24 open-source  version-control  git  clearcase 

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

24 version-control  refactoring  branching 

เมื่อทำงานกับการแก้ไขหรือคุณสมบัติบางครั้งฉันสะดุดปัญหาเล็ก ๆ อื่น ๆ ที่สามารถปรับปรุงได้ทันทีในไม่กี่วินาที เมื่อฉันทำพวกเขาทันทีจากนั้นส่งมอบคุณสมบัติ / แก้ไขที่เสร็จสิ้นแล้วคอมมิชชันมีมากกว่าหนึ่งสิ่ง ยกตัวอย่างเช่นหรือ"add feature X and code clean up" "fix bug X and improved logging"มันจะเป็นการดีกว่าถ้าคุณแยกมันออกเป็นสองคอมมิชชัน ในกรณีที่การเปลี่ยนแปลงสองอย่างเกิดขึ้นในไฟล์เดียวกันฉันไม่สามารถเพิ่มไฟล์เดียวคอมมิทเพิ่มและอีกครั้ง ดังนั้นฉันเห็นสามตัวเลือกต่อไปนี้: จงใจมองข้ามสิ่งที่ไม่เกี่ยวข้องขณะทำงานกับบางสิ่ง คัดลอกไฟล์ที่มีการเปลี่ยนแปลงสองรายการย้อนกลับรวมการเปลี่ยนแปลงหนึ่งกระทำรวมถึงการเปลี่ยนแปลงอื่นกระทำอีกครั้ง อย่าเปลี่ยนสิ่งเล็ก ๆ ที่ไม่เกี่ยวข้อง แต่เพิ่มไปยังรายการสิ่งที่ต้องทำและทำในภายหลัง ฉันไม่ชอบทั้งสามตัวเลือกเพราะเหตุผลดังต่อไปนี้: คุณภาพของรหัสอาจประสบได้หากไม่สามารถแก้ไขปัญหาเล็ก ๆ ได้ และฉันก็รู้สึกไม่ดีถ้าฉันพลาดโอกาสที่จะปรับปรุงบางสิ่งโดยไม่ต้องใช้ความพยายามมาก นี่เป็นการเพิ่มการทำงานด้วยตนเองและเกิดข้อผิดพลาดได้ง่าย นี่เป็นสิ่งที่ดีสำหรับโทโดที่ไม่ได้เล็ก แต่เพิ่มไอเท็มเล็ก ๆ ลงในรายการสิ่งที่ต้องทำและกลับมาอีกครั้งในภายหลังมักใช้เวลานานกว่าการแก้ไขทันที คุณจัดการกับสถานการณ์เช่นนี้ได้อย่างไร?

23 version-control  git 

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

23 licensing  version-control  gpl  closed-source 

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

23 open-source  version-control  dependencies