คำถามติดแท็ก versioning

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

2
การกำหนดเวอร์ชันแบบ Semantic เมื่อแก้ไขข้อบกพร่องที่สำคัญ
ฉันกำลังจัดการห้องสมุดซึ่งมีจำนวนมากของการใช้งานของประชาชนและผมมีคำถามเกี่ยวกับความหมายเวอร์ชัน ฉันต้องการ refactor หนึ่งส่วนที่สำคัญพอสมควรของห้องสมุดซึ่งถูกนำไปใช้อย่างไม่ถูกต้อง - และถูกนำไปใช้อย่างไม่ถูกต้อง แต่การทำเช่นนี้จะหมายถึงการเปลี่ยนแปลง API สาธารณะซึ่งเป็นการตัดสินใจที่สำคัญ การเปลี่ยนแปลงที่ฉันต้องการทำให้หมุนรอบวิธีใช้ตัววนซ้ำ ขณะนี้ผู้ใช้ต้องทำสิ่งนี้: while ($element = $iterator->next()) { // ... } ซึ่งไม่ถูกต้องอย่างน้อยใน PHP พื้นเมืองอินเตอร์เฟซ Iterator ฉันต้องการแทนที่ด้วยสิ่งนี้: while ($iterator->valid()) { $element = $iterator->current(); // ... $iterator->next(); } ซึ่งคล้ายกับ: foreach ($iterator as $element) { // ... } หากคุณดูที่คู่มือของ Tom เกี่ยวกับการกำหนดเวอร์ชันแบบ semantic เขาระบุไว้อย่างชัดเจนว่าการเปลี่ยนแปลงใด ๆ กับ …

4
การจัดการสคีมาฐานข้อมูลจะเปลี่ยนไปเมื่อทำการกดเวอร์ชั่นใหม่
ในช่วงเวลาของการพัฒนาอย่างหนักสกีมาของฐานข้อมูลจะเปลี่ยนแปลงทั้งอย่างรวดเร็วและต่อเนื่องและเมื่อถึงเวลาที่เราจะทำการสร้างรายสัปดาห์ไปที่รุ่นต่อ ๆ มาสคีมาก็เปลี่ยนไปมากจนตัวเลือกที่เหมาะสมเท่านั้นคือ คัดลอกเวอร์ชันใหม่จากฐานข้อมูล dev ของฉัน เห็นได้ชัดว่านี่จะไม่ทำงานเมื่อเราเปิดตัวเนื่องจากข้อมูลการผลิต nuking เป็นสูตรสำหรับภัยพิบัติฉันจึงสงสัยว่ามีกลยุทธ์ใดบ้างในการจัดการ schema ของฐานข้อมูลที่เปลี่ยนแปลงจากรุ่นหนึ่ง / รุ่นอื่น บางอย่างที่ฉันพบหรือมีประสบการณ์: ตรง nuke-and-dump จากฐานข้อมูลหนึ่งไปยังอีกฐานข้อมูล (สิ่งที่ฉันทำตอนนี้) การดูแลรักษาไฟล์ UPDATE.sql ด้วยคำสั่ง SQL ที่เรียกใช้ผ่านสคริปต์หรือด้วยมือ การบำรุงรักษาไฟล์ update.php ด้วยค่า "db-schema-version" ที่สอดคล้องกันในฐานข้อมูลที่ใช้งานอยู่ ตัวเลือกที่สามดูเหมือนจะเหมาะสมที่สุด แต่ก็ยังมีความเป็นไปได้ที่แบบสอบถาม SQL ที่สร้างขึ้นไม่ดีจะล้มเหลวในช่วงกลางสคริปต์ทำให้ฐานข้อมูลอยู่ในสถานะที่มีการอัพเดทเพียงครึ่งเดียว ดูเหมือนว่าจะไม่มีปัญหา แต่เกิดขึ้นเนื่องจากเราเป็นทีมเราใช้ phpMyAdmin และฉันไม่สามารถพึ่งพาตัวเองได้จำการคัดลอกคำสั่ง SQL ที่เรียกใช้เพื่อวางลงในไฟล์ update.php เมื่อคุณนำทางไปยังหน้าอื่นฉันต้องเขียนคำสั่ง SQL ด้วยมืออีกครั้งหรือย้อนกลับการเปลี่ยนแปลงของฉันและทำมันอีกครั้ง ฉันเดาว่าสิ่งที่ฉันหวังคือโซลูชันที่ไม่ส่งผลกระทบต่อเวิร์กโฟลว์การพัฒนาของเราหรือไม่

4
รุ่นใหญ่อย่างรวดเร็วชนกับหลักฐานของการออกแบบที่ไม่ดีหรือไม่?
ฉันเริ่มงานเป็นโปรแกรมเมอร์รุ่นพี่เมื่อไม่กี่เดือนที่ผ่านมา ระบบที่เรากำลังดำเนินการอยู่ได้รับการผลิตเป็นเวลา ~ 2 ปี ฉันไม่ได้เกี่ยวข้องกับการขอร้องของระบบและการออกแบบ สิ่งหนึ่งที่ฉันสังเกตเห็นได้คือรุ่นหลักของระบบนั้นมีอยู่แล้ว 11.YZ จากประสบการณ์ของฉันที่ทำงานกับระบบและไลบรารีอื่น ๆ ฉันไม่จำการเห็นผลิตภัณฑ์เวอร์ชันหลักกระแทกอย่างรวดเร็ว มีผลิตภัณฑ์ที่มีมานานหลายปีใน 1.XY และยังคงได้รับคุณสมบัติและแก้ไขข้อบกพร่อง สมมติว่าการใช้เวอร์ชันเชิงความหมายถูกต้องหรือไม่นี่บ่งชี้ว่าระบบได้รับการออกแบบไม่ดีเนื่องจากทำให้เกิดการเปลี่ยนแปลงครั้งใหญ่เกือบทุกสี่เดือนหรือไม่

2
การกำหนดเวอร์ชันแบบ Semantic อนุญาตให้มี 4 คอมโพเนนต์ในหมายเลขเวอร์ชันหรือไม่
ตัวอย่างทั้งหมดของการกำหนดเวอร์ชันทางความหมายที่ฉันเห็นแสดงส่วนประกอบที่ใช้งานอยู่ 3 รายการ ไม่เกิน 2 จุดอักขระ ที่$DAYJOBเราใช้ 4 องค์ประกอบในหมายเลขรุ่นของเรา: 5.0.1.2 การกำหนดเวอร์ชันแบบ Semantic อนุญาตสำหรับสิ่งนี้หรือไม่ และในฐานะที่เป็นคำถามที่อยู่ในระดับที่สูงขึ้นและมีเหตุผลมากขึ้น ฉันเริ่มคิดว่าอาจเป็นความคิดที่ดีที่จะบังคับใช้การกำหนดเวอร์ชันแบบ semantic แต่ท้ายที่สุดเอนทิตีเช่น PCI จะแทนที่ ฉันควรจะชี้แจงความคิดเห็น PCI ของฉัน ปัญหาคือการตรวจสอบและมีผลต่อต้นทุนเมื่อองค์ประกอบหลักและรองเปลี่ยนไม่จำเป็นต้องเป็นคุณสมบัติใหม่จริง ตัวอย่างเช่นหากมีการแนะนำคุณลักษณะที่เกี่ยวข้องกับการชำระเงินเราจะชนหมายเลขรองสำหรับ PCI แต่ถ้าเราเพิ่มฟีเจอร์ใหม่ที่เกี่ยวข้องกับสิ่งที่อยู่ใน gui มันก็ไม่ได้ เฉพาะการแก้ไขแพทช์ ดังนั้นในกรณีนี้เราไม่ได้พูดจริง ๆ ในฐานะผู้พัฒนาเนื่องจากมีคนอื่นทำการตัดสินใจเหล่านั้น

3
REST APIs การกำหนดเวอร์ชัน แต่ละ API มีเวอร์ชันของตัวเอง
เป็นเรื่องธรรมดามากที่จะระบุเวอร์ชันของ REST API ใน URL โดยเฉพาะที่จุดเริ่มต้นของเส้นทางนั่นคือ: POST /api/v1/accounts GET /api/v1/accounts/details อย่างไรก็ตามฉันไม่เห็นการออกแบบที่เกี่ยวข้องกับแต่ละ API กล่าวอีกนัยหนึ่งเรารักษาเวอร์ชันของแต่ละ API แยกจากกัน เช่น: POST /api/accounts/v2 GET /api/accounts/details/v3 การใช้วิธีการนี้ทำให้เราเพิ่มรุ่น API ของ API ที่เฉพาะเจาะจงเมื่อจำเป็นต้องทำการแตกหักการเปลี่ยนแปลงไม่จำเป็นต้องเพิ่มรุ่น API ทั้งหมด อะไรคือข้อเสียของการใช้สไตล์นี้แทนสไตล์ทั่วไป?

5
วิธีการจัดการข้อบกพร่องที่ผู้ใช้คิดว่าเป็นคุณสมบัติ?
คำถาม : เป็นวิธีที่เหมาะสมในการแก้ไขข้อผิดพลาดที่คิดว่าผู้ใช้ปลายทางเป็นคุณสมบัติคืออะไร? การทำอย่างละเอียด : ฉันคาดเดาว่าหากมีผู้ใช้จำนวนมากคาดหวังว่ามันจะเป็นฟีเจอร์มันควรจะอยู่ที่ "ไม่ได้ผสม" หรือ "คงที่" เพื่อให้มีเสถียรภาพมากขึ้นหรือไม่ อย่างไรก็ตามจะเกิดอะไรขึ้นถ้าผู้ใช้จำนวนน้อยมากคาดหวังว่ามันจะเป็นคุณสมบัติ ... พูด 0.1% หรือ 1% และข้อผิดพลาดนี้จะต้องได้รับการแก้ไข ในทางทฤษฎีเนื่องจากนี่เป็นการแก้ไขบั๊กเล็กน้อยจึงสามารถมีคุณสมบัติเป็น PATCH โดยพิจารณาจากการกำหนดเวอร์ชันแบบ semantic: xyZ อย่างไรก็ตามเนื่องจากความเข้ากันได้แบบย้อนกลับ มันจะยังคงมีคุณสมบัติเป็นแพทช์ (เพราะมันไม่ได้มีวัตถุประสงค์เพื่อเป็นคุณสมบัติ) ตราบใดที่มันเป็นเอกสาร? แก้ไข: ในกรณีเฉพาะนี้มันเป็นข้อผิดพลาดใน API ของห้องสมุดที่ใช้ภายในที่นักพัฒนาอื่นใช้

2
หมายเลขเวอร์ชันเป็นส่วนหนึ่งของชื่อไฟล์
ฉันเห็นว่าซอฟต์แวร์บางตัวมีหมายเลขเวอร์ชันเป็นส่วนหนึ่งของชื่อไฟล์ในขณะที่ซอฟต์แวร์อื่นไม่ทำ ฉันคุ้นเคยกับประเภทหลังมากขึ้นและฉันคิดว่ามันเป็นที่นิยมมากกว่า แต่ฉันเห็นประเภทเก่าในห้องสมุดจาวาสคริปต์ ยกตัวอย่างเช่นชื่อไฟล์ jQuery เป็นเหมือนแทนjquery-2.1.0.js jquery.jsเมื่อใดก็ตามที่ฉันอัปเดตไฟล์ประเภทนี้ฉันจะต้องค้นหาสถานที่ในโปรแกรมอื่น ๆ ที่โหลดไฟล์เหล่านี้และเปลี่ยนชื่อไฟล์ที่พวกเขาอ้างถึงและลบเวอร์ชันเก่าของไลบรารีเหล่านี้ด้วยตนเอง ฉันไม่สะดวกดังนั้นฉันค่อนข้างเปลี่ยนชื่อไฟล์เพื่อยกเว้นหมายเลขรุ่นและเก็บชื่อไฟล์ที่อ้างถึงโดยไม่รวมหมายเลขรุ่น ฉันสงสัยว่าตัวเลขเหล่านี้ใช้สำหรับการควบคุมเวอร์ชันบางประเภท แต่ไม่ชัดเจนว่าจะใช้เมื่อใดและอย่างไร ข้อดีและข้อเสียของการรวมหมายเลขรุ่นในชื่อไฟล์คืออะไร มีความเห็นพ้องกันว่าในด้านใดของซอฟต์แวร์หรือภาษาที่ใช้หมายเลขรุ่นในชื่อไฟล์และพื้นที่ / ภาษาใดที่ไม่ได้ใช้? ถ้าเป็นเช่นนั้นมีเหตุผลใดที่

5
กำลังมองหาแนวปฏิบัติที่ดีที่สุดสำหรับการกำหนดหมายเลขเวอร์ชันของส่วนประกอบซอฟต์แวร์ที่ต้องพึ่งพา
เรากำลังพยายามตัดสินใจเกี่ยวกับวิธีการกำหนดหมายเลขรุ่นสำหรับส่วนประกอบซอฟต์แวร์ที่ดีซึ่งขึ้นอยู่กับซึ่งกันและกัน ให้เจาะจงยิ่งขึ้น: องค์ประกอบซอฟต์แวร์ A เป็นเฟิร์มแวร์ที่ทำงานอยู่บนอุปกรณ์ฝังตัวและส่วนประกอบ B เป็นไดรเวอร์ที่เกี่ยวข้องสำหรับพีซีปกติ (เครื่อง Linux / Windows) พวกเขากำลังสื่อสารกันโดยใช้โปรโตคอลที่กำหนดเอง เนื่องจากผลิตภัณฑ์ของเรามีการกำหนดเป้าหมายที่นักพัฒนาเราจะเสนอทั้งสองเวอร์ชันที่เสถียรและไม่เสถียร (ทดลอง) ของส่วนประกอบทั้งสอง (เฟิร์มแวร์เป็นแบบโอเพ่นซอร์สในขณะที่ไดรเวอร์เป็นโอเพ่นซอร์ส) ปัญหาที่ใหญ่ที่สุดของเราคือวิธีจัดการกับการเปลี่ยนแปลง API ในโปรโตคอลการสื่อสาร ในขณะที่เรากำลังใช้การตรวจสอบความเข้ากันได้ในไดรเวอร์ - มันจะตรวจสอบว่าเวอร์ชั่นของเฟิร์มแวร์นั้นเข้ากันได้กับเวอร์ชั่นของไดรเวอร์หรือไม่ - เราเริ่มพูดคุยเกี่ยวกับการกำหนดหมายเลขเวอร์ชันหลายวิธี เราคิดวิธีแก้ปัญหาขึ้นมา แต่เราก็รู้สึกเหมือนการพลิกโฉมพวงมาลัย นั่นคือเหตุผลที่ฉันต้องการได้รับคำติชมจากชุมชนนักพัฒนาซอฟต์แวร์ / โปรแกรมเมอร์เนื่องจากเราคิดว่านี่เป็นปัญหาที่พบบ่อย ดังนั้นนี่คือทางออกของเรา: เราวางแผนที่จะติดตามหมายเลขรุ่นmajor.minor.patch ที่ใช้กันอย่างแพร่หลายและใช้เลขคู่รอง / คู่สำหรับรุ่นเสถียร / ไม่เสถียร หากเราแนะนำการเปลี่ยนแปลงใน API เราจะเพิ่มจำนวนรองลงมา การประชุมนี้จะนำไปสู่สถานการณ์ตัวอย่างต่อไปนี้: สาขาที่มั่นคงในปัจจุบันคือ 1.2.1 และไม่เสถียรคือ 1.3.7 ตอนนี้แพทช์ใหม่สำหรับการเปลี่ยนแปลงที่ไม่เสถียรของ API สิ่งที่จะทำให้หมายเลขรุ่นที่ไม่เสถียรใหม่กลายเป็น 1.5.0 ครั้งหนึ่งสาขาที่ไม่เสถียรถือว่าเสถียรแล้วสมมุติใน 1.5.3 …
15 versioning 


1
สรุปความแตกต่างระหว่างเวอร์ชัน Java? [ปิด]
ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ปิดให้บริการใน2 ปีที่ผ่านมา คำตอบของคำถามนี้เป็นความพยายามของชุมชน แก้ไขคำตอบที่มีอยู่เพื่อปรับปรุงโพสต์นี้ ขณะนี้ไม่ยอมรับคำตอบหรือการโต้ตอบใหม่ อะไรคือความแตกต่างที่สำคัญระหว่างเวอร์ชัน Java ในแง่ของการพัฒนาซอฟต์แวร์? เราจะหาบทสรุปของการเปลี่ยนแปลงที่สำคัญที่สุดที่เกี่ยวข้องกับการเขียนโปรแกรมได้ที่ไหน? บันทึกประจำรุ่นเช่นhttp://www.oracle.com/technetwork/java/javase/releasenotes-136954.htmlอาจอ่านยาก ตัวอย่างเช่นมีโครงสร้างโค้ดใหม่ "สำหรับแต่ละ" ใน Java 1.5
14 java  versioning 

3
กลยุทธ์แพคเกจและรุ่นในสภาพแวดล้อมที่เก็บหลาย
เราเป็น บริษัท เล็ก ๆ ที่มีหลายทีมที่จัดการที่เก็บคอมไพล์ของตัวเอง นี่คือแพลตฟอร์มเว็บและสิ่งประดิษฐ์ของแต่ละทีมจะถูกนำไปใช้ในตอนท้ายของวันสำหรับการทดสอบทุกคืน เรากำลังพยายามทำให้เป็นทางการกระบวนการเกี่ยวกับการกำหนดรุ่นและบรรจุภัณฑ์ ทุกทีมมีสาขาหลักที่พวกเขาทำการพัฒนาแบบวันต่อวัน สมาชิกการประกันคุณภาพของแต่ละทีมต้องการให้สิ่งประดิษฐ์จากการเปลี่ยนแปลงของทีมของพวกเขาถูกนำไปใช้ในห้องทดสอบที่มีการรวมส่วนประกอบทั้งหมดโดยเชฟ Artifacts เป็น tarballs แต่ฉันต้องการแปลงเป็น RPMs เพื่อให้เราสามารถคิดและเหตุผลเกี่ยวกับเวอร์ชันได้อย่างถูกต้อง กระบวนการปล่อยเกี่ยวข้องกับการตัดสาขาที่วางจำหน่ายจากสาขาการพัฒนา (ต้นแบบในกรณีส่วนใหญ่) ของที่เก็บ git แต่ละอัน สิ่งนี้จะมอบให้กับการประกันคุณภาพที่เรียกใช้การทดสอบและลงชื่อออกในชุดของสิ่งประดิษฐ์ ตัวอย่างเช่นนี่เป็นที่เก็บคอมไพล์ทั่วไปที่มีสาขาย่อยที่เกี่ยวข้อง: 0-0-0-0-0-0-0-0-0-0 (master) | | 0 0 (rel-1) | 0 (rel-2) ฉันพยายามที่จะหารูปแบบของแพคเกจที่มาจากสาขาการพัฒนา เราไม่ต้องการติดแท็กสาขาหลักของแต่ละ repo และ จำกัด แท็กเพื่อปล่อยสาขาเท่านั้น แต่เราควรจะสามารถค้นหาแพ็คเกจที่ปรับใช้ในเครื่องทดสอบโดยใช้ซีแมนทิกส์ yum / rpm มาตรฐาน เวอร์ชันการพัฒนาจะมีลักษณะอย่างไรเมื่อสาขาหลักไม่มีแท็ก ฉันเข้าใจว่าgit describeสามารถให้การแสดงเวอร์ชั่นประกอบที่มีประโยชน์แก่ฉันได้ แต่ทำงานได้ดีเมื่อติดแท็กจุดปล่อยต่างๆในสาขา แก้ไข 1: เพื่อตอบสนองต่อคำตอบของ …

2
git, maven และ jenkins - versioning, dev และ release สร้างเวิร์กโฟลว์
เป็นวิธีที่ต้องการทำต่อไปนี้ด้วยคอมไพล์ maven และเจนกินส์คืออะไร: ฉันกำลังพัฒนาแอปพลิเคชันซึ่งฉันต้องการรักษาสาขา "dev" และ "release" ฉันต้องการเจนกินส์เพื่อสร้างทั้งสอง อาจเป็นไปได้ว่าการเผยแพร่สิ่งประดิษฐ์จะมีรุ่นเช่น 1.5.2 และ dev-builds จะเป็น 0.0.1-SNAPSHOTs ฉันไม่ต้องการไฟล์ pom.xml 2 ไฟล์ ฉันดูโปรไฟล์ แต่ดูเหมือนว่าพวกเขาจะไม่สามารถเปลี่ยนเวอร์ชันสิ่งประดิษฐ์ได้ วิธีหนึ่งที่ฉันสามารถดูได้คือการเพิ่ม 'ตัวระบุ' ลงในการทดสอบสร้าง แน่นอนฉันสามารถเปลี่ยนชื่อไฟล์ได้เนื่องจากข้อมูลสิ่งประดิษฐ์จริงในเรื่องนี้ไม่สำคัญเพราะแอปเป็นแบบสแตนด์อโลน สิ่งที่จะเป็นวิธีที่ต้องการในการทำเช่นนี้? หรือคุณจะทำอย่างไร

3
รูปแบบการกำหนดข้อมูลสัมพันธ์ในฐานข้อมูล MySQL?
ฉันกำลังพยายามหาวิธีการสำหรับโครงการที่ผู้ใช้สามารถแก้ไขระเบียนและสามารถดูรุ่นที่ผ่านมาของระเบียนเหล่านั้น นี่คือสคีมาตัวอย่างที่มีการจำลองโดยใช้รายการ: TABLE list ( id int auto_increment primary key, user_id int, title varchar(255) ); TABLE list_tasks ( id int auto_increment primary key, list_id int, title varchar(255), order int, is_complete tinyint ); ดังนั้นผู้ใช้อาจเข้ามาและทำการแก้ไขหลายรายการ (เช่นเพิ่มหรือลบงานสั่งงานใหม่ทำเครื่องหมายว่าเสร็จแล้วเปลี่ยนชื่อบางส่วน ฯลฯ ) จากนั้นบันทึก ณ จุดนี้ฉันต้องการสร้างรายการและงาน 'รุ่น 2' และให้พวกเขาสามารถดูรุ่นก่อนหน้า แต่เมื่อพวกเขาเข้าถึงรายการให้รับรุ่นล่าสุดเสมอ มีวิธีการทั่วไป / รูปแบบการออกแบบสำหรับจัดการกับข้อมูลเวอร์ชันในลักษณะนี้ในฐานข้อมูล MySQL หรือไม่
12 mysql  versioning 

6
กลยุทธ์การแบ่งสาขาและการกำหนดเวอร์ชันสำหรับไลบรารีที่แบ่งใช้
ข้อความเหล่านี้ดูเหมือนว่าเกี่ยวข้อง แต่สมองของฉันเริ่มละลายพยายามคิดผ่าน: P นายจ้างของฉันเพิ่งเริ่มใช้การควบคุมแหล่งที่มาส่วนใหญ่เป็นเพราะก่อนที่พวกเขาจะจ้างนักพัฒนามากขึ้น "ที่เก็บ" คือฮาร์ดไดรฟ์ของ dev ที่โดดเดี่ยวซึ่งทำงานจากที่บ้านเป็นหลัก ทั้งหมดของรหัส .NET เขาต้องการเขียนได้รับการตรวจสอบในว่อนและมีเป็นจำนวนมากของการทำซ้ำ (อ่าน: คัดลอกวาง) ฟังก์ชั่น ตอนนี้ระบบ SCM ของเราได้รับการเชิดชูข้อมูลสำรอง ฉันต้องการดึงรหัสที่ซ้ำกันบางส่วนลงในห้องสมุดสาธารณะ ฉันปล่อยให้ repo ดั้งเดิมอยู่คนเดียวเพื่อที่เราจะได้ไม่ทำลายสิ่งใด - เราสามารถย้ายและ / หรือปรับโครงสร้างโค้ดที่มีอยู่เดิมและเมื่อจำเป็น ดังนั้นฉันจึงตั้งค่า repo สำหรับรหัสใหม่รวมถึงไลบรารี ปัญหาของฉันเกี่ยวกับการกำหนดเวอร์ชันไลบรารี่โดยไม่ทำให้เรายุ่งเหยิงในกระบวนการที่มากเกินไป: โดยยอมรับว่าเราต้องการแนวทางที่สอดคล้องกันมากขึ้นด้วย devs ทั้งหมดที่เขียนโค้ดที่คล้ายกันมากการจัดการและ devs อื่น ๆ เปิดเพื่อจัดระเบียบใหม่ ลงไปได้ด้วยดีถ้าการแก้ปัญหาเริ่มส่งผลกระทบต่อผลผลิต ทางออกที่ดีที่สุดในใจของฉันคือการสร้างห้องสมุดแยกจากกันโดยแต่ละโครงการขึ้นอยู่กับรุ่นที่เลือกและเข้ากันได้โดยเจตนา ด้วยวิธีนี้เรารู้ว่าลูกค้ารายใดมีไลบรารีรุ่นใดที่สามารถทำซ้ำข้อบกพร่องได้อย่างน่าเชื่อถือรักษาสาขาการปล่อยอิสระสำหรับผลิตภัณฑ์และไลบรารีและไม่ทำลายโครงการของกันและกันเมื่อเปลี่ยนรหัสที่ใช้ร่วมกัน สิ่งนี้ทำให้การอัปเดตห้องสมุดยุ่งยากโดยเฉพาะอย่างยิ่งสำหรับผู้ที่ทำงานจากที่บ้าน ฉันคาดว่าห้องสมุดจะเปลี่ยนแปลงอย่างรวดเร็วอย่างน้อยในขั้นต้นเมื่อเรา (ในที่สุด) ดึงบิตทั่วไปเข้าด้วยกัน มีความเป็นไปได้ค่อนข้างมากที่ฉันคิดอย่างถี่ถ้วนและเราก็สามารถสร้างทุกอย่างให้สอดคล้องกับความมุ่งมั่นล่าสุดของห้องสมุดได้ แต่อย่างน้อยฉันก็ควรเตรียมตัวให้พร้อมสำหรับวันที่เราตัดสินใจว่าส่วนประกอบบางอย่างต้องเป็นรุ่นที่เป็นอิสระและ กระจาย ความจริงที่ว่าบางไลบรารีจะต้องติดตั้งใน GAC ทำให้การกำหนดเวอร์ชันมีความสำคัญเป็นพิเศษ ดังนั้นคำถามของฉันคืออะไรฉันหายไปไหน …

5
โครงการแยกที่หมายเลขเวอร์ชันของฉันเริ่มต้นที่ไหน
ฉันได้แยกโครงการและมีการเปลี่ยนแปลงมากมาย ทางแยกนี้ไม่ได้เป็นเพียงการเปลี่ยนแปลงคุณสมบัติเล็กน้อยที่นี่และการแก้ไขข้อบกพร่องที่ฝังอยู่ที่นั่นมันเป็นการเปลี่ยนแปลงที่สำคัญมาก มีการแชร์รหัสหลักส่วนใหญ่เท่านั้น ฉันแยกโครงการนี้เป็น v2.5.0 ในขณะที่ฉันเริ่มรุ่นส้อมของฉันที่ v3.0 อย่างไรก็ตามฉันไม่แน่ใจว่านี่เป็นวิธีที่ถูกต้องหรือไม่ส่วนใหญ่เป็นเพราะเมื่อโครงการนั้นถึง v3.0 สิ่งต่าง ๆ จะสับสน แต่ฉันไม่ต้องการเริ่มต้นใหม่ที่ v1.0 หรือ v0.1 เพราะนั่นหมายถึงช่วงวัยเด็กความไม่แน่นอนและการไม่ refindness ของโครงการ สิ่งนี้ไม่เป็นความจริงเนื่องจากรหัสหลักส่วนใหญ่นั้นละเอียดและเสถียรมาก ฉันหลงทางในสิ่งที่ต้องทำดังนั้นฉันจึงถามที่นี่: อะไรคือวิธีมาตรฐานในการจัดการกับสถานการณ์แบบนี้? ทำส้อมส่วนใหญ่เริ่มต้นใหม่อีกครั้งชนหมายเลขรุ่นหรือทำอย่างอื่นที่ฉันไม่ทราบ
12 versioning 

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.