Версия программы в которой все ошибки исправлены и добавляются новые функции называется
Видов программ великое множество, и все они сильно друг от друга отличаются. Со временем даже одна система может развиться так, что ее станет не узнать. Как же разобраться во всем этом хаосе? Одним из решений является “Версионирование ПО”, с которым мы познакомимся в этой статье.
Версионирование это способ группировки и маркировки изменений, вызванных эволюцией системы. Говоря проще, это использование имен, для описания некоторого состояния программы. Чаще всего, в качестве имени выступает цифра, но может так же использоваться некоторое слово или смесь обоих, на пример - 2.4-alpha .
Применение версионирования решает следующие основные задачи разработки и сопровождения ПО:
- Контроль изменений - с помощью версий, пользователи данной системы могут выбрать наиболее полезное для себя состояние (к примеру, с некоторой функциональностью или совместимую с данной ОС)
- Группировка - версии позволяют автору ПО сгруппировать изменения и предоставить их пользователям в виде патча или обновления
- Совместимость - при использовании “Семантического версионирования” (о котором мы поговорим немного позже), разработчики, использующие данный пакет, могут не бояться сломать свою систему после обновления или патча, так как правильный выбор версии гарантирует совместимость на уровне кода
Как уже было сказано ранее, версия может обозначаться любой последовательностью символов. Часто применяется простая модель версионирования: инкремент числа версии при каждом изменении - но это не всегда является удачным решением. Для понимания проблемы, с которой вы можете столкнуться при использовании такой модели версионирования, давайте рассмотрим простой пример:
Представьте, что вы используете пакет для обработки изображений в своей системе “Галерея фотографий”. Вся логика галереи всецело зависит от этого пакета, но пакет часто меняется, в нем появляются новые функции и закрываются старые баги, что постоянно изменяет его версию. Вы конечно же хотите “идти в ногу со временем” и часто обновляете этот пакет, но в один ужасный день вся система перестает работать. Быстрый анализ показывает, что проблема вызвана удалением из пакета одной старой, но используемой галереей функции (назовем ее crop ).
Как же обезопасить свой код от такого рода проблем? Решение есть, оно называется “Семантическим версионированием”. Использование систем, применяющих эту модель версионирования, обеспечивает вас удобным инструментом для контроля за возможными изменениями и совместимостью. Работает это очень просто, нужно всего навсего следовать следующим правилам при выборе версии ПО:
- Версия представляется в виде трех целых цифр, разделенных точкой (на пример 2.4.1). Первая цифра называется минором версии, вторая мажором, а третья патчем
- Каждая из трех цифр не ограничена в своей размерности и служит для контроля изменений на данном уровне (об уровнях чуть позже). Это означает, что версия вида 3.15.91 вполне обычное явление и не следует стремиться к смене мажорной версии при достижении патч-версии десятки (частая ошибка новичков)
- Патч-версия изменяется при любых изменениях системы, не добавляющих новую функциональность и не изменяющих старую. Обычно изменение патч-версии ПО означает, что в нем были поправлены некоторые баги или выполнен рефакторинг
- Мажорная версия изменяется при добавлении новой функциональности с учетом обратной совместимости. Другими словами, вы можете смело обновлять ПО на новую мажорную версию, не опасаясь ошибок, описанных в примере выше, так как с этим обновлением вы получите только новую функциональность
- Минорная версия изменяется при появлении несовместимых изменений, таких как: удаление устаревших (но, может быть, используемых кем то) функций, расширения семантики компонентов системы (к примеру добавление новых, обязательных аргументов функции) и т.п. Для обновления минорной версии необходимо предварительно обеспечить совместимость ваших компонентом с ее правками
Чтобы было понятнее, рассмотрим несколько примеров:
Если вы увидите, что для используемого вами пакета обработки изображений ImageEditor 1.1.4 изменилась версия до 1.1.5 (патч-версия), смело обновляйте ее, ведь это не нарушит совместимости с вашей галереей.
В новой версии 1.2.0 (мажорная версия) этого же пакета появилась функция resize ? Обновитесь. Галерея будет продолжать работать без ошибок, ведь новая функция никак ей не помешает.
Вышла новая версия ImageEditor 2.0.0 из которой была удалена функция crop ? Для обновления придется заменить эту функцию на аналогичную в вашей галерее, иначе обновиться до новой минорной версии вы не сможете.
Часто имеет смысл расширять версию некоторым именем, на пример alpha . Делается это для дополнительной семантической группировки изменений, либо для конфиденциальности. Рассмотрим два случая такой модели:
- “Альфа”, “бета” и “релиз” версионирование - такая модель используется для описания состояний системы, при которых она тестируется разными группами людей. Система, версия которой помечена как alpha (на пример 1.1.0-alpha) обычно еще слишком сырая для представления пользователю и тестируется внутри компании или только доверенными лицами. Пометка beta (на пример 1.1.4-beta) означает, что система, по мнению разработчика, завершена, но ее еще следует протестировать целевым пользователям. Релизная версия, маркеруемая как r (на пример 1.1.5-r) или вовсе не имеющая буквенных маркеров, полностью прошла тестирование внутри и вне компании и может безопасно использоваться клиентами
- Проектные имена - эта модель подразумевает параллельное версионирование, облегчающее пользователям восприятие новой версии продукта. Она выражается в использовании запоминающихся имен версий, таких как star , zero , red и т.д., которые будут известны пользователям. Внутри компании, часто используется обычное семантическое версионирование
Для отслеживания изменений в версиях применяются файлы “Логов изменений” ( Changelog ), в которых описываются правки, сгруппированные по версиям. При выпуске новой версии ПО этот файл дополняется соответствующими этой версии изменениями. Каждая группа в этом файле, как правило, состоит из четырех подгрупп:
Методология изменения версий продукта программного обеспечения
Software versioning — это процесс создания уникальных имен или номеров для различных версий продуктов программного обеспечения.
При имеющейся категории номера версии (главная, второстепенная), номера обычно выставляются в возрастающем порядке и соответствуют новым разработкам в программном обеспечении. На начальном уровне отслеживанием постепенно появляющихся версий электронной информации занимается система управления версиями, позволяющая хранить несколько версий одного и того же документа, при необходимости, возвращаться к более ранним версиям, определяя, кто и когда сделал то или иное изменение и многое другое. Вместе с тем для отслеживания изменений программного обеспечения было создано большое количество схем присвоения номеров версиям.
Каждой стадии разработки программного обеспечения соответствует уникальный идентификатор, который состоит из последовательности номеров или букв. В некоторых схемах последовательные идентификаторы используются для определения значимости перемен между стадиями разработки: эти перемены классифицируются по уровням значимости. Решение о том какую последовательность изменить между стадиями разработки основано на значимости перемен на последней стадии разработки, например в схеме, с версией, состоящей из последовательности 4 чисел, первое число может быть прибавлено только тогда когда код полностью переписан, в то время как четвертое число изменяется при незначительных переменах в интерфейсе или документации.
В более поздних релизах, главное число (major) увеличивается, когда происходят значительные переходы в функциональности, второстепенное число (minor) прибавляется только тогда, когда были добавлены незначительные функции или внесены исправления. Номер версии изменяется, если исправлены все мелкие неполадки. Для типичного программного продукта используются следующие номера: 0.9 (для бета-версии), 0.9.1, 0.9.2, 0.9.3, 1.0, 1.0.1, 1.0.2, 1.1, 1.1.1, 2.0, 2.0.1, 2.0.2, 2.1, 2.1.1, 2.1.2, 2.2, и т.д. Разработчики порой перескакивают от версии 5.0 сразу к 5.5, для того чтобы обозначить добавление нескольких значимых функций в программе, однако их не достаточно, чтобы изменить главный номер версии, тем не менее такие скачки все же неуместны.
Известные примеры буквенно-цифровых версий — Macromedia Flash MX, Adobe Photoshop CS2.
Иногда присутствие человеческого фактора в создании номеров версий приводит к ошибкам в изменении версий. Например, разработчики могут изменить последовательность между версиями, даже если одна строчка кода не была переписана, лишь для того чтобы создать ложное впечатление, что были внесены значительные изменения.
Обозначение стадии разработки
Для присвоения альфа или бета статуса релизам, которые еще не достаточно стабильны для практического применения, существуют схемы, где в первой последовательности используется ноль. Он ставится третьим числом в тех случаях, когда планируется еще тестировать версию или версия годна только для внутреннего применения.
- 0 — альфа
- 1 — бета
- 2 — релиз кандидат
- 3 — публичный релиз
- 1.2.0.1 вместо 1.2-a
- 1.2.1.2 вместо 1.2-b2 (бета с несколькими исправленными ошибками)
- 1.2.2.3 вместо 1.2-rc (релиз кандидат)
- 1.2.3.0 вместо 1.2-r (для коммерческого распространения)
- 1.2.3.5 вместо 1.2-r5 (для коммерческого распространения со многими исправленными ошибками)
Разделение последовательностей
При публикации последовательности могут быть разделены знаками препинания. Выбор знаков препинания и их использования зависит от схемы.
- Схема может использовать один и тот же знак препинания между последовательностями: 2.4.13, 2/4/13, 2-4-13
- Выбор схемы, какие числа разделять, а какие нет, может быть противоречивым: 2.413
- Схема может использовать разные знаки препинания внутри одной последовательности: 2.4_13
Номера последовательностей
Иногда в схемах существует четвертое неопубликованное число, которое обозначает сборку (build) программного обеспечения (как это делает ,Microsoft). ,Adobe Flash наоборот больше всего выделяет четвертое число версии: 10.1.53.64. Некоторые компании также включают дату сборки. Номера версий могут включать буквы и знаки препинания: Lotus 1-2-3 Release 1a.
Приращение последовательности
Существует два разных способа приращения последовательности номеров в версии. Большинство продуктов свободного программного обеспечения используют непрекращаемый поток последовательных номеров: 1.7.0, 1.8.0, 1.8.1, 1.9.0, 1.10.0, 1.11.0, 1.11.1, 1.11.2, и т.д. Примером такого продукта может служить MediaWiki. В других программах используются десятичные номера: 1.7, 1.8, 1.81, 1.82, 1.9, и т.д. В таких программах после версии 1.8 будет идти версия 1.81, текущие релизы будут обозначаться 1.81a, 1.81b, и т.д.
Использование дат в версиях
Разработчики проекта Wine использовали даты при нумерации версий, они указывали год, месяц и день релиза: «Wine 20040505». Сейчас Wine использует «стандартную» нумерацию релизов, последняя версия 2010 года имеет номер 1.2. Компания Ubuntu Linux использует похожую схему нумерации, например релиз апреля 2010 года пронумерован как Ubuntu 10.04. Номера сборок Microsoft Office тоже на самом деле закодированные даты.
Здесь следует отметить, что при использовании дат в нумерации версий необходимо использовать схему ISO, то есть сначала указывается год, затем месяц, а потом день (YYYY-MM-DD), причем дефис можно опускать.
Существуют также примеры нумерации версии годом выпуска (Adobe Illustrator 88, WordPerfect Office 2003). Хотя такой ход чаще всего используется в маркетинговых целях, и настоящий номер версии все равно существует. Например, версия Microsoft Windows 2000 Server на самом деле имеет номер Windows NT 5.0.
Схема нумерации версий TeX
Система TeX использует уникальную схему нумерации версий. После появления версии номер 3, ко всем последующим обновленным версиям после точки добавляли цифру, соответствующую последовательности числа Π это одна из форм унарной системы счисления – номер версии соответствует номеру цифры в числе Π. Номер последней версии 3.1415926. Такой метод отражает стабильность системы TeX. Разработчик TeX Дональд Кнут сказал, что последняя версия выйдет после его смерти и ее номер будет полное число Π, в которой все оставшиеся недочеты станут постоянными функциями. Подобной схемы придерживается METAFONT, нумеруя версии числами из математической константы e.
Схема Apple
,Apple использует формализованную структуру нумерации версий основанную на структуре NumVersion, она состоит из номера главной версии (1-2 числа), номера второстепенной версии (1 число), номера исправленной версии («bug» version) (1 число), индикатора стадии разработки (преальфа, альфа, бета и т.д.) и номера пререлиза (0-255). При написании этих номеров версий в строке, существовало условное соглашение опускать часть номера, обозначающую нулевую или последнюю стадию разработки. На пример: 1.0.2b12, 1.0.2 (вместо 1.0.2f0), и 1.1 (вместо 1.1.0f0).
Другие схемы
Производители программного обеспечения используют различные схемы для обозначения релиза их софта. Например, операционная система Microsoft Windows появилась на рынке со стандартной числовой схемой обозначения версий (от Windows 1.0 до Windows 3.11). Позднее разработчики Microsoft начали разделять названия версий в маркетинговых целях, то есть, сначала используя год релиза (Windows 95 (4.0), Windows 98 (4.10), Windows 2000 (5.0)), потом буквенно-цифровые коды (Windows Me (4.90), Windows XP (5.1)), после чего названия брендов (Windows Vista (6.0)). Судя по последнему релизу Windows 7, Microsoft снова вернулся к стандартной числовой схеме, хотя официальное название версии Windows 7 это 6.1.
В проекте Debian для релизов операционной системы используется «major/minor» схема, а для названий программных продуктов при разработке используются имена из мультфильма «История Игрушек».
Скрытые номера версий
Продукт программного обеспечения может иметь так называемый «скрытый» номер версии, который не указан в основном названии продукта (обычно в составлении скрытого номера соблюдаются все правила нумерации версий). Например, версия Java SE 5.0 имеет внутренний номер 1.5.0, а версии Windows начиная от NT 4, продолжают внутреннюю стандартную нумерацию версий: Windows 2000 это NT 5.0, XP это Windows NT 5.1, 2003 это NT 5.2, Vista это NT 6.0 и 7 это NT 6.1.
Предварительные версии продуктов программного обеспечения
Нечетные числа в обозначении версий для разработки релиза
Между сериями 1.0 и 2.6.x, Linux kernel использовал нечетную нумерацию версий, что бы обозначить релизы в разработке, а для стабильных релизов четную нумерацию. Например Linux 2.3 была серия разработок второго главного дизайна Linux kernel, а Linux 2.4 была серия стабильных релизов, в которую перерос Linux 2.3. В номере релиза Linux kernel сначала писался номер второстепенной версии, а затем номер релиза в возрастающем порядке. Например Linux 2.4.0 → Linux 2.4.22. После релиза 2.6 kernel в 2004 году, Linux больше не использует эту систему, теперь цикл релиза намного короче. Сейчас они просто увеличивают третье число, используя четвертое при необходимости.
Apple и нечетные числа
У компании Apple были свои особенности на счет нечетных чисел, особенно во время системы MacOS. Даже тогда когда выпускались второстепенные (minor) релизы номер версии редко был больше чем 1, а если номер нужно было увеличить они перескакивали сразу на 5, предлагая при этом небольшое изменение величины между главным и второстепенным релизом (например, 8.5 значит «восемь с половиной», а 8.6 значит «восемь с половиной точка один»). Завершенная последовательность версий выглядит так: 1.0, 1.1, 2.0, 2.1, 3.0, 3.2 (3.1 пропущена), 4.0, 4.1, 5.0, 5.1, 6.0, 7.0, 7.1, 7.5, 7.6, 8.0, 8.1, 8.5, 8.6, 9.0, 9.1, 9.2.
Версия 1.0 как ключевой этап разработки
Разработчики проприетарного программного обеспечения всегда называют первый релиз программы версия 1, а затем увеличивают номер главной версии после каждого переписывания кода. Это значит, что программа может достичь версии 3 всего за несколько месяцев разработки, при этом она еще возможно не станет стабильной и надежной.
В отличие от компаний, сообщество свободного программного обеспечения используют версию 1.0 как ключевой этап разработки, обозначая тем самым, что продукт завершен, в нем есть все необходимые функции, и он достаточно надежен для публичного использования.
Согласно этой схеме, номер версии медленно приближается к 1.0 пока устраняются все недочеты в подготовке к релизу. Разработчики MAME, например, не стремятся выпускать версию 1.0 программы эмулятора, аргументируя это тем, что она никогда не будет до конца завершена, потому что аркадные игры будут появляться всегда. За версией 0.99 просто следует версия 0.100. Подобный пример Xfire, после релиза 1.99 идет 1.100. Так за 6 лет существования eMule все еще не достигли версии 0.50.
История программ
Winamp выпустил совершенно иную конфигурацию третьей версии программы, в которой отсутствовала обратная совместимость с плагинами и другими ресурсами предыдущей версии. Однако, эта версия стала полностью совместимой с версиями 2 и 3, но нумеровалась пятой, то есть 4 была пропущена… То же самое произошло с UnixWare 7, что было соединением UnixWare 2 и Open Server 5.
Как не отставать от конкурентов
В индустрии проприетарного программного обеспечения существует общая привычка перескакивать в нумерации главных и второстепенных версий в маркетинговых целях.
Это можно увидеть на примере нескольких продуктов Microsoft и America Online, а также в системе нумерации версий Sun Solaris, Java Virtual Machine, в версиях SCO Unix и Corel Word Perfect. Программные продукты filePro DB/RAD имели нумерацию от 2.0 к 3.0 к 4.0 к 4.1 к 4.5 к 4.8 к 5.0, и они уже готовят релиз 5.6, не имея при это ни одного промежуточного. Небольшую разницу можно заметить между версиями программного обеспечения AOL's PC client, хотя они нумеруют только главные релизы — 5.0, 6.0, 7.0, и т.д. Таким же образом Microsoft Access перескочили от версии 2.0 к версии 7.0, чтобы догнать нумерацию версий Microsoft Word.
У корпорации Microsoft тоже была цель догнать нумерацию версий браузера Netscape, пропустив версию 5 и выпустив сразу шестую версию Internet Explorer.
- JDK 1.0.3
- JDK 1.1.2 через 1.1.8
- J2SE 1.2.0 («Java 2») через 1.4.2
- Java 1.5.0 («Java 5»)
- Java 1.6.0 («Java 6»)
Суеверия
У релиза 2007 программы Microsoft Office был внутренний номер версии 12. Релиз Office 2010 внутренне нумеровался уже 14, из-за плохой репутации чертовой дюжины.
Версия 13 WordPerfect Office программы Corel обозначена в продаже как «X3» (римская цифра 10 и «3»). Процедура повторилась в следующей версии X4.
Как преодолеть маркетинговые трудности
В середине 1990х быстро развивающиеся на китайском рынке CMMS и Maximo, перескакивали от версии Maximo Series 3 сразу к Series 5, пропуская Series 4, так как неправильное произношение номера 4 на китайском языке могло означать «смерть» или «неудача». Хотя это, однако, не остановило Maximo Series 5 при выпуске релиза 4.0. Следует отметить, что на этом нумерация Series остановилась, но возобновилась вполне успешно, начиная с релиза 1.0.
Значимость нумерации версий в разработке программного обеспечения
Номера версий используются в практических условиях потребителем или клиентом для того, чтобы можно было сравнить имеющуюся у них копию продукта программного обеспечения и новую версию, выпущенную разработчиком. Команда программистов и компании используют нумерацию версий для сравнения отдельных частей и секторов программного кода одних версий с другими, обычно сотрудничая с Системой контроля версий. Не существует абсолютной и определенной схемы нумерации версий продуктов программного обеспечения, поэтому очень часто нумерация зависит от личного выбора программистов.
Перевод осуществлен сотрудницей компании "Chyrius" Натальей Володиной.
Общеизвестно, что каждый программный продукт в конечном итоге обретает номер поставляемой версии. Изначально это может быть цифра в README файле, на борде в JIRA либо просто в голове у тимлида или ПМа. Но в какой-то момент становится понятно, что нужно формализовать процесс назначения версии релизу, отобразить номер в приложении, интегрировать версионность в CI, аналитику и другие места.
С появлением технологии PWA, версионность в вебе обрела еще больший смысл, ведь теперь самая последняя версия приложения доступна пользователю не в момент загрузки страницы, а только через определенное время после обновления файлов в фоновом режиме. Поэтому важно следить за номерами версий у пользователей, чтобы знать в какой из них возникла проблема и сколько обновилось до последней.
Ниже рассмотрим способы добавления версионности веб-проекту, используя готовые решения, и напишем свой универсальный скрипт, удовлетворяющий всем требованиям.
Git и версионность
Для наглядности, давайте взглянем на диаграмму одного из самых популярных подходов Git Flow:
Демонстрация Git Flow
Как видим, нумерация версий происходит в ветке, код которого попадает на прод (разумеется, можно добавлять версии для любых окружений), при этом формат версии обычно задается X.Y.Z (как правило, согласно спецификации семантической версионности, где X - мажорная версия, Y - минорная, Z - патч).
Расшифровка версии semver
Очевидно, что версии в первую очередь должны быть привязаны к коммитам (после которых и собираются релизные сборки), чтобы хранилась наглядная история релизов и легко было откатываться до предыдущего при необходимости. Удобнее всего это реализовать с помощью тегирования коммитов (git tag). Давайте рассмотрим npm пакеты, помогающие решить эту задачу.
Готовые npm-решения
Основная проблема в том, что все существующие npm пакеты предназначены больше для версионности и публикации вашего проекта в npm непосредственно, хотя никто не мешает воспользоваться функционалом инкрементирования версии сборки и пуша тегов в гит (будь то ручной запуск команды, либо из CI-скрипта).
Примеры:
После установки пакета, выполняем команду np, выбираем какую цифру релиза нужно увеличить. Правда, придется выполнять команду добавив флаги --no-publish --no-tests --no-release-draft
Обновление версии с помощью одной команды
Нет возможности контролировать, куда записывается номер версии (только в package.json)
Нет возможности добавить постфикс версиям (например, 1.3.1-dev, 0.1.1-alpha)
Не все git сервисы разрешают пушить тег с новой версией и измененный package.json в репозиторий прямо из CI-скрипта после окончания сборки.
Пакет популярнее предыдущего, больше конфигураций, интерактивный режим настройки. Принцип выполнения команды такой же:
release-it minor --no-npm.publish
Для режима CI нужно добавить флаг --ci
Чтобы хранить номер версии в своем файле нужен отдельный плагин (тем не менее, там нет поддержки .js расширения, поэтому проще использовать пакет replace-in-file) - для отображения версии сборки в самом приложении
Нет возможности добавить постфикс к версии (по крайней мере я не нашел)
Наиболее популярный из представленных примеров. Полностью автоматизирует процесс версионности, убирая человеческий фактор по инкременту версий. Однако, для этого необходимо следовать Commit Message Conventions (хороший повод начать именовать коммиты более организованно).
Инкремент версий происходит по следующей логике: если в названии коммита находится слово fix - это считается как Patch Release (обновляется третья цифра); если в названии коммита присутствует feat (feature) - Minor Release (вторая цифра); perf (performance) или breaking change - Major Release (первая цифра).
Вдобавок, на основе коммитов генерируется changelog.
Не обнаружил возможность хранить версию в отдельном .js файле для последующего отображения в приложении
Возможность контролировать процесс обновления мажорных и минорных версий вручную.
Как видим, готовых решений достаточно, однако, давайте все же попробуем написать свое, адаптировав его под свои нужды.
Что нам нужно?
Код из git-веток попадающий на окружение (dev, staging, prod) должен быть пронумерован и хранить тип окружения (к примеру, 1.0.1-dev)
Каждый пуш в ветку (master, integration, release) увеличивает патч-версию
Обновление мажорной и минорной версии происходит вручную после каждого релиза / спринта. Какую версию менять решаем сами на основе запланированных задач и потенциальных изменений
Версия сборки доступна в JS, для того чтобы была возможность ее отображать в самом приложении, использовать для аналитики, передавать в системы репорта ошибок и т.п.
package.json не должен меняться во время CI (т.е версию приложения не храним в этом файле) во избежание потенциальных мерж конфликтов (к примеру, когда одновременно вмерживается несколько реквестов и сборки собираются одновременно, в нашей команде такое случается достаточно часто).
При релизе патч-версия (z) начинается с 1, оставляя только номер релиза (x.y). Например: версии на деве 1.4.1-dev, 1.4.2-dev, 1.4.3-dev, а в релиз пойдет 1.4.1. Если же подливаем hotfix в тот же релиз, то версия будет 1.4.2.
Данные пункты являются субъективными и легко могут быть изменены под ваши требования. Ниже рассмотрим JS-реализацию данной логики.
Реализация своей системы версионности
Предварительно создадим 2 файла, первый version.txt (в корне проекта) для хранения мажорной и минорной версии релиза (которые мы вручную меняем, как указано выше). В файле будет хранится только 2 числа версии, разделенные точкой вида: 2.13
Создадим второй файл app-version.js (путь - src/environment, т.к. там лежат подобные файлы в Angular проекте, вы же можете выбрать любой удобный путь), который будет меняться CI-скриптом перед сборкой, при этом в самом репозитории файл всегда статичен. Содержимое выглядит так:
Это позволит получить доступ к версии прямо во время выполнения javascript / typescript кода приложения и использовать по назначению:
Логика определения и назначения версии будет следующая:
получить текущую мажорную и минорную версии (x.y) из файла version.txt
вывести список всех git-тегов данного релиза x.y.*
обнаружить патч версию (z) последнего тега релиза
добавить новый тег вида x.y.(z+1)
при необходимости добавить постфикс окружения (x.y.z-dev)
Приступим к скрипту. Нам нужен пакет npm shelljs - для того, чтобы мы могли работать с системными командами (git, файловая система) прямо из js-файла без нужды писать shell-скрипты. Создадим update-version.js:
Скрипт генерации новой версии приложения на основе предыдущих версий из git готов. Далее можно запускать сборку проекта, зная, что app-version.js с новой версией попадет в проект и будет доступен в JS.
Остался лишь последний шаг - git push нового тега после успешной сборки в git-репозиторий.
Создаем еще один файл push-new-version-tag.js:
Готово. Остается добавить запуск этих команд в ваш CI скрипт.
А вот как выглядит наш для GitLab (проект на Angular):
Таким образом, мы добавили версионность в веб-приложение для разных окружений (дев-версии сборок именуются вида x.y.z-dev, а прод-версии без постфикса - x.y.z). Как видите, реализация получилась несложной и адаптируемой. К примеру, если вы уже используете готовое решение, но у вас нет возможности получить номер версии в JS, можно добавить скрипт, который будет вычитывать последний тег и записывать его в js-файл. К слову, для меня был большим открытием npm-пакет shelljs, заметно упрощающий написание логики вместо shell-скриптов.
Как мы используем номер версии в Uxcel?
Наше приложение является PWA, поэтому нам важно следить за номерами версий наших пользователей: версии отправляются в google analytics, в систему мониторинга ошибок sentry, в API запросы (которые могут обрабатываться по-разному в зависимости от версии) и, само собой, версия отображается в самом приложении. Помимо этого, номер версии может использоваться для отображения Release Notes или для показа обучающего окна нового функционала сразу после авто-обновления приложения.
Uxcel - сервис интерактивного обучения UI/UX. Наша версия отображается в меню.
Спасибо за внимание, надеюсь, статья была полезной для вас! Буду рад услышать ваше мнение, делитесь своими способами версионности веб-приложений.
Каждая программа перед тем, как попасть к пользователю, проходит несколько этапов тестирования. Но иногда пользователям могут быть доступны даже те версии, которые не протестированы до конца — и многие этому даже рады. Давайте разберёмся, как это работает.
Стадии тестирования и разработки софта
Если не углубляться в нюансы разработки и тестирования, то обычно говорят о пяти состояниях, в которых находится программа:
- Преальфа (Pre-alpha) — самая начальная стадия разработки.
- Альфа-версия — вроде всё сделали, протестировали самое основное.
- Бета-версия — оттестировали большую часть, ловим тараканов при поддержке небольшого круга доверенных людей.
- Релиз-кандидат — почти готовая к выпуску программа.
- Релиз — готовая программа.
Преальфа
Преальфа — это сырой продукт, не предназначенный для использования. На нём чаще всего тестируют гипотезы и убеждаются, что софт в принципе может работать.
Эта версия позволяет оценить выбранную архитектуру и подход к программированию, сравнить с планируемой нагрузкой и понять, идёт ли всё по плану или впереди будет гораздо сложнее. В преальфе много ошибок, заглушек и не предусмотренных тестами ситуаций.
Иногда преальфа нужна для того, чтобы показать клиентам или инвесторам, как вообще идут дела в компании. Например, в игровой индустрии ролики из преальфа-версии позволяют заранее прикинуть возможности графики в игре или понять, стоит вкладывать деньги в эту идею или она провалится в прокате.
Альфа
Когда программа доходит до стадии «альфа», то считается, что в ней реализованы все возможности, предусмотренные этой версией, и теперь нужно найти все ошибки.
Случается такое, что во время тестирования в программу добавляются или в ней сокращаются некоторые модули, чтобы снизить сложность или количество ошибок. Альфа-версия считается уже как бы рабочей, но очень сырой версией программы. По идее, ей уже можно пользоваться, но с поправкой на общую глючность.
Бывает такое, что программа в стадии альфа-версии может находиться годами: разработчики никуда не спешат и делают софт для себя. Или у них внезапно закончились деньги, а забрасывать программу жалко. Тогда они могут открыть эту версию для всех, но с оговоркой, что это альфа и что пользуемся на свой страх и риск.
Бета-версия — это уже серьёзно. Чаще всего это означает, что в ней исправлены почти все большие ошибки, но может остаться много мелких, которые ещё не нашли тестировщики.
Ещё одна причина выпуска бета-версий в свет — желание компании уйти от ответственности за ошибки. Идея такая: компания говорит, мол, что это ещё не окончательная версия, поэтому в ней могут быть баги, которые ещё не отловили. Но на самом деле эту версию никто не будет дорабатывать до финала — в лучшем случае поправят пару заметных ошибок.
Релиз-кандидат
После бета-тестирования и исправления почти всех найденных ошибок, программа переходит в стадию релиз-кандидата. Это значит, что ей можно пользоваться как полноценной программой, но не факт, что тестировщики нашли все ошибки.
Если через 1–3 месяца полноценного использования и тестирования программы в ней не найдут никаких ошибок, программа переходит в стадию релиза.
Релиз-кандидат — это почти всегда та же самая программа, что и в релизе, просто разработчикам нужно убедиться, что она работает стабильно и без сбоёв.
Релиз
Релиз — это готовая версия программы, доступная для всех пользователей.
Релизом может быть и крупное обновление, например, новая версия Windows, а может быть и обновление с версии 1.5.234 на версию 1.5.235. Про то, что означают эти цифры и как они меняются, мы поговорим как-нибудь отдельно.
У многих начинающих разработчиков возникает вопрос: как назначать версию своей программы?
Поделюсь своим опытом.
Не буду вдаваться в теорию, тем более, что жестких рамок в данном вопросе нет. В своей практике я встречал много различных вариантов назначения версий программ.
Приведу несколько примеров написания версии:
Разберем каждое значение.
Ревизия (Revision)
Номер ревизии (revision) в системе управления версиями (Version Control System, VCS или Revision Control System). Благодаря ему, можно легко получить исходный код конкретной версии, выгрузив его из хранилища. Как правило, данное значение начинается с 1 с последующим увеличением соответственно номеру ревизии и никогда не обнуляется. В силу того, что значение важно только для разработки, в нумерации программы его часто опускают.
Билд (build)
Иными словами, номер сборки программы. После изменения в коде программы, как правило, проводят сборку программы, т.е. полную компиляцию всех файлов проекта. Как правило, данное значение начинается с 1 с последующим увеличением соответственно номеру сборки. Обнуление сборки либо не проводят никогда, либо при смене мажорной (major) версии. В силу того, что это значение важно только для разработки, в нумерации программы его часто опускают.
Патч или заплатка (patch)
Значение изначально устанавливается в 0 и увеличивается по мере внесения незначительных изменений в программу, например исправление какой-либо ошибки. Обнуляется при смене мажорной или минорной версий.
Минорная версия (minor)
Значение изначально устанавливается в 0 и увеличивается по мере внесения существенных изменений в программу, например, добавления нового функционала в программу. Значение также может повышаться при накоплении мелких изменений (патчей). Обнуляется при смене мажорной версии.
Мажорная версия (major)
Собственно говоря, это и есть версия программы. Значение мажорной версии устанавливается равной 1. Увеличивается данное значение с выходом новой версии, когда происходят значительные переходы в функциональности, например, добавлены новые функции, существенно меняющие возможности программы, изменен интерфейс, переписаны основные алгоритмы и т.п. Значение также может повышаться при накоплении серьезных (минорных) изменений.
Для пред-релизных версий используют значение равное 0, получая номер вида 0.9.*.*
Год.Месяц.День (year.month.day)
Такое назначение версии указывает на дату выхода программы, что удобно для конечного пользователя. Исходя из такой нумерации пользователь может судить о том, как давно вышла конкретная версия программы, и не пора ли проверить обновление. К сожалению, подобная версионность не всегда удобна для разработчиков, особенно когда над проектом работает не один человек.
Кроме указанных позиций, разработчики часто используют буквенные обозначения в номере версии:
alpha — как правило, первая публичная тестовая версия, перед выходом финальной версии. Служит для обкатки и тестирования.
beta — вторая публичная тестовая версия, перед выходом финальной версии. Также служит для тестирования.
RC, RC2 — релиз-кандидат (Relise Candidate) версия, почти готовая к релизу. Служит для окончательной проверки.
final — окончательная (финальная) версия программы. Используется крайне редко, обычно просто опускается.
Какую схему наименования версий использовать решать прежде всего разработчикам, главное, чтобы нумерация была удобна в разработке и понятна конечному пользователю. И это один из тех вопросов, о которых необходимо договариваться в самом начале разработки любого проекта.
В своей практике я использую написание вида major.minor[.patch[.build]], так как оно больше подходит к моему стилю разработки.
Читайте также: