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

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

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

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

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

4
การจัดการการเปลี่ยนแปลงในสถาปัตยกรรม microservice ที่ขับเคลื่อนด้วยเหตุการณ์
ฉันกำลังทำโครงการวิจัยที่ฉันค้นคว้าตัวเลือกเพื่อจัดการการเปลี่ยนแปลงในสถาปัตยกรรมไมโครบริการที่ขับเคลื่อนด้วยเหตุการณ์ สมมุติว่าเรามีแอปพลิเคชั่นที่ให้บริการต่าง ๆ สี่อย่าง แต่ละบริการเหล่านี้มีฐานข้อมูลของตัวเองเพื่อเก็บข้อมูลในเครื่อง ในการตั้งค่านี้บริการสี่รายการสื่อสารกันโดยใช้ Event Bus ดังนั้นเมื่อมีสิ่งใดเกิดขึ้นในบริการมันจะเผยแพร่กิจกรรม บริการอื่น ๆ ทั้งหมดที่มีความสนใจในเหตุการณ์นั้นจะดำเนินการด้วยวิธีของตนเอง ในกรณีนี้บริการต่าง ๆ ในสถาปัตยกรรมจำเป็นต้องมี "สัญญา" เกี่ยวกับเนื้อหาของเหตุการณ์เหล่านี้ (แอตทริบิวต์ ฯลฯ ) ดังนั้นบริการจึงมี "การพึ่งพาคู่กันอย่างหลวม ๆ " ต่อเหตุการณ์เหล่านี้ คำถามของฉันคือ: เราจะจัดการการเปลี่ยนแปลงในเหตุการณ์เหล่านี้ได้อย่างไร ดังนั้นบริการสมมติว่าลงทะเบียนผู้ใช้ใหม่ในแอปพลิเคชัน ดังนั้นจึงส่งกิจกรรม "" UserRegistered "Service B เลือกกิจกรรมนั้นและประมวลผล แต่นักพัฒนาบางคนในทีมบริการ C ตัดสินใจว่าพวกเขาต้องการเพศของผู้ใช้ที่ลงทะเบียนด้วยดังนั้นเหตุการณ์จึงเปลี่ยนไปและแอตทริบิวต์เพศ ถูกเพิ่มไปยังเหตุการณ์ "UserRegistered" เราจะมั่นใจได้อย่างไรว่า Service B ยังสามารถรับเหตุการณ์เดียวกันด้วยคุณสมบัติพิเศษนั้นโดยไม่ต้องปรับใช้ซ้ำ และมีวิธีอื่นในการแก้ไขปัญหานี้แล้วกำหนดเหตุการณ์เหล่านี้หรือไม่

2
การแสดงละคร Git: เมื่อไหร่ถึงเวที? จะทำอย่างไรถ้ามีการดัดแปลงเกิดขึ้นในภายหลัง
ฉันค่อนข้างใหม่สำหรับโลกกว้างของ Git ฉันอ่านคู่มือและฝึกฝนมาแล้ว แต่ฉันก็สับสนเล็กน้อยเกี่ยวกับมันซึ่งฉันคิดไม่ออกหลังจากค้นหา ฉันสงสัย: ในโครงการ (โพสต์การคอมมิทครั้งแรก) ช่วงเวลาที่เหมาะสมในการจัดทำไฟล์ต้นฉบับคืออะไร ก่อนที่จะตัดสินใจ? ทันทีหลังจากเพิ่ม / ลบหรือแก้ไข? หากไฟล์ถูกจัดฉากกลางคันระหว่างสองคอมมิตและจากนั้นไฟล์จะถูกแก้ไขจะเกิดอะไรขึ้นกับ Git มันต้องการการดูแลเกี่ยวกับการเปลี่ยนแปลงเนื้อหาเมื่อมันถูกระบุและสิ่งที่มันจะกลายเป็นตั้งแต่? ถ้าฉันสร้างไฟล์ใหม่ให้จัดวางและต้องการลบไฟล์ทำไม Git ขอให้ฉันใช้แฟล็ก "-f" และ "git -rm file.ext" ธรรมดาจะไม่ทำงาน ฉันได้อ่าน "What stage หมายถึงอะไร" และวิชาอื่น ๆ ของคู่มือและแบบฝึกหัดอื่น ๆ ใน Git แต่อย่างที่ฉันพูดฉันยังไม่เข้าใจเรื่องข้างต้น ดังนั้นถ้าคุณทำได้โปรดตอบคำถามด้วยคำพูดและตัวอย่างของคุณเองเพื่อที่ฉันจะได้มีโอกาสเข้าใจมันมากขึ้น ขอบคุณ.

2
รุ่น Bump ก่อนที่จะเริ่มการพัฒนาใหม่หรือเมื่อติดแท็กการปล่อยซึ่งดีกว่า?
บางโปรเจ็กต์ชนเวอร์ชันก่อนที่จะเริ่มการพัฒนาใหม่ในขณะที่โปรเจ็กต์อื่น ๆ ชนเวอร์ชันเมื่อแท็กการปล่อย วิธีไหนดีกว่ากัน หากหมายเลขเวอร์ชั่นไม่เปลี่ยนแปลงในช่วงเริ่มต้นของเฟสใหม่ผู้พัฒนาอาจลืมที่จะเปลี่ยนแปลงและเพียงแค่ปล่อยโปรแกรม หากหมายเลขเวอร์ชันเปลี่ยนไปก่อนการแท็กปล่อยดังนั้น 2 หมายเลขเวอร์ชัน (แท็กและ Makefile / AssemblyInfo.cs) จะไม่ตรงกัน git describe อาจให้คุณ v1.2.3.4-15-g1234567 หากการแก้ไขปัจจุบันหลังจาก v1.2.3.4 แต่คุณได้เปลี่ยนไฟล์ไปเป็น v1.2.3.5 แล้ว

1
API การกำหนดเวอร์ชัน
สมมติว่าคุณมีโครงการขนาดใหญ่ที่สนับสนุนโดย API พื้นฐาน โครงการนี้ยังจัดส่ง API สาธารณะที่ผู้ใช้สามารถใช้ (สิ้นสุด) บางครั้งคุณต้องทำการเปลี่ยนแปลงฐาน API ที่สนับสนุนโครงการของคุณ ตัวอย่างเช่นคุณต้องเพิ่มคุณสมบัติที่ต้องมีการเปลี่ยนแปลง API วิธีการใหม่หรือต้องการแก้ไขวัตถุใดวัตถุหนึ่งหรือรูปแบบของวัตถุเหล่านั้นอย่างใดอย่างหนึ่งผ่านไปหรือกลับจาก API สมมติว่าคุณกำลังใช้วัตถุเหล่านี้ใน API สาธารณะของคุณวัตถุสาธารณะก็จะเปลี่ยนทุกครั้งที่คุณทำเช่นนี้ซึ่งไม่พึงประสงค์เนื่องจากลูกค้าของคุณอาจพึ่งพาวัตถุ API ที่เหลือเหมือนกันสำหรับรหัสการแยกวิเคราะห์เพื่อทำงาน (ไคลเอนต์ C ++ WSDL สำหรับไอ ... ) ดังนั้นทางออกที่เป็นไปได้หนึ่งอย่างก็คือการเวอร์ชั่น API แต่เมื่อเราพูดว่า "version" API ดูเหมือนว่านี่จะต้องหมายถึงวัตถุรุ่น API เช่นเดียวกับการให้การเรียกใช้วิธีที่ซ้ำกันสำหรับลายเซ็นวิธีการที่เปลี่ยนไปแต่ละอัน ดังนั้นฉันจะมีวัตถุ clr แบบธรรมดาสำหรับ api ของฉันแต่ละรุ่นซึ่งดูเหมือนจะไม่พึงประสงค์อีกครั้ง และแม้ว่าฉันจะทำสิ่งนี้ฉันก็จะไม่สร้างแต่ละวัตถุตั้งแต่เริ่มต้นเพราะจะจบลงด้วยการทำซ้ำรหัสจำนวนมหาศาล แต่ API มีแนวโน้มที่จะขยายออบเจ็กต์ส่วนตัวที่เราใช้สำหรับ API พื้นฐานของเรา แต่จากนั้นเราพบปัญหาเดียวกันเนื่องจากคุณสมบัติที่เพิ่มเข้ามาจะมีให้บริการใน API สาธารณะเมื่อไม่ควรจะเป็นเช่นนั้น ดังนั้นสติบางอย่างที่มักใช้กับสถานการณ์นี้คืออะไร? ฉันรู้ว่าบริการสาธารณะจำนวนมากเช่น …
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.