إستراتيجية إصدار التطبيقات

إستراتيجية إصدار التطبيقات

تداول العملات الأجنبية في سان أنطونيو
أسعار الفوركس في أوغندا اليوم
الفوركس الباكستانية


تدريب تداول العملات الأجنبية في بنغلاديش أفضل نسبة الرافعة المالية فوركس أزواج الفوركس الأكثر تداولا استراتيجيات التداول كفا الفوركس الدولار الأمريكي الين الياباني إغوباي الفوركس وسطاء

كايل ليبر. بعض الأشياء شعرت الكتابة عن. مافين فيرسيونينغ ستراتيغي. لقد أجري الكثير من المناقشات مع المحللين في مؤسستي حول كيفية إصدار البرامج باستخدام مافين و I & [رسقوو]؛ م العثور على هناك سوء فهم مشترك حول ما يعني سنافشوت في الواقع. لقد كنت تبحث عن بلوق جيدة لإرسالها التي تساعد على شرح الإصدار في مافين ولكن للأسف كل شيء أنا & [رسقوو]؛ وجدت فقط يناقش إصدارات الإصدارات وليس كيفية استخدامها كما كنت إعادة تطوير التطبيق. لذلك، قررت أنني سوف تأخذ طعنة في ذلك. أرحب بأي تعليقات ونقد بناء سيساعدني على تحسين هذه الوثيقة، لذا يرجى عدم التردد. أولا، سنافوت ليست نفس الشيء مثل إصدار ألفا / بيتا / الخ. إنها كلمة رئيسية خاصة تعني أنها أحدث إصدار من شفرتك. وهذا يعني أنه يتغير. إذا كنت سحبت سوماب-1.0-سنافشوت أمس ثم حاولت سحب عليه اليوم فإنه من المرجح أن لا تكون هي نفسها. وهذا يعني أيضا إذا كان لديك مشروع يعتمد على إصدار سنافشوت، سوف تحتاج إلى مافين للتحقق من مستودع بعيد عن التغييرات في كل مرة تقوم بتشغيل بناء. الشيء التالي لفهم هو ما هو الافراج عنه في مافين. الإفراج لا يعني أن الإصدار جاهز للإنتاج. وهذا يعني أن المطور قد قرر أنه في مرحلة في تطوره أنه يريد أن يكون رمز مغلق حتى لا تضيع. وقد يرغب أيضا في توزيع هذه الشفرة على شخص ما، ربما مكتبة لديه مطور على فريق آخر يحتاج إلى البدء في تطوير التطبيقات الخاصة بهم أو ربما هو التطبيق الذي سيتم تثبيته على بيئة اختبار للاختبار. لذلك هذا يعني أن الافراج عن المافين يمكن أن يكون ألفا، بيتا، وإطلاق سراح المرشح، والتصحيح، والإنتاج، أو أي شيء آخر تريد تصنيفه كما. منطقي؟ حسنا، ربما المشي من خلال سيناريو لكيفية التعامل مع هذا من شأنه أن يساعدك. أولا يتيح نظرة على استراتيجية الإصدار التي استخدمها: استراتيجية الإصدار. بناء الجملة لهذه الاستراتيجية يستند إلى تنسيق في مافين: المرجع الكامل. الاختلافات هي I & [رسقوو]؛ م إعادة تسمية & لدكو؛ نسخة تزايدي & رديقو؛ إلى & لدكو؛ التصحيح & رديقو؛ وكسر المؤهل الاختياري & لدكو؛ & رديقو؛ إن & لدكو؛ تايب & رديقو؛ و & لدكو؛ محاولة & رديقو؛ لمجرد الوضوح. العلامة & lt؛ & GT الكبرى. - هذا هو رقم يشير إلى تغيير كبير في التطبيق. قد تكون النسخة الرئيسية إعادة كتابة كاملة من النسخة الرئيسية السابقة و / أو كسر التوافق الوراء مع الإصدارات القديمة. العلامة & lt؛ قاصر & GT. - هذا رقم يشير إلى مجموعة صغيرة من التغييرات من الإصدار الثانوي السابق. وعادة ما تتكون النسخة الثانوية من مجموعة من إصلاحات الشوائب والميزات الجديدة ويجب أن تكون دائما متوافقة مع الوراء. العلامة & lt؛ التصحيح وGT. - هذا هو الرقم الذي يشير إلى أن بعض الأخطاء الثابتة التي لا يمكن الانتظار حتى الإصدار الطفيفة المقبل. يجب أن يتضمن إصدار التصحيح إصلاحات الأخطاء فقط وعدم تضمين ميزات جديدة مطلقا. وينبغي أيضا أن تكون دائما متوافقة مع الوراء. إصلاحات الأمان هي مثال على التصحيح نموذجي. [& لوت؛ تايب & غ؛ - & لوت؛ تريبوت & غ؛] - هذا الجزء الأخير اختياري ويستخدم فقط لتحديد أن هذا الإصدار ليس بالضرورة مستقرا. النوع هو كلمة رئيسية ويمكن أن يكون أي شيء ولكن أنا عادة التمسك ألفا، بيتا، و أرسي. المحاولة مجرد رقم للإشارة إلى أي محاولة من هذا النوع هي. على سبيل المثال، بيتا-01، أرسي-02، أرسي-05، إلخ. للحصول على نسخة مستقرة، أترك هذا الجزء، ومع ذلك، لقد رأيت المشاريع الأخرى التي ترغب في استخدام الكلمة من ريليس للإشارة إلى نسخة مستقرة (يمكنك ترك محاولة لأن ذلك لن يكون منطقيا، واستخدام أرسي (إطلاق سراح مرشح) لذلك). مثال سيناريو. حتى الآن للسيناريو. اسمحوا لي أن أقول أنا & [رسقوو]؛ م العمل على تطبيق فوبار. مؤسستي تتوقع مني تقديم فوبار الإصدار 1.0 في نهاية الربع. (لاحظ أقول 1.0 وهو ما يعني أنا & [رسقوو]؛ م فقط باستخدام أول رقمين للإشارة إلى الإصدار، وذلك لأن النسخة الرئيسية والثانوية هي حقا الإصدارات الوحيدة أي شخص يهتمون بخلاف فريق التطوير الخاص بك.أيضا، هناك & نبسب؛ الطريق بالنسبة لي أن أعرف ما سيكون الإصدار النهائي ولكن أنا لا أعرف الرئيسية والثانوية سوف تبقى على حالها.) أنا & [رسقوو]؛ م العمل على فريق رشيقة لذلك أنا ذاهب لنشر ما فعلته في نهاية كل سباق إلى بيئة الاختبار بلدي حتى اختبار بلدي يمكن التحقق من صحة كل شيء. لذلك، هنا ما يمكنني القيام به: وسوف تبدأ مع الإصدار 1.0.0-سنافشوت في بلدي pom.xml في بداية سبرينت # 1. في نهاية سبرينت # 1، وسوف تستخدم مافين-ريليس-بلوجين لإنشاء فوبار-1.0.0-أرسي-01 الافراج عن تطبيق فوبار. سوف البرنامج المساعد تغيير الإصدار من 1.0.0-سنافشوت إلى 1.0.0-أرسي-01، علامة رمز في سم مع فوبار-1.0.0-أرسي-01، ومن ثم بناء أخيرا أن الإفراج عنهم. ثم البرنامج المساعد ثم قم بتحديث الجذع ليكون الإصدار القادم من التطبيق الذي سنترك في 1.0.0-سنافشوت. ثم سوف نشر فوبار-1.0.0-أرسي-01 إلى بيئة الاختبار. وسوف تستمر هذه العملية لسباق السرعة المقبلين حتى نصل إلى مرحلة حيث نحن إلى نقطة حيث نعتقد أننا كاملة. لذلك دعنا نقول إننا الآن في سبرينت # 5. لقد أصدرنا أربعة إصدارات مرشحة الإصدار من التطبيق، وتحديد الخلل وإضافة ميزات على طول الطريق. الآن نحن نشعر فوبار-1.0.0-أرسي-04 جاهز للاستخدام الإنتاج. الآن أنا تشغيل المافين الافراج عن البرنامج المساعد مرة أخرى لإنشاء فوبار-1.0.0 نسخة من طلبي. مرة أخرى، فإن البرنامج المساعد وضع علامة على الإصدار الحالي من التعليمات البرمجية في سم مع فوبار 1.0.0 ومن ثم بناء هذا الإصدار. فإن البرنامج المساعد ثم تحديث الجذع ليكون الإصدار القادم من التطبيق الذي هذه المرة اخترت أن تكون 1.1.0-سنافشوت. لاحظ، أنا زيادة النسخة الثانوية وليس النسخة التصحيح. في عالم مثالي، وأود أن يتم ذلك مع الإصدار 1.0 ولكن بالطبع هذا هو العالم المثالي، وعلى الأرجح أنا و [رسقوو]؛ ليرة لبنانية لديك التصحيح بلدي الإصدار 1.0.0 في مرحلة ما. منذ لا & رسكو؛ ر نعرف متى سيكون I & [رسقوو]؛ م الذهاب إلى مجرد التحرك مع الحياة والبدء في العمل على الإصدار التالي من التطبيق، 1.1. بعد بضعة أسابيع لي فريق كا بلدي يبلغني أنه تم العثور على علة في اختبار الافراج التي تحتاج إلى أن تكون ثابتة. ماذا سأفعل الآن؟ لقد انتقلت ولديها 1.1 رمز جديد في الجذع الذي لا يمكن الذهاب إلى الإصدار 1.0. لا تقلق، أتذكر أن البرنامج المساعد الافراج عن العلامات كل من بلدي النشرات بالنسبة لي. لذلك، أنا إنشاء فرع من علامة فوبار-1.0.0 وندعوها فوبار-1.0.X. ثم أنا الخروج من هذا الفرع الجديد وزيادة إصدار التصحيح إلى 1.0.1-سنافشوت. هذا الفرع الجديد هو الآن بلدي الترقيع فرع. وسوف إصلاح علة ذكرت لي من قبل فريق كا واستخدام البرنامج المساعد الافراج عن إنتاج نسخة التصحيح فوبار-1.0.1. ثم مباشرة بعد إنتاج فوبار-1.0.1 وسوف دمج 1.0.1 التغييرات في الجذع بحيث الإصلاح موجود في الإصدار 1.1 (الذي لم يتم الافراج عنه). ثم أخذ نفسا عميقا والعودة إلى العمل على 1.1. إذا علة أخرى يأتي، ربما حتى بعد أن نخرج إلى الإنتاج، وسوف تستمر للتو العودة إلى بلدي فوبار-1.0.X الترقيع فرع لجعل الإصلاح ودمج التغييرات مرة أخرى في الجذع. استراتيجية مبسطة. أنا لا تستخدم دائما الاستراتيجية المذكورة أعلاه. في الواقع، الكثير من الوقت يمكنني استخدام ما أود أن نسمي نسخة مبسطة من هذه الاستراتيجية. في الأساس، هو الشيء نفسه باستثناء إزالة العنصر & لوت؛ تايب & غ؛ - & لوت؛ تريبوت & غ؛ تماما وبدلا من & لوت؛ باتش & غ؛ ، لدي أكثر عام & لوت؛ إنكرمنتالفرزيون & غ؛ (تماما كما هو الحال في كتاب المافين). لذلك يبدو هذا: لنرجع إلى السيناريو المثال أعلاه ومقارنة الاستراتيجية الكاملة مع هذه الإستراتيجية المبسطة: كما ترون استراتيجية مبسطة يفقد بعض من شجاعة الاستراتيجية الكاملة التي يمكن أن تكون شيئا جيدا وسيئا. لن يكون واضحا ما إذا كان الإصدار جاهزا للإنتاج أم مجرد مرشح الإصدار. ومع ذلك، فهذا يعني أنه لا يتعين عليك اختبار المرشح الذي تم قبوله مرتين. إذا لاحظت إصدار تسليمها بواسطة سبرينت # 4 هو أيضا إصدار الإنتاج. هناك حاجة إلى إعادة بنائه فقط لإزالة -RC-04. لفريق أصغر أو فريق لا يفعل حقا القطع الأثرية التي يستهلكها العديد من المجالات الأخرى هذا قد يكون حلا أفضل لأن هناك الكثير أقل الإصدار لإدارة. تحتاج فقط للتأكد من أنك التواصل بوضوح مع فريقك حتى يعرف الجميع ما يجري. المشاركات الاخيرة. جيثوب ريبوس. تحديث الحالة. klieber على جيثب. كوبيرايت & كوبي؛ 2018 كايل ليبر - الترخيص - بدعم من هوغو و هوغو-أوكتوبريس موضوع. أربعة ريست أبي إصدارات استراتيجيات. توضح هذه المقالة أربعة ريست أبي استراتيجيات النسخ الشائعة ويشرح كيف نقوم بإصدار أبي ريست في زماترز. في زماترز، ونحن نتابع مواصفات سيمفر & # 8211؛ نقوم بتحديث النسخة الرئيسية أبي كلما قدمنا ​​تغييرات كسر. داخليا، نقوم بتحديث إصدارات صغيرة وتصحيح كلما نضيف وظائف والتحديثات المتوافقة مع الخلف. عندما نطلق نسخة رئيسية جديدة من واجهة برمجة التطبيقات زماترز ريست، يمكن للعملاء اختيار إما الاستمرار في استخدام إصدار رئيسي موجود أو الانتقال إلى الإصدار الجديد. ريست هو إلى حد بعيد النمط المعماري البارز المستخدمة اليوم لفضح الخدمات لأطراف ثالثة عبر الإنترنت. ويستخدم معيار هتب بدلا من بروتوكولات أكثر تعقيدا مثل سواب أو ريك. السبب ريست كان ناجحا جدا هو أنه يحاكي كيفية عمل الويب: عديمي الجنسية: لا يحتفظ بسياق العميل بين الطلبات القابلة للتخزين المؤقت: يعتمد على قواعد التخزين المؤقت هتب العميل / الخادم المنحى: يفصل المخاوف بين العملاء والخوادم الطبقات: يستفيد نظام الطبقات وواجهة موحدة. أربعة ريست أبي المشتركة استراتيجيات الإصدار. هناك أربع طرق شائعة لإصدار أبي ريست. 1. الإصدار من خلال مسار أوري. طريقة واحدة لإصدار واجهة برمجة تطبيقات ريست هي تضمين رقم الإصدار في مسار عنوان ورل. يتم استخدام هذه الاستراتيجية من قبل زماترز وكذلك شركات أخرى مثل الفيسبوك، تويتر، إيربنب، وغيرها. هذا الحل غالبا ما يستخدم توجيه أوري للإشارة إلى إصدار محدد من أبي. لأن مفاتيح ذاكرة التخزين المؤقت (في هذه الحالة أوريس) يتم تغييرها من قبل الإصدار، يمكن للعملاء بسهولة ذاكرة التخزين المؤقت الموارد. عند إصدار إصدار جديد من واجهة برمجة تطبيقات ريست، يتم اعتباره إدخال جديد في ذاكرة التخزين المؤقت. يبدو الإصدار الداخلي من واجهة برمجة التطبيقات كما يلي: النسخة الرئيسية: النسخة المستخدمة في عنوان أوري وتشير إلى حدوث تغييرات في واجهة برمجة التطبيقات. داخليا، يعني إصدار رئيسي جديد إنشاء واجهة برمجة تطبيقات جديدة ويتم استخدام رقم الإصدار للتوجيه إلى المضيف الصحيح. إصدارات صغيرة وتصحيحات: هذه شفافة للعميل وتستخدم داخليا للتحديثات المتوافقة مع الإصدارات السابقة. وعادة ما يتم إبلاغهم في سجلات التغيير لإعلام العملاء عن وظيفة جديدة أو إصلاح الأخطاء. هذا الحل لديه بصمة كبيرة جدا في قاعدة التعليمات البرمجية كما إدخال تغييرات كسر يعني متفرعة أبي بأكمله. 2. الإصدار من خلال معلمات الاستعلام. هناك خيار آخر لإصدار واجهة برمجة تطبيقات ريست هو تضمين رقم الإصدار كمعلمة طلب بحث. هذه طريقة مباشرة لإصدار أبي من وجهة نظر التنفيذ. كما أنه من السهل التخلف عن أحدث إصدار إذا لم يتم تحديد معلمة طلب البحث. العيب الرئيسي مقارنة بإصدار أوري هو صعوبة التوجيه. معلمات الاستعلام هي في الواقع أكثر صعوبة لاستخدام لتوجيه الطلبات إلى إصدار أبي المناسبة. 3. فيرسيونينغ من خلال رؤوس مخصصة. يمكن أيضا إصدار واجهات برمجة التطبيقات ريست من خلال توفير رؤوس مخصصة مع رقم الإصدار المضمنة كخاصية. والفرق الرئيسي بين هذا النهج والاثنين السابقين هو أنه لا فوضى أوري مع معلومات الإصدار. 4. الإصدار من خلال التفاوض المحتوى. كورل -H & # 8220؛ أسيبت: أبليكاتيون / vnd.xm.device + جسون؛ فيرسيون = 1 & # 8221؛ مثال / المعهد / المنتجات. وتتمثل آخر إستراتيجية نخاطبها في عملية الإصدار من خلال التفاوض على المحتوى. هذا النهج يسمح لنا لنسخة تمثيل الموارد واحد بدلا من إصدار أبي بأكمله الذي يعطينا السيطرة أكثر دقة على الإصدار. كما أنه يخلق بصمة أصغر في قاعدة التعليمات البرمجية كما أننا لم يكن لديك لشوكة التطبيق بأكمله عند إنشاء نسخة جديدة. ميزة أخرى لهذا النهج هو أنه لا يتطلب تنفيذ قواعد توجيه أوري التي أدخلتها النسخة من خلال مسار أوري. واحدة من عيوب هذا النهج هو أنه يمكن الوصول إليها أقل من واجهات برمجة التطبيقات التي تم إصدارها من قبل أوري: إن طلب رؤوس هتب مع أنواع الوسائط يجعل من الصعب اختبار واستكشاف واجهة برمجة التطبيقات باستخدام متصفح. إن التفاوض على المحتوى هو نهج أكثر دقة لأنه يقوم بإصدار تمثيلات الموارد بدلا من إصدار أبي بالكامل، ولكنه يأتي أيضا بتكلفة تنفيذ عالية لكل من العملاء والمطورين. في كثير من الأحيان، تحتاج إلى التفاوض المحتوى من الصفر كما أن هناك عدد قليل من المكتبات التي تقدم ذلك من خارج منطقة الجزاء. النهج الأخرى هي أسهل لتنفيذ واستخدامها ولكن تحد من قدرة المطور على ريفاكتور بسبب التكلفة العالية لإدخال تغييرات على عقد أبي. أي أفكار أو توصيات؟ ترك تعليق أدناه! ورقة بيضاء مجانية: تعرف على ستاندارد + كيس. تعلم المزيد عن اتخاذ نهج شمولي لتكنولوجيا المعلومات من روب انكلترا في بلوق له، وشك في تكنولوجيا المعلومات، ومن كتبه، بما في ذلك زائد! معيار + حالة النهج. لمزيد من المعلومات، اقرأ ورقة بيضاء جديدة من روب حول تحويل حالات إدارة الحالات غير المعرفة إلى نماذج استجابة قياسية جديدة، مكتوبة ل زماترز: ستاندارد + كيس: كيف نماذج استجابة تكنولوجيا المعلومات محرك العمليات الحديثة. هل نحن بحاجة لجعل باكجينغ (مجلد) وفقا للنسخة الرئيسية؟ سؤال آخر هو، كيف يتطلب إصدار المخطط إذا تغيير أبي تغيير في جداول قاعدة البيانات. أي رابط؟ شيء واحد غير موثقة في كثير من الأحيان هو كيفية إدارة التعليمات البرمجية وجميع الإصدارات التي تدعمها أبي. أنا & # 8217؛ م المهتمة للعثور على نمط جيد لإدارة التعليمات البرمجية وتجنب الكابوس الإصدار. بلدي تنفيذ النهج 3 لربيع-ويبفك: قد تكون أيضا مهتما ب. كيف اخترقنا تجربة إيربنب مع أت & # 038؛ T و هب و إنتيل. جديد سيرفيسينو التكامل يقلل الوقت لحل. موغسوفت و زماترز التكامل يأخذ إدارة الحوادث إلى مستوى جديد. غيبوبة جوبز كان & # 8217؛ ر توقف عن طريق البريد الإلكتروني البث. بحاجة إلى دعم؟ لدينا موقع المجتمع مخصص هو أفضل مكان للحصول على مساعدة على جميع المنتجات زماترز. لدينا فريق من الموظفين دعم الخبراء والمستخدمين داخل مجتمعنا يمكن أن تساعدك على الحصول على الجواب الصحيح. استراتيجيات إصدار البرامج. عالقة الكمال في العالم الحقيقي. إصدار البرمجيات يمكن أن تكون واحدة من تلك المناطق حيث كنت لا تشعر وكأنك حصلت عليه بالضبط الحق. ليس هناك توجيه محدد هناك مع حل من شأنه أن يرضي الجميع. معظم فرق البرمجيات إما الخلط حول هذا الموضوع، أو يختارون تجاهل ذلك. ويهدف هذا الدليل إلى سد الفجوة، وتقديم نظرة عملية على مختلف الاستراتيجيات الشعبية والمفاضلة. بعض التقنيات سوف تكون موجهة نحو ميكروسوفت كومة (ويندوز،)، كما هو ما أنا الأكثر خبرة مع، ولكن المبادئ تنطبق بشكل عام. لينكس، Node.js، بيثون & أمب؛ كما تم تطرق روبي قليلا. إصدارات في كل مكان. نحن جميعا جميلة تستخدم لمصطلح "نسخة" في الوقت الحاضر. الأكثر شيوعا في العالم البرمجيات، فقد تسربت إلى وسائل الإعلام وغيرها من الصناعات. ويجري حاليا إصدار إصدارات الفيلم - "فاست & أمب؛ فوريوس 7" (7!؟)، ويجري الآن إصدار الأحذية - "إير جوردان XX8"، والأكثر شعبية، يتم حاليا إصدار الكتب - "مدير دقيقة واحدة، طبعة 1984". في الواقع، بالنظر إلى الكتب، والناس قد تم إصدار بعض الوقت الآن - "موسوعة بريتانيكا"، منذ 1768! الفرضية بسيطة - حيث أن المنتجات تعيش على ومواصلة تحسين، الإصدارات الجديدة يجب أن تكون متميزة عن الإصدارات السابقة. اسم المنتج لا يتغير، لأن السوق أصبحت بالفعل مألوفة معها، لذلك يتم إلحاق شيء في النهاية للإشارة إلى أنه هو أحدث (أو مختلفة). في حين أن الإصدارات موجودة منذ فترة طويلة من العصر الرقمي، والبرمجيات دفعت حقا القضية إلى الأمام. يعد تعديل نسخة جديدة من البرمجيات وإصدارها عملية سريعة جدا، أسرع بكثير من تغيير خط الإنتاج الصناعي لإنتاج قطعة جديدة من الملابس أو طباعة طبعة جديدة للكتاب. وهكذا دورات التكرار البرمجيات هي أقصر بكثير، وإمكانية للكثير من الطبعات المتزامنة هو أكبر من ذلك بكثير. ببساطة استخدام سنوات (أو حتى أشهر)، كما هو الحال في طبعات الكتاب، ليست كافية. ويمكن إنتاج إصدارات جديدة من البرنامج في غضون دقائق. وبالإضافة إلى ذلك، والبرمجيات لديها جانب مواز هائل لذلك - تيارات البرمجيات - حيث يمكن أن توجد العديد من الإصدارات الرئيسية، وكلها يمكن تحديثها باستمرار في نفس الوقت. هذا نادرا ما يحدث مع حذائك. (أتمنى لو فعلت ذلك، وأحيانا أنا فقط لا أريد أن الترقية إلى نموذج كتالوج هذا العام، أريد تحسين زوجي القديم!) لماذا الإصدار؟ قبل الغوص في كيفية تنفيذ الإصدار، دعونا نتوقف وننظر لماذا نحن نريد أن نفعل ذلك في المقام الأول! بعد كل شيء، إذا كنا نعرف الأسباب الدقيقة لماذا هو مفيد، ثم يمكننا أن نحكم بشكل أفضل ما إذا كانت الحلول المقترحة هي مناسبة. وقد ألمحنا إلى ذلك في القسم الأخير، مشيرا إلى ما يسمى النسخة العامة. هذا هو الإصدار المرئي بشكل عام، وغالبا ما يحمل وزن التسويق (بمعنى أنه من المرجح أن يتم تعريفه من قبل قسم التسويق / المبيعات). "ويندوز 7" و "إفون 5S" و "أوفيس 2018" - كلها أمثلة على إصدار عام. ويهدف الإصدار العام لتكون بسيطة ولا تنسى، مشيرا إلى العملاء أنه جديد & أمب؛ لامعة (على افتراض أن الناس يريدون عموما "جديدة وبراقة"). الناس لا يفهمون "10.6.6527.14789" - لكنهم يحصلون على "2018" أو "5". لقد كانت شعبية متزايدة لاستخدام السنة من الإفراج عن عدد الإصدار العام، كما أنها ببساطة وبقوة ينقل ما يصل إلى تاريخ الوضع. كانت شركات صناعة السيارات تفعل ذلك لفترة طويلة. الإصدار الخاص هو ما كنا عليه في عالم البرمجيات. طابع داخلي (نأمل) يحدد بشكل فريد قطعة معينة من البرمجيات. البرمجيات، مثل سيارة، يمكن أن تكون مصنوعة من أجزاء كثيرة. أخذ قياس السيارة كذلك، السيارة "نسخة خاصة" هو رقم الشاسيه فين. المصنعين الافراج عن والحفاظ على كتالوجات ضخمة من أجزاء، ورسم خرائط لسيارة "أرقام الإصدار". يمكن ميكانيكي ثم أمر جزء بالضبط التي تناسب سيارتك. بدون "رقم الجزء الخاص"، لن تكون قادرا على خدمة البرنامج الخاص بك في البرية، لأنك لن تعرف بالضبط "الشكل" أن وحدة استبدال يجب أن تكون لتناسب النظام العام. تخيل إذا كنت اضطر لتغيير السيارة بأكملها عندما كسر ضوء الذيل. لذلك، يتم استخدام رقم الإصدار الخاص تماما مثل معرف الكتالوج. الغرض منه هو أن تستخدم عند استكشاف الأخطاء وإصلاحها أو صيانة البرنامج. (أنا أحب جيف أتوود في "دوغتاغ" قياسا!) يجب أن خريطة إلى وصف ما قطعة البرنامج هو مثل - ما هو شكله وظيفة. وما أفضل "وصف" من شفرة المصدر الأصلي نفسه! الاستخدام يتلخص أساسا إلى: تحديد شفرة المصدر الأصلية لجزء من البرنامج، لتمكين التصحيح التدريجي وتأكيد عملية معيبة تحديد ما إذا كان جزء واحد "متوافق" مع آخر، أو ما إذا كان يمكن أن يحل محله. يتم إنجاز كل هذا مع رقم الإصدار الخاص. الإصدار العام هو مجرد علامة التسويق، ويخطط إلى واحد أو أكثر من أجزاء البرمجيات الداخلية، ولكل منها نسخة خاصة بها. (تماما مثل تويوتا كورولا 2018 يحتوي على إطار ZRE142 ومحول عزم الدوران 32000-12420) استخدام الإصدار. في ويندوز يتم دعم مفهوم رقم الإصدار بواسطة طبقة من نظام التشغيل. يتم تضمين أرقام الإصدار في كافة الملفات الثنائية القابلة للتنفيذ، ويمكن أن ينظر إليها عند تحوم فوق إيكس / دل في مستكشف ويندوز، أو عند عرض خصائص. في الواقع، أي ملف يمكن أن يكون "الموارد" يمكن أن يكون إصدار، لأنه يتم تخزينها في المورد فيرسيونينفو. ويستخدم التنسيق العام الذي نستخدمه جميعا: main.minor.build.revision (على سبيل المثال "1.2.360.0"). من المهم أن نلاحظ أن كل عدد يقتصر على 16 بت، وحتى لا يمكن أن يتجاوز 65535. وهذا له بعض الآثار على ما يمكن أن تمثل مع هذه الأرقام. لاحظ أن تسمية لهذه الأرقام ليست محددة بدقة - فهي بسيطة 4 أعداد صحيحة قصيرة. ويشار إلى الأولين باسم الرئيسية والثانوية جميلة بالإجماع. آخر اثنين هو حيث نرى بعض الاختلاف، اعتمادا على نظام الإصدار. يستخدم هذا الإصدار بشكل بارز أثناء عملية تحديث ويندوز، والذي يستخدم تقنية ويندوز إنزتالر (مسي) لتحديث أجزاء مختلفة من النظام. بشكل أساسي، يتبع ويندوز إنزتالر قواعد معينة لتحديد ما إذا كان التحديث الذي يتم تثبيته أحدث من ما تم تثبيته بالفعل. إذا كان الإصدار أكبر، ثم انها موافق لتحديث. بطبيعة الحال هذا المفهوم يتدفق إلى الإطار، الذي بني حول العديد من المفاهيم ويندوز القائمة. لدينا فئة الإصدار، الذي يتبع 4 عدد صحيح نموذج. يمكننا أيضا تعريف أسمبليفيرزيوناتريبوت و أسمبليفيليفرزيوناتريبوت، التي تحدد إصدار التجميع ومصدر إصدار ويندوز على التوالي. في الإصدار التجميعي موجود بشكل منفصل عن الإصدار الأساسي الذي يستند إلى ويندوز فيرسيونينفو، وهو ما تراه في مستكشف ويندوز (أو خصائص الملف). وهو يشكل جزءا من اسم الجمعية قوية، ويستخدم حصرا من قبل الإطار عند حل التجميعات. اثنين - نسخة التجميع وإصدار ملف ويندوز - يمكن أن تكون مختلفة، ولكن في كثير من الأحيان أنها هي نفسها لتجنب الارتباك.  يستخدم إصدار تتبع التبعية، بمعنى الإشارة إلى نسخ التجميعات المشار إليها، مما يجعلها واضحة عندما يكسر التحديث التوافق للتطبيق الذي يعتمد على مكتبة معينة. هذه خطوة إلى الأمام من إصدار ملف ويندوز الأصلي، والذي كان يستخدم فقط أثناء عملية التحديث، وليس عند الرجوع إلى مكتبة، مما يؤدي إلى سيئة السمعة "الجحيم دل". ومن الجدير بالذكر أن النسخة ق يسمح 4 أعداد صحيحة 32 بت، في حين أن أسمبليفيليفرزيوناتريبوت يقتصر على 16 بت، كما أنها خرائط مباشرة إلى الموارد فيرسيونينفو. وهكذا، إذا أردنا أسمبليفيرزيوناتريبوت و أسمبليفيليفرزيوناتريبوت أن تكون هي نفسها، وهذا يضع بشكل فعال حد على مكونات الإصدار التجمع كذلك. لينكس، بشكل عام، يستخدم طريقة مختلفة لمعالجة الإصدار. لا تحتوي الملفات الثنائية على طابع إصدار مضمن، مثل معظم ويندوز الثنائيات القيام به. وبدلا من ذلك، يشير اسم ملف المكتبة المشتركة إلى إصداره، على سبيل المثال. /usr/local/lib/mylib.so.1.5. يتم إنشاء عدد من الروابط الرمزية، على سبيل المثال. mylib.so - & غ؛ mylib.so.1 و mylib.so.1 - & غ؛ mylib.so.1.5. يمكن تطبيق مرجع مكتبة عن طريق رابط رمزي، مثل mylib.so.1، والحصول على أحدث نسخة متوافقة 1.x مثبتة. هذا يعمل بشكل جيد إلى حد ما، طالما الجميع يتبع هذه الاتفاقية. كل مكتبة يمكن ثم، بدوره، تحميل المكتبات يعتمد على بطريقة مماثلة. كما سيكون مستخدمو لينوكس على دراية ب "أداة الحزمة المتقدمة" الشهيرة، أبت-جيت، التي تستخدم بشكل واسع على الأنظمة المستمدة من دبيان مثل أوبونتو. كونه مدير حزمة صحيح أنه يدعم تثبيت جنبا إلى جنب الإصدارات وتتبع تبعيات بين الحزم. نلقي نظرة فاحصة على مزايا مديري الحزم في الأقسام التالية. مخططات أرقام الإصدار. هناك العديد من برامج الترقيم نسخة شعبية للبرامج، ولكن كل منهم هو الاختلاف من نفس الموضوع وتبادل الصفات المشتركة. وجود مكونات النسخة الرئيسية والثانوية هو نفسه في جميع المجالات. إن ما يمثلونه متسق إلى حد ما: زيادة عدد كبير: يمثل تغيرات كبيرة في نظام البرمجيات، في كثير من الأحيان غير متوافقة مع الوراء، أو إضافة كمية كبيرة من وظائف جديدة زيادة عدد أقل: يمثل تغييرات تطورية أقل جوهرية، وذلك أساسا التحديثات أو التحسينات في الوظائف الموجودة، أو إضافة جديد أصغر مجموعة الميزات. أعلاه هو دليل واحد فقط - لا توجد قواعد محددة حول ما هي الإصدارات الرئيسية والثانوية من المفترض أن تمثل. فقط أن من المفترض أن تزيد كما يتم إضافة المزيد من الميزات إلى البرنامج مع مرور الوقت. ويندوز وثنائيات تحديد مخطط إصدار 4-جزء: الرئيسية. تحت السن القانوني . بناء. مراجعة . والمكونان الأخيران هما شكلان حران إلى حد ما، وهناك العديد من الاختلافات في ما يمثلونه، فبعضها يستخدم عدادات بناء تدريجية، وبعض تاريخ / وقت استخدام المبنى، وبعضها يستمدها من أرقام المراجعة الداخلية لمراقبة المصدر. يتجاهل الكثيرون رقم المراجعة، والتركيز فقط على البناء. مثبت ويندوز، على سبيل المثال، يحتوي فقط على 3 مكونات. إذا كنت تريد الإصدار الخاص بك لتمتد على كل من الثنائيات والحزمة التي تحتوي على، فمن الأفضل للحد من نفسك إلى ثلاثة أرقام فقط: الرئيسية. تحت السن القانوني . بناء. في أي حال، فإن النمط العام: كلما زاد عدد الإصدار، وأكثر حداثة البرنامج. وقد أطلق على نظام إصدار شعبية في السنوات الأخيرة (وخاصة بين المشاريع مفتوحة المصدر) النسخة الدلالية (الملقب سيمفر)، وتوثيقها في سيمفر. فإنه يقدم بضعة مكونات أخرى، ويجعل نسخة سلسلة أبجدية رقمية، بدلا من رقم نقي - فتح بعض الاحتمالات مثيرة للاهتمام. المكونات الثلاثة الأولى هي نفس ما ناقشنا بالفعل، مع التصحيح يجري اختياري. التصحيح هو إلى حد كبير يعادل عنصر بناء، ولكن الدلالات يمكن أن تكون مختلفة. إصدار الدلالي في الواقع يصف عند كل عنصر يجب أن تكون متزايدة (على أساس "أبي العامة" التغييرات). التجريبي، إذا كان محددا، عبارة عن سلسلة أبجدية رقمية تستخدم لوضع علامة على إصدار كتلك التي تسبق الإصدار النهائي. على سبيل المثال، 1.3.567-rc1 سيسبق 1.3.567. هذا مفيد لإرفاق معنى أكثر إلى تسمية الإصدار من ببساطة عن طريق استخدام الأرقام. تعد البيانات الوصفية عنصرا اختياريا آخر، مما يسمح بوضع علامات إضافية على تسمية الإصدار (عادة باستخدام طابع زمني للبناء)، إلا أنه لا يشارك في ترتيب الإصدار، أي الإصدارات التي تختلف فقط في البيانات الوصفية تعتبر نفسها. بريليليس مفيد مع مديري حزمة مثل نوجيت، التي تعاملهم بشكل مختلف - أنها تعتبر غير مستقرة وغير مرئية لعامة الناس، إلا إذا طلب صراحة. وهذا يسمح بالإفراج عن إصدارات ألفا / بيتا دون التأثير على تلك التي تعتمد على الإصدارات المستقرة. يمكن أن تكون علامات التجريبي مفيدة أيضا في تدفق الإصدار الداخلي عند التعامل مع الإصلاحات العاجلة المتوازية والبنيات الخاصة، كما تمت مناقشته لاحقا في هذه المقالة. إصدار الملفات غير الثنائية. لذلك نحن نعرف كيفية ختم نسخة على الملفات الثنائية. ولكن ماذا عن الملفات الأخرى التي تتألف من نظام البرمجيات - ملفات التكوين والصور والوثائق والخطوط، وما إلى ذلك؟ كيف يمكنك ختم نسخة عليها؟ ماذا عن أطر الويب مثل أسب (أو روبي، Node.js، بيثون، الخ) حيث يمكن تعديل ملفات المصدر والصفحات في مكانها، وتحديثها تلقائيا؟ كيف يمكننا تصحيح نظام ويب، بمعنى تحديث بعض الملفات المستهدفة، وما زلنا نحتفظ بها في الإصدار؟ الجواب هو - لا تحديث الملفات الفردية! لا توجد طريقة بالنسبة لك للحفاظ على رقم إصدار مفيد لتطبيق البرنامج الخاص بك، إذا كان يمكن تحديث الملفات غير الثنائية الفردية المخصصة كإصلاحات عاجلة. تحديث باستخدام حزمة بدلا من ذلك. أهمية البناء والحزمة. عندما تسمع مصطلح "بناء"، عادة ما يتبادر إلى الذهن تجميع - معظم اللغات المترجمة، مثل C #، C ++ أو جافا، يجب أن يتم تجميعها في ثنائي قبل أن تكون قادرة على تنفيذها. وهكذا يرتبط البناء عادة بعملية التجميع. ولكن هذه ليست صورة كاملة. بعض اللغات أو الأطر، مثل بيثون أو أسب، لا تتطلب تجميعا صارما. ويمكن تفسيرها إما في حالة بايثون أو تجميعها على ذبابة في حالة أسب. ما الذي ينبغي القيام به لهذه الأنظمة؟ كيف يمكنك "بناء" تطبيق بايثون؟ هذا هو السبب في أنه من المفيد التفكير في بناء عملية التجميع، أو ببساطة التعبئة والتغليف. تماما مثل خط السلع الاستهلاكية، على سبيل المثال. والأحذية، يحصل تعبئتها قبل الشحن إلى المخازن، لذلك لا نظام البرمجيات، قبل أن يطلق سراحه. مفهوم الحزمة هو ضروري لإصدار، لأن الحزمة هي مجموعة واحدة من القطع التي تتألف من نظام البرمجيات، أو جزء منه، وبالتالي يمكن تحديدها، وختم مع نسخة. مع نظام إدارة حزمة الحق (الذي ننظر في القسم التالي)، يمكن نشرها وتحديثها، وتحديد التبعيات على حزم أخرى. البرمجيات اليوم هو أبدا ملف تنفيذي ثنائي واحد - هو عبارة عن مجموعة من الثنائيات المختلفة والمكتبات والوثائق وملفات التكوين والصور وغيرها من الموارد. حزمة ما يساعدنا على تجميعها معا، الإصدار والافراج عن العالم الخارجي. ولا يلزم أن تكون الحزمة متطورة، على الرغم من أنها تساعد في بعض الحالات (مثل قواعد البيانات). يمكن أن يكون حتى ملف مضغوط بسيط، التي يمكن أن تحتوي على نسخة في اسم الملف، أو جزءا لا يتجزأ من ملف نصي. في الواقع، العديد من المشاريع مفتوحة المصدر تفعل ذلك - الإفراج هو زيب أو أرشيف .tar.gz. الشيء المهم هو أن الحزمة هي وحدة واحدة، التي يتم تحريرها وتحديثها في نفس الوقت، مما يؤدي إلى الاتساق. من الشائع وجود عدة حزم، على سبيل المثال، تمثل مكونات "العميل" و "الخادم"، أو أي تجميع منطقي آخر ينطبق على نظام البرامج. ويمكن بعد ذلك يتم تحديث كل حزمة من تلقاء نفسها. دعونا نلقي نظرة على بعض طرق التعبئة والتغليف المشتركة، ونهج الإصدار، والتطبيق الذي هي الأنسب ل. مثبت الويندوز. أفضل مناسبة: تطبيقات ويندوز غوي كاملة أو خدمات ويندوز أو برامج تشغيل. أقدم، وطويلة الوقت الطريقة الوحيدة الموصى بها، لتثبيت التطبيقات على منصة ويندوز. أنه يحتوي على دعم الإصدار المدمج في ومتطورة (البعض يقول "معقدة") مجموعة من القواعد لتحديد متى لتحديث المكونات. في حين أن حزمة ويندوز إنزتالر (.msi) هو ملف واحد، في جوهره، هو عبارة عن مجموعة من المكونات المنطقية الصغيرة (وصولا إلى ملفات واحدة) التي يمكن تحديثها بشكل مستقل. سيقوم ويندوز إنزتالر بالتحقق من كل ملف فردي يتم تثبيته، سواء كان لديه إصدار وما إذا كان الإصدار أكبر من ملف بنفس الاسم المثبت مسبقا. وهذا يعني أنه من المهم إصدار ليس فقط حزمة المثبت، ولكن كل ملف الواردة فيه. ولكن هذا يعني أيضا أنه من الصعب بشكل لا يصدق للقيام تخفيضات (أي التراجع) مع ويندوز إنزتالر. هو الأنسب لتطبيقات ويندوز التقليدية (واجهة المستخدم الرسومية، والخدمات، والسائقين) التي يتم إصدارها للجمهور. ومع ذلك، فإنه ليس أفضل خيار للداخلية & أمب؛ والتطبيقات الموزعة، وأي نوع من تطبيقات الويب، أو أنظمة قواعد البيانات. كما كان يستخدم لنشر المكتبات القابلة للتوزيع (دلز الأصلي) وكائنات كوم، ولكن مع التركيز اليوم على، فإنه ليس هو الآلية الصحيحة لتوزيع المكتبات. نشر الويب. الأفضل: تطبيقات الويب (إيس، أسب) تم تصميم تقنية نشر الويب خصيصا لنشر التطبيقات ومزامنتها على خوادم ويب ميكروسوفت إيس. يستخدم النسخ المتماثل إيس ويب فارم ويب نشر الأوامر والحزم وراء الكواليس لمزامنة المواقع عبر مجموعة من الملقمات. يحتوي إيس ماناجر على إضافة (تمكين عن طريق تثبيت ويب ديبلوي) إلى "استيراد التطبيق"، والتي يمكن تثبيت أو تحديث تطبيق ويب باستخدام حزمة نشر ويب زيب. أكبر عيب هو أنه لا يمكن إلا أن تستخدم لتطبيقات الويب على منصة مايكروسوفت إيس، وآلية محدودة لتخصيص التثبيت. في حين أنه يمكن أن تكون مناسبة لتطبيقات الويب بسيطة، فإنه يمكن أن تصبح محبطة بسرعة لأي شيء أكثر تطورا، أي المتغيرات والمنطق الشرطي وقواعد البيانات، وما إلى ذلك. وبالإضافة إلى ذلك، فإنه لا يوجد لديه الدعم المتأصل للإصدار. Package Managers. Best Suited : Shared Libraries, Dependencies, Command-line Utilities. Package Managers are great for releasing and versioning shared components, and tracking dependencies between them. For example, if you have a shared library that you want others to use, then a Package Manager allows you to publish multiple versions side-by-side, and for consumers of the library to reference the version they depend on. Package Managers can resolve all inter-package dependencies, and retrieve only the versions that are expected. In effect, Package Managers solve the "DLL Hell" problem. They are best used during development, to resolve library dependencies. However some Package Manager, like Chocolatey for Windows or apt-get for Ubuntu, are geared towards installing complete software. Most importantly, Package Managers are designed around the versioning concept . So they are a perfect mechanism for distributing versioned software libraries. For we have NuGet. A lot of open-source libraries have been published to its online repository, and it is now the defacto standard for distributing 3rd party components. It is encouraged that every team sets up their own NuGet repository to share and publish internally developed libraries in a versioned manner. NuGet can even be used to release complete software systems - see next section. Other development environments have their own - npm for Node.js, pip for Python, gems for Ruby, apt-get on Linux. Package Managers have been proven to be extremely useful, and have exploded in popularity. Octopus Deploy. Best Suited : Internally Developed & Deployed Software. Octopus uses NuGet as the packaging and versioning shell. It is similar to an installer, only driven by PowerShell, meaning infinite flexibility in how the software is to be deployed. PowerShell already has a great support for configuring Windows Services, IIS Web Applications, Scheduled Tasks, SQL Server, and more. For internally developed and distributed software (i.e. for a company running home-grown software solutions) this is a perfect release management vehicle. Packages are versioned and pushed to a shared NuGet feed (e.g. a network share), from where Octopus Deploy can release and deploy each package into the appropriate environment. NuGet here plays a role of the application package/container, with a version stamped on it. Package can be built once, and then deployed as many times as needed to whatever environment. Versioning & Packaging Databases. Database versioning is one of the biggest challenges in software projects. Almost every team I encountered, either completely ignored it or had something inadequate in place. It certainly presents a challenge - database systems mix schema definition with actual live data , and there is no single "file" that can be effectively versioned. We have to recognize the database as an integral part of the software system. One that executes on a proprietary 3rd-party platform (SQL Server, Oracle, PostgreSQL, etc), but the source of which is part of the software definition. It can be compared to script-based systems, such as Node.js or Python, only the scripts are written in a SQL dialect. There are essentially three popular approaches to database versioning, that support automated deployments (I am not considering manual approaches, because they are error-prone, and have nothing to do with real versioning!). DB - Migrations. "Migrations" is a concept where developers keep a set of organized SQL script files, numbered sequentially, where each script applies modifications to the target DB to bring it to the expected state. Whenever a change is needed to the application database, a developer creates a new migration script that applies the delta changes. All of the scripts are kept as part of the source control, and are packaged with the application (either embedded into the executable binary, or installed along-side). A migrations library then checks the target database for a dedicated table which holds the last "migration script number" applied, and then runs all the scripts with a number greater than that in order, effectively applying all of the changes in turn. While this approach is simple to implement, and is favored among several popular frameworks (Ruby Rails, Entity Framework), it has a number of significant short-comings . Firstly, there is no single source view of all database objects (i.e. tables, stored procedures, etc), they are sprinkled through the multiple migration scripts. It is not clear which of the scripts contains which of the modifications. One has to "replay" them all to generate a database, and then look directly in the database (rather than source code). Secondly, the migration scripts number becomes the "version" of the database, which is different from the software package version number for the rest of the application. This is somewhat confusing. In addition, this "version" does not really identify the state of the database, since a database can be changed outside an application without updating the "version". This may potentially break future installs, because migration scripts expect the database to be in a certain state to work. Thirdly, developers have to be disciplined enough to follow the structure and apply ALL changes through migration scripts . Furthermore, when developing and debugging locally, one often has to go through several iterations before getting that table or store procedure change right. Yet only the final changes should make it into the migration script , meaning they have to be remembered and written manually. Otherwise, migration scripts would contain all of the intermediate changes made by all developers on the project. It is easy to see how that can grow out of proportion quickly. Finally, there is an argument that migration scripts are a "history of changes", and it is a bit of a redundancy to store them in source control, which already is a "history" of code changes. We would be storing a history of a history . There's something philosophical about that. Supported by some frameworks and libraries (Rails, DbUp, RoundHousE, EF Code First) Can work with any database Potentially high degree of control over SQL scripts. Have to manually maintain all migration scripts Tracking changes through source control is difficult Not robust against target database out-of-band changes. DB - SQL Compare. Most often this is used in a manual approach, comparing a database between two environments (e.g. development vs test) to copy over the changes. We are considering an automated approach, suitable for the packaging and versioning strategies being discussed. In source control, database is represent by a series of creation scripts (e.g. to create tables, stored procedures, triggers, etc), such that a new database with the right schema can be created from scratch. Usually each script file logically represents a corresponding object in the database, e.g. Table1.sql would be the create script for Table1 table. All of the scripts are included in the released package (sometimes even combined into a large single create script, by concatenating them). The idea is that during automated package deployment a temporary fresh database copy is created, by running all of the creation scripts , and then a SQL Compare tool is executed to compare the pristine copy with the target database to generate a migration delta script on the fly. The advantage of this approach is that it is robust against the target database out-of-band changes, since delta script is generated during deployment , rather than during development. SQL Compare tools (such a RedGate's SQLCompare or XSQL Compare) are sophisticated and mature enough tools that we can have some confidence in the generate SQL code. Each can be controlled by a multitude of options to fine-tune behavior with respect to renames, reordering columns, avoiding drops, etc. In this case, target database is considered as a runtime environment , and we avoid having the issue of versioning it . Instead we version the package that contains all of the creation scripts , which is much easier, and use it to synchronize target database with what's expected in each version. The big disadvantage of this approach is the difficulty of getting it right - there is no off-the-shelf framework that would support it, and it has to be developed. For SQL Server, read the next section for a better approach. For others, some day I may put together the set of scripts and logic necessary to achieve this, based on some of my prior work (unless someone else beats me to it). Automatically detect and migrate changes, regardless of target DB state Only maintaining DDL (i.e. create) scripts in source control, meaning easy change tracking. More difficult to setup, especially to be automated Having to create a temporary database during each deployment (need " create database " permission) DB - DACPAC (SQL Server) For SQL Server there is now a new recommended approach - DACPAC, and it can be produced by Visual Studio 2018 and above, if using the SQL Server database project. Really, this is a slick variation of the "SQL Compare" method above, just that Microsoft has done all the heavy lifting for you! Essentially, DACPAC is a zip package which contains an XML schema model of what the target database should look like. It is compiled by Visual Studio based on the creation scripts in your project. In fact, it represents that temporary pristine database that we would have had to create manually. Only it is done automatically and the schema represented in an XML format. The real bonus is that a DACPAC can be versioned , i.e. its metadata supports storing a version number. SQL Server Data Tools can be used to deploy a DACPAC package, which really performs a SQL Compare operation between the in-memory database model loaded from DACPAC and the target database. It does the same thing as SQL Compare, but avoids having to create the extra temporary database copy to do the comparison. For applications having SQL Server as a back-end, a DACPAC can be included as one of the deployable packages, stamped with appropriate version generated during the build. Starting with SQL Server 2008 R2, database can be registered as a Data-Tier Application, and the latest DAC version is tracked in a system view that can be queried. Can package the whole DB definition into a single package (or several packages) Can apply the same version to the package as the rest of the software system Same advantages as the SQL Compare method. SQL Server only Need to treat lookup data in a special way (post-deploy MERGE script) Build Auto-versioning. Given the importance of consistent versioning discussed above, it makes sense to implement a strategy for automatically generating and stamping a version number during the software automated build process. We want the version number to be applied to the produced packages, and also applied to all the binaries generated through compilation. There are several well-known and not so well-known ways of achieving this. We look at pros and cons of each. Applying Build Number. There are some who prefer to update the version number manually just before a release. I will argue that this is a bad practice. Firstly, it is easy to forget to do it, if you don't have an automated system for incrementing the version build number. And, if it is easy to forget, it will be forgotten at some point. Secondly, without automatically updating build number, there will be multiple packages produced from the source code that have the same version number, but different functionality (as more commits are made to the source control). This will be confusing to say the least. It is better to have a process, like ones described below, where version number build component is automatically updated whenever a non-local build is made. Multiple Versions for Multiple Components. If there are multiple software components, where each needs to have its own version number, then it is best to split them each into its own separate build. Don't mix multiple version numbers in the same build, as it unnecessarily increases the complexity, and raises a question about which of the build numbers should be used to label the build itself (in addition to having to tag each source sub-tree separately). Developer vs Continuous vs Release Builds. Release build is the one that will potentially be released to public or a particular environment - test, staging, production, etc. That's the build that needs to be consistently versioned to keep track of changes that are included and to link back to the source code at the time of compilation. Note that the Release build can scheduled - it is popular to have a Daily or Nightly build. In most situations it should be the Release build, i.e. it should be versioned and packaged ready to be released. Continuous Integration builds run whenever someone commits to the repository and are used to validate that the code compiles, and passes unit tests. There is no need to version this build, as it is not intended to be released. Developers must also be able to do a Developer build , whether it is to test/fix the build process itself, or to generate shared software components to be used in development. Such builds are intended to be run locally only and should never be publicly released. You can default the build part of the version number to "0". This will identify Developer builds, i.e. ones that are not supposed to be released. For Release builds pass the build number to your build scripts as a property. Have MSBuild stamp a version number on all generated assemblies and packages. Tagging Source Control. Since one of the primary reasons for having a version number is to be able to link back to source code used to build the software (see beginning of the article), it is important to create tags/labels in source control that identify the state of source code at the time that version was built. Various systems call it differently - TFS has "Labels", Git has "tags". Tag should include the full version (including the build number) of the build, so that it can later be found, if needed. Build Number - Version File Auto Increment. Common technique is to record version number together with source code, usually in a separate file (e.g. "version.txt"). The build process then finds the file, reads the version, increments the build number portion, and commits the file back to repository. If the commit message also includes the version number, e.g "Auto-increment: 1.3.156.0" , then it comes in handy when viewing commit history. You can see the changes that occurred between versions clearly by seeing the commits between the two "Auto-increment: . " messages. This works fairly well, but has a few drawbacks. Mainly due to the fact that "version" becomes part of the source code. When merging changes between say release branch and main, you have to resort to "cherry-picking" (i.e. selecting just the code changesets) to avoid merging the modified version number. That requires being always careful, because you can accidentally change the versioning sequence of another branch just by merging the "version file" into it. Control over the build number sequence (i.e. sequential) Can make it easy to see changes between versions in source control history. Difficult to control merging between code branches in source control. Build Number - External. Overcoming the drawbacks of the auto increment approach, it is possible to track the build number outside of the source tree. Build server software such as CruiseControl or TFS Builds can do that - they track a build number internally for each "project" and are able to pass it as a parameter to MSBuild. Version file is still used, but it records major and minor versions only, and doesn't have to change between each build. This makes it easier to merge changes from release branches back to main and others, since they will contain only code changes, without being intermingled with version increments. Major/minor version changes would occur early in the development cycle, when starting work on the next update, and are already set by the time release branch is created. Not modifying source tree on every build makes merging between branches easier Versioned builds are forced to be built by a dedicated build server. Relies on a build system that can supply a build number (e.g. CruiseControl, TFS Builds) Changing build number sequence can be difficult (e.g. TFS Builds) Build Number - Derived from Date/Time. A popular alternative is to derive build number for the date/time of the build. The advantage being that it carries more meaning (useful in diagnosis), and each build inherently should get a different build number (with later builds getting a higher number). The trick, of course, is fitting all this into a 16-bit number, if using the standard 4-part Windows version number. While some solve it by using both, the build and revision components, I cannot recommend it, because revision cannot always be applied to external packages (like Windows Installer, or NuGet), which use only a 3-part version number. This only allows only 4 unique builds per day, which is not a lot, unless all you want is a daily build . Not depending on keeping track of the last build number Build number can be given more meaning, if it derives from a date. Build number is not sequential (but it increases nevertheless) Limited to 16-bit (maximum 65535), so some overflow into revision (4th) number. Build Number - Derived from Source Control. A variation of the previous technique is to derive build number from a unique property in source control. With a centralized SCM like Subversion or TFS, a revision or changeset number is an ever increasing number that is tied directly to the source code. The big problem with it is that it can quickly overflow the 16-bit limit, meaning you may have to accept build numbers looping back to zero. An alternative in distributed SCM, like Git, is to use the size of the commit history log as the build number. This will monotonously increase for any single branch, as new commits are made. It too can overflow the 16-bit limit, but goes a lot further than the global revision number. Example: git rev-list HEAD --count. Not depending on keeping track of the last build number No possibility of "forgetting" to update version file, or accidentally merge it to/from another branch. Commit history size will grow beyond 65,535 at some point, overflowing the 16-bit build number. Parallel Branches. It's no secret that developing for multiple versions requires multiple branches in source control, each representing a "version" stream for the software. They can be roughly divided into: Development branches - where unstable code for the next version lives, and where developers commit daily work Feature branches - veering off from development branches, encorporating larger feature development, that would otherwise disrupt other team members Release branches - representing versions of released software, or a release undergoing stabilization. Each release branch needs to have an identifying version, and is usually named after it, e.g. "1.7" . A decision of whether to create a new release branch depends on how long it is expected that it will be in stabilization mode before releasing, and whether concurrent live versions are permitted (i.e. for packaged software). If you need to be able to maintain & hotfix the current released version, while a new version is being tested & stabilized, then create a new branch. Development and feature branches need to have a version number that is above any of the existing release branches to avoid confusion. For example, if a 1.7 release branch is created, for the upcoming 1.7 release, then immediately update development branch version sequence to 1.8 . Versioning feature branches is more difficult, since you don't want to start a new versioning sequence for every feature . Nothing should be "released" from feature branches, so this version is for internal purposes only. If using Semantic Versioning, attach a prerelease tag to clearly indicate this is a version for a feature branch, e.g. 1.8.781-dev-feature-x . In any case, you wouldn't deploy anything built from a feature branch to the shared testing or production environment, or release a package from it. So it is acceptable to have version sequence overlap with that of development branch. Finally, in the next section we look at how to version patches & hotfixes that are applied to release branches. Handling Patches / Hotfixes. Devising a system to handle patches depends heavily on the rest of the software development cycle, which is what many teams forget when searching for the "one, true way" of handling concurrent patching of the released/production software in parallel with working on the new version. For example, having a short QA/test cycle, where most of the tests are automated, results in a more simplified and robust system, which does not have to deal with multiple parallel hotfixes "in test". Overlapping hotfixes. One difficulty that comes with managing parallel development is consistent versioning and deployment strategy that would overcome inherent conflicts. Consider following scenario: you have recently released a software package 1.5.167. Two urgent show-stopping issues have slipped past your QA process and now require a quick fix. You assign two developers to work on each one in parallel. How would they commit their fixes to minimize conflicts? How do you test each fix? How do you release one independent of the other? This is a good example of the complexity of software release processes that can be encountered in real-world teams. It applies both to internal software and packaged software, but distribution of the hotfix might be slightly different for each one. First, let's consider what happens if we remove concurrency . In the case where the two issues are worked one after the other , the solution becomes simple. The first fix gets committed into the maintenance/hotfix branch for 1.5 release stream, a new build is generated, with an incremented build number. Build goes through a quick QA cycle to make sure there is no regression, and then it is ready to be deployed. Same process repeats for the second fix. The problem with concurrent approach is the time when development is in parallel, creating the entangled case where there is no build/package that contains only one of the fixes , i.e. independent of the other. This problem is magnified by a slow QA cycle , usually meaning there are no automated tests. While one fix is in test, if a commit for a second fix is made to the same branch, and a problem is discovered with the first one, it becomes very difficult to separate the two now. The culprit here is, of course, the concept of a partial fix - the state where the fix is not complete. It has been committed, but has a problem with it, requiring further commits . This can easily create the case of a hotfix branch where the two fixes are "entangled" (quantum physics on the code level!). Solution is to remove possibility of a partial hotfix . This means that each hotfix has to be coded and tested in a separate code stream, independent of the other. Once tested, and ready for release, it is merged into the main hotfix release branch, where the automated build can create a new package and apply versioning (i.e. increment build number, for example, to 1.5.168). Second hotfix, once tested, also has to be merged into the main hotfix release branch. But, because during the work on this second hotfix, the first hotfix got released, we first merge the first hotfix into the second hotfix's branch ! This ensures that we can test how the second hotfix operates, when applied on top of the first hotfix, and merge any code conflicts, if any. In the end, you want a system with both hotfixes applied - that is the "next" version. So it makes sense that whatever hotfix is "second", it is applied on top of the "first" one. And creating a packaged release from the single hotfix release branch ensures that the version number is consistently incremented for the whole system. Of course, above means that we must create a separate branch for each hotfix. Some version control systems, namely Git, make this very easy and part of the expected developer workflow. If you are using a version control system like TFS, then creating new branches for each hotfix is a bit more painful. In TFS, I suggest using named Shelvesets feature to emulate Git's process, and perform initial QA tests for a hotfix from a Shelveset-branch build. Then commit Shelveset into the hotfix branch to build the official hotfix package (and perform necessary merging). What about the versioning of the interim hotfix builds ? The main hotfix release branch would have a standard versioning scheme applied (as discussed above), either incrementing a build number, or using a timestamp. Each new hotfix, applied on top of all previous hotfixes, gets an increased build number , and the software version keeps moving forward. However, when building from the developer hotfix branch (or Shelveset in TFS), we also need to apply a version to distinguish it from other builds, and be able to deploy it into QA/test environment. We want to be able to test each hotfix in isolation, applied on top of an existing released version of the software system. This becomes problematic, if you have a single test environment . You do not want to apply both hotfixes into one test environment, because there is no guarantee that they won't conflict or affect each other. If you are able to quickly spin up a test environment for a hotfix development branch, then you can truly parallelize team efforts. For a shared test environment, they have to be applied one at a time : Force install latest release version (e.g. 1.5.168) to bring environment to a known state Install the hotfix version to be tested Perform the tests (preferably automated) For shared test environnments this is the bottleneck, since no other hotfixes can be tested at the same time (automation can help minimize the time spent in this step) Repeat 1-3, until tests are satisfactory. What this means is that each hotfix has to have its build version number greater than the latest released version, the one it is being applied on top of. There are several ways to achieve that. If using a derived build number , this should just work out of the box. If incrementing or using external build numbers, then the easiest option is to simply force the build for hotfix development branch (or Shelveset) to use a number greater than latest released version (i.e. .168). With Semantic Versioning, we can setup hotfix builds to use a "prerelease" tag that clearly marks it as a hotfix-test build. For example - 1.5.169-check14761 , where the trailing number could be a reference to the issue tracking system. This works especially well when using NuGet as the packaging mechanism. Once tested, the changes can be merged into hotfix release branch, and an official build generated, with incremented build version number. NOTE: Above process to resolve concurrent hotfixes is undoubtedly complicated. It is intended to solve a particular real-world scenario, but one that does not happen too often. If there are no concurrent fixes expected, you can simplify your life by applying fixes directly to the hotfix release branch. Patching a large system. If applying hotfixes to a large system, we don't want to upgrade the whole thing, which may involve a lot of different components - services, GUI applications, scheduled jobs, databases, etc. Instead, we want to apply the fix only to affected parts. This is where splitting the system into multiple packages helps. Each corresponds to a logically contained piece of the system - for example, each service, application, database, etc is its own package. That means they can be patched independently by applying just that package . Care must be taken about dependencies, if hotfix affects multiple packages at once. Although, in that case, ask yourself is it really a hotfix or a new minor version? Patching for specific installation. Some software shops may have developed the practice of patching the software for individual customers (for packaged software), in other words creating a "custom" version for just that installation, without including this fix in the rest of released software streams. This is one of the worst situations to be in, with regards to versioning, since it creates a large number of variations that have to be maintained separately. Instead, release a general update , moving the overall software version forward for that release stream. Adopt a "feature" system , where parts of the software can be turned on & off based on configuration. If a specific fix is needed for a particular installation, then that code can be encapsulated behind a configuration switch which turns this section of the code on or off. That particular customer can turn it on , while the rest can have it off! This is also a popular technique in web applications, of which only one installation exists (on the server), where various "features" can be enabled based on "configuration" for each user , or a set of users. Patching the changes only. There is often the temptation to simply patch in the changes to the live/production system by editing/replacing one file, or updating one table or stored procedure. The change is small, and it seems like the fastest way to solve the imminent issue, without changing anything else in the system. While it seems like a smaller risk to make only the necessary updates directly, it makes it a whole lot harder to know the state of the system in the future. As more and more such "small" patches get applied, there is no longer any reliable way to link the running system back to the original source code, making further maintenance exponentially more complicated (and, ironically, increasing the risk). Updating individual non-binary (e.g. config files) or altering database objects does not update any version number . That means it is difficult to tell which changes have been made to the system, leading to "maintenance hell" (a variation of the infamous "DLL Hell"). Rule of thumb: Any change to the system should change the version number. NOTE : Windows Installer allows a so called "small update", where product version number does not have to change, used for small hotfix patches. I believe this creates too much confusion, and so I do not recommend it. Windows Installer does track each patch, through package code, so you always know which patches have been applied. But it means now having to track and remove patches on subsequent product updates, which complicates the process. It may work for Microsoft Windows and Microsoft Office, but I wouldn't recommend using it for any system. الكلمات الأخيرة. This turned out to be a much longer article than I originally anticipated when I sat down to write about versioning . I am hoping it proves useful for software engineers out there looking for some guidance on how to apply these concepts in their own projects. Still this seems like only a partial treatment of the topic. Everything I wrote above has been learned through the painful process of trial & error over the years. If just a few readers have an "aha!" moment while reading this, then I have achieved my goal!

Application versioning strategy

الحصول على فيا أب ستور قراءة هذه المشاركة في التطبيق لدينا! What is your application versioning strategy? [مكرر] هذا السؤال له إجابة هنا: I would be interested to get the SO community's opinions on the best application versioning strategy. How do you keep track of your application's version number? Do you have a formal definition of what each number/character in that version represents? What do the different numbers/strings in the application's version mean for your app? Do you use any automated updating system in your apps (e.g. something like Sparkle) and how good has it been behaving for you? Do you have a separate update procedure for beta-testers or pre-release testers of your app? migrated from stackoverflow May 18 '11 at 13:48. This question came from our site for professional and enthusiast programmers. How do you keep track of your application's version number? Do you have a formal definition of what each number/character in that version represents? What do the different numbers/strings in the application's version mean for your app? I use following: Major - Major version is a definite release of the product. It increased when there are significant changes in functionality. Minor - Minor version is incremented when only new features or major bug fixes have been added. Upgrade/Patch - Upgrade refers to the replacement of a product with a newer version of product.It is incremented only when upgrade is provided on designated major release.Patch version starts with 0 and incremented only when bug has been resolved. Build No - Build Number is incremented when new build is created. Do you use any automated updating system in your apps (e.g. something like Sparkle) and how good has it been behaving for you? We use building tool which automatically builds app at night which we call nightly build and this increases build number every time a build is created. Do you have a separate update procedure for beta-testers or pre-release testers of your app? No. Tester tests over nightly build at every morning which we call BAT(Build Acceptance Test) and verify nightly build. Let me note first there seem to be no agreement on the "best" strategy. I can only share my experience on a current project. The system version is defined manually in a build property. It happens when the team agrees on a new release. As additional versioning we use the build number which is automatically generated by the CI build. We loosely follow the Ubuntu naming scheme YY.MM.version.patch_buildNumber as we have found that Major.Minor versioning messes up customer expectations ;) There are no automatic updates as the application has to be rolled out by adminstrators. The test releases are more frequent than GA releases, but that should be all. I tested many version systems and now I'm pretty happy with this one: Major is set manually and refer to a version including major improvements Minor is also set manually and refer to an upgrade/maintenance release, including minor improvements & fixes Revision is generated automatically and refer to an exact revision in the repository. The last one allows us to be very flexible with versionning. We can ship multiple versions for multiple clients and still be able to debug & fix with ease by getting the specific version from the repos, then merge back with the trunk. The build, packaging & publishing is fully automated. The only manual action is when we move the last package to the production server by FTP. We want to keep the control on that to ensure we don't deliver crap in production. It goes to a preliminary stage where early adopters can read the release notes and then decide to download and use the version. Customers that face specific bugs can get a fixed version very fast by using one of these versions. I use Semantic Versioning for my open source libraries and find it much easier to work with other libraries which do as well. It provides a common basis for understanding what a version change might mean. Is the library still in beta? Is a release just for bug fixes? Will there be breaking API changes? It's basically a codification of the best versioning practices already used by most open source projects. Semantic Versioning 2.0.0. Given a version number MAJOR.MINOR.PATCH, increment the: MAJOR version when you make incompatible API changes, MINOR version when you add functionality in a backwards-compatible manner, and PATCH version when you make backwards-compatible bug fixes. Additional labels for pre-release and build metadata are available as extensions to the MAJOR.MINOR.PATCH format. المقدمة. In the world of software management there exists a dread place called “dependency hell.” The bigger your system grows and the more packages you integrate into your software, the more likely you are to find yourself, one day, in this pit of despair. In systems with many dependencies, releasing new package versions can quickly become a nightmare. If the dependency specifications are too tight, you are in danger of version lock (the inability to upgrade a package without having to release new versions of every dependent package). If dependencies are specified too loosely, you will inevitably be bitten by version promiscuity (assuming compatibility with more future versions than is reasonable). Dependency hell is where you are when version lock and/or version promiscuity prevent you from easily and safely moving your project forward. As a solution to this problem, I propose a simple set of rules and requirements that dictate how version numbers are assigned and incremented. These rules are based on but not necessarily limited to pre-existing widespread common practices in use in both closed and open-source software. For this system to work, you first need to declare a public API. This may consist of documentation or be enforced by the code itself. Regardless, it is important that this API be clear and precise. Once you identify your public API, you communicate changes to it with specific increments to your version number. Consider a version format of X.Y.Z (Major.Minor.Patch). Bug fixes not affecting the API increment the patch version, backwards compatible API additions/changes increment the minor version, and backwards incompatible API changes increment the major version. I call this system “Semantic Versioning.” Under this scheme, version numbers and the way they change convey meaning about the underlying code and what has been modified from one version to the next. Semantic Versioning Specification (SemVer) The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in RFC 2119. Software using Semantic Versioning MUST declare a public API. This API could be declared in the code itself or exist strictly in documentation. However it is done, it should be precise and comprehensive. A normal version number MUST take the form X.Y.Z where X, Y, and Z are non-negative integers, and MUST NOT contain leading zeroes. X is the major version, Y is the minor version, and Z is the patch version. Each element MUST increase numerically. For instance: 1.9.0 -> 1.10.0 -> 1.11.0. Once a versioned package has been released, the contents of that version MUST NOT be modified. Any modifications MUST be released as a new version. Major version zero (0.y.z) is for initial development. Anything may change at any time. The public API should not be considered stable. Version 1.0.0 defines the public API. The way in which the version number is incremented after this release is dependent on this public API and how it changes. Patch version Z (x.y.Z | x > 0) MUST be incremented if only backwards compatible bug fixes are introduced. A bug fix is defined as an internal change that fixes incorrect behavior. Minor version Y (x.Y.z | x > 0) MUST be incremented if new, backwards compatible functionality is introduced to the public API. It MUST be incremented if any public API functionality is marked as deprecated. It MAY be incremented if substantial new functionality or improvements are introduced within the private code. It MAY include patch level changes. Patch version MUST be reset to 0 when minor version is incremented. Major version X (X.y.z | X > 0) MUST be incremented if any backwards incompatible changes are introduced to the public API. It MAY include minor and patch level changes. Patch and minor version MUST be reset to 0 when major version is incremented. A pre-release version MAY be denoted by appending a hyphen and a series of dot separated identifiers immediately following the patch version. Identifiers MUST comprise only ASCII alphanumerics and hyphen [0-9A-Za-z-]. Identifiers MUST NOT be empty. Numeric identifiers MUST NOT include leading zeroes. Pre-release versions have a lower precedence than the associated normal version. A pre-release version indicates that the version is unstable and might not satisfy the intended compatibility requirements as denoted by its associated normal version. Examples: 1.0.0-alpha, 1.0.0-alpha.1, 1.0.0-0.3.7, 1.0.0-x.7.z.92. Build metadata MAY be denoted by appending a plus sign and a series of dot separated identifiers immediately following the patch or pre-release version. Identifiers MUST comprise only ASCII alphanumerics and hyphen [0-9A-Za-z-]. Identifiers MUST NOT be empty. Build metadata SHOULD be ignored when determining version precedence. Thus two versions that differ only in the build metadata, have the same precedence. Examples: 1.0.0-alpha+001, 1.0.0+20180313144700, 1.0.0-beta+exp.sha.5114f85. Precedence refers to how versions are compared to each other when ordered. Precedence MUST be calculated by separating the version into major, minor, patch and pre-release identifiers in that order (Build metadata does not figure into precedence). Precedence is determined by the first difference when comparing each of these identifiers from left to right as follows: Major, minor, and patch versions are always compared numerically. Example: 1.0.0 < 2.0.0 < 2.1.0 < 2.1.1. When major, minor, and patch are equal, a pre-release version has lower precedence than a normal version. Example: 1.0.0-alpha < 1.0.0. Precedence for two pre-release versions with the same major, minor, and patch version MUST be determined by comparing each dot separated identifier from left to right until a difference is found as follows: identifiers consisting of only digits are compared numerically and identifiers with letters or hyphens are compared lexically in ASCII sort order. Numeric identifiers always have lower precedence than non-numeric identifiers. A larger set of pre-release fields has a higher precedence than a smaller set, if all of the preceding identifiers are equal. Example: 1.0.0-alpha < 1.0.0-alpha.1 < 1.0.0-alpha.beta < 1.0.0-beta < 1.0.0-beta.2 < 1.0.0-beta.11 < 1.0.0-rc.1 < 1.0.0. Why Use Semantic Versioning? This is not a new or revolutionary idea. In fact, you probably do something close to this already. The problem is that “close” isn’t good enough. Without compliance to some sort of formal specification, version numbers are essentially useless for dependency management. By giving a name and clear definition to the above ideas, it becomes easy to communicate your intentions to the users of your software. Once these intentions are clear, flexible (but not too flexible) dependency specifications can finally be made. A simple example will demonstrate how Semantic Versioning can make dependency hell a thing of the past. Consider a library called “Firetruck.” It requires a Semantically Versioned package named “Ladder.” At the time that Firetruck is created, Ladder is at version 3.1.0. Since Firetruck uses some functionality that was first introduced in 3.1.0, you can safely specify the Ladder dependency as greater than or equal to 3.1.0 but less than 4.0.0. Now, when Ladder version 3.1.1 and 3.2.0 become available, you can release them to your package management system and know that they will be compatible with existing dependent software. As a responsible developer you will, of course, want to verify that any package upgrades function as advertised. The real world is a messy place; there’s nothing we can do about that but be vigilant. What you can do is let Semantic Versioning provide you with a sane way to release and upgrade packages without having to roll new versions of dependent packages, saving you time and hassle. If all of this sounds desirable, all you need to do to start using Semantic Versioning is to declare that you are doing so and then follow the rules. Link to this website from your README so others know the rules and can benefit from them. How should I deal with revisions in the 0.y.z initial development phase? The simplest thing to do is start your initial development release at 0.1.0 and then increment the minor version for each subsequent release. How do I know when to release 1.0.0? If your software is being used in production, it should probably already be 1.0.0. If you have a stable API on which users have come to depend, you should be 1.0.0. If you’re worrying a lot about backwards compatibility, you should probably already be 1.0.0. Doesn’t this discourage rapid development and fast iteration? Major version zero is all about rapid development. If you’re changing the API every day you should either still be in version 0.y.z or on a separate development branch working on the next major version. If even the tiniest backwards incompatible changes to the public API require a major version bump, won’t I end up at version 42.0.0 very rapidly? This is a question of responsible development and foresight. Incompatible changes should not be introduced lightly to software that has a lot of dependent code. The cost that must be incurred to upgrade can be significant. Having to bump major versions to release incompatible changes means you’ll think through the impact of your changes, and evaluate the cost/benefit ratio involved. Documenting the entire public API is too much work! It is your responsibility as a professional developer to properly document software that is intended for use by others. Managing software complexity is a hugely important part of keeping a project efficient, and that’s hard to do if nobody knows how to use your software, or what methods are safe to call. In the long run, Semantic Versioning, and the insistence on a well defined public API can keep everyone and everything running smoothly. What do I do if I accidentally release a backwards incompatible change as a minor version? As soon as you realize that you’ve broken the Semantic Versioning spec, fix the problem and release a new minor version that corrects the problem and restores backwards compatibility. Even under this circumstance, it is unacceptable to modify versioned releases. If it’s appropriate, document the offending version and inform your users of the problem so that they are aware of the offending version. What should I do if I update my own dependencies without changing the public API? That would be considered compatible since it does not affect the public API. Software that explicitly depends on the same dependencies as your package should have their own dependency specifications and the author will notice any conflicts. Determining whether the change is a patch level or minor level modification depends on whether you updated your dependencies in order to fix a bug or introduce new functionality. I would usually expect additional code for the latter instance, in which case it’s obviously a minor level increment. What if I inadvertently alter the public API in a way that is not compliant with the version number change (i.e. the code incorrectly introduces a major breaking change in a patch release)? Use your best judgment. If you have a huge audience that will be drastically impacted by changing the behavior back to what the public API intended, then it may be best to perform a major version release, even though the fix could strictly be considered a patch release. Remember, Semantic Versioning is all about conveying meaning by how the version number changes. If these changes are important to your users, use the version number to inform them. How should I handle deprecating functionality? Deprecating existing functionality is a normal part of software development and is often required to make forward progress. When you deprecate part of your public API, you should do two things: (1) update your documentation to let users know about the change, (2) issue a new minor release with the deprecation in place. Before you completely remove the functionality in a new major release there should be at least one minor release that contains the deprecation so that users can smoothly transition to the new API. Does semver have a size limit on the version string? No, but use good judgment. A 255 character version string is probably overkill, for example. Also, specific systems may impose their own limits on the size of the string. The Semantic Versioning specification is authored by Tom Preston-Werner, inventor of Gravatars and cofounder of GitHub. If you’d like to leave feedback, please open an issue on GitHub.
استراتيجيات كفد الفوركس
Forex4you فبا