в чем разница между релизным и дев репозиторием

Среды, код и релизы

Лучшие практики по именованию и разграничению сред в соответствии с их предназначением, взаимному соответствию сред и ветвей кода, и процессу выпуска.

Именование сред

Разработки [dev] — та среда (база данных, сайт, ВМ и т.д.), где развёртываем свежий код и смотрим, что получается.

Демо [demo] — тут промежуточный результат показывается заказчику. Пока развёрнутый здесь полуготовый функционал ждёт внимания заказчика, на [dev] можно всё сломать, работая дальше.

Тестовая [test] — тут тестируется функциональность. Среда наполнена тестовыми данными, которые могут отражать редко возникающие (в рабочей среде) случаи или быть удобными для тестирования. Пока тут идёт тестирование того, что готовится в продакшен, на [dev] уже появляется код следующего релиза.

Промежуточная [stage], она же предпродакшен — тут тестируется развёртывание. Сюда развёртывается последний бэкап системы из продакшена, чтобы проверить обновление на версию.

Продакшен [prod] — тут работают пользователи.

Связь с кодом

В зависимости от системы бывает, что код идёт в развёртывание вместе с конфигурацией (набором переносимых настроек). При этом, сам код ведётся в репозитории, а конфигурация в среде.

Изначально, код, попадающий в ветвь /dev, выкатывается в среду [dev], где настраивается конфигурация к нему. Затем, код и конфигурация (иногда по частям) переносятся в другие среды.

Путь кода

То, что исправляется в /main при тестировании, естественно → /dev.

Путь конфигурации

[dev] → экспорт в репозиторий отдельно от кода.

Ошибки проектирования систем

Рассмотрим, что в архитектуре системы может сделать невозможным гладкий выпуск.

Двусторонняя зависимость

Бывает, что часть конфигурации зависит от кода (нельзя настроить, пока не выкатится какая-либо сборка), но часть кода зависит от конфигурации (это код, который опирается на структуры в базе данных, которые создаются конфигуратором, либо на сборки, которые собираются конфигуратором).

То, что делает путь релиза таким трудным или уникальным — ошибка архитектуры. Её совершают из побуждений «сделать что-то автоматическим», закладывая возможность в единый конфигуратор системы, вместо того, чтобы закладывать в более низко-уровневые инструменты, или «получить быстрый результат», используя такую возможность.

Бывает, что в покупной системе есть несколько путей создания вещей, таких как структуры данных или объекты. Например, в ELMA-BPM есть создание объектов через конфигуратор, а есть через плагин к Visual Studio. Выбирайте более низко-уровневый способ, иначе попадёте на описанную двустороннюю зависимость.

Логика в базе данных

Переразвернуть базу данных гораздо сложнее чем пересобрать код.

Из-за этого, в системах, где много логики в базе, разработчики работают на одном общем экземпляре БД. Обычно они говорят, что им нужна общая БД для разработки, так как: а) там всегда развёрнут последний код от каждого из них и б) там готовы тестовые данные.

Из-за постоянной работы в общей базе (читай «среде»), в свою очередь, теряется смысл ветвления кода в репозитории.

В итоге, от /dev бессмысленно отделять ветви фич, что, в свою очередь, не позволяет выделять длинные работы и делать релизы независящими от них.

Кроме того, поскольку перенос из среды в среду (ибо это из базы в базу) сложнее, количество сред в процессе пытаются сократить, не выходя за [dev] → [stage] → [prod] (а то и [dev] → [prod]). Тестируют и демонстрируют функционал прямо на [dev].

Логика в БД сегодня, это ошибка архитектуры (по многим причинам), которую, наверное, мало кто будет отрицать (хотя случается и такое). В данном случае, это ограничение для повышения качества и сокращения цикла выпуска.

Источник

Получение разницы между двумя репозиториями

Как мы можем получить разницу между двумя репозиториями git?

сценарий: У нас есть repo_a и repo_b. последний был создан как копия repo_a. после этого в обоих репозиториях была параллельная разработка. Есть ли способ перечислить различия между текущими версиями этих двух репозиториев?

8 ответов:

чтобы заставить его работать, я должен был сделать:

просто используйте каталоги двух репозиториев git, и вы получите приятное графическое сравнение:

при нажатии на один из синих элементов, вы можете увидеть, что изменилось.

вы можете добавить другое РЕПО сначала в качестве пульта дистанционного управления для вашего текущего РЕПО:

затем принесите brach с этого пульта дистанционного управления:

это создает эту ветвь как новую ветвь в вашем текущем РЕПО, тогда вы можете разделить эту ветвь с любой из ваших ветвей, например, чтобы сравнить текущую ветвь с новой ветвью (branch_name):

см.http://git.or.cz/gitwiki/GitTips, раздел » как сравнить два локальных репозитория «в разделе»Общие».

современная версия будет выглядеть примерно так (предполагая, что вы в repo_a’):

Я использую PyCharm, который имеет большие возможности для сравнения папок и файлов.

просто откройте родительскую папку для обоих репозиториев и подождите, пока она не индексируется. Затем вы можете использовать щелчок правой кнопкой мыши на папке или файле и Compare to. и выбрать соответствующую папку / файл на другой стороне.

он показывает не только то, что файлы отличаются, но и их содержание. Гораздо проще, чем в командной строке.

лучше всего иметь оба репозитория на локальном компьютере и использовать команду linux diff с двумя каталогами в качестве параметров:

Источник

11 концепций и команд git, которые заставят вас плакать

В самой популярной системе контроля версий нужно хорошо разбираться. Проверьте знание команд git, ответив на 11 каверзных вопросов.

Последние опросы на Stack Overflow показывают, что более 70% разработчиков используют git для ПО с открытым исходным кодом и для коммерческих продуктов. Преимущества этой VCS для командной работы сложно переоценить.

Вопрос 1. В чем разница между fork, branch и clone?

Вопрос 2. В чем разница между pull request и branch?

Вопрос 3. Объясните разницу команд git pull и git fetch?

Простыми словами, git pull = git fetch + git merge.

Вопрос 4. Как отменить предыдущий коммит?

Предположим, у вас сложилась следующая ситуация. Указатель HEAD находится в C, а (F) – это текущее состояние ваших файлов.

Откатиться к предыдущему состоянию можно с помощью группы команд git reset с разными флагами.

• Чтобы полностью отменить коммит, используйте

• Чтобы отменить коммит, но сохранить сделанные в нем изменения, просто выполните

Так мы передвигаем HEAD на один коммит назад (на B), но оставляем файлы в том состоянии, в котором они находятся. git status покажет, что файлы соответствуют фиксации C.

• Чтобы отменить коммит и сохранить все проиндексированные файлы, используйте

Вызовите git status и убедитесь, что в индексе git находятся те же файлы, что и раньше.

Вопрос 5. Что такое git cherry-pick?

Команда git cherry-pick используется для перенесения отдельных коммитов из одного места репозитория в другое, обычно между ветками разработки и обслуживания. Этот механизм отличается от привычных команд git merge и git rebase, которые переносят коммиты целыми цепочками.

Вопрос 6. Расскажите о преимуществах forking workflow.

Работа через форки принципиально отличается от других популярных методов организации командной разработки. Вместо того чтобы использовать один серверный репозиторий в качестве центральной кодовой базы, здесь каждый разработчик получает свой собственный репозиторий. Чаще всего эта модель применяется в общедоступных open source проектах.

Основное преимущество forking workflow заключается в том, что все изменения вносятся без загрязнения истории проекта. Разработчики делают push в собственные репозитории, а доступ к центральному есть только у менеджера.

Когда обновление готово к интеграции, программист делает pull-запрос в главный репозиторий, а менеджер одобряет и вносит его.

Вопрос 7. В чем разница между HEAD, рабочим деревом и индексом?

Вопрос 8. Расскажите о gitflow-организации рабочего процесса.

Модель gitflow использует две параллельные «долгие» ветки для хранения истории проекта: master и develop.

Вопрос 9. Когда следует использовать git stash?

git stash берет ваши изменения, подготовленные и неподготовленные к фиксации, сохраняет их для последующего использования и убирает из рабочей области.

Это полезно в ситуации, когда вы внезапно поняли, что последний коммит следует изменить, но уже начали другую работу в той же самой ветке.

Вопрос 10. Как удалить файл из git, но оставить его в файловой системе компьютера?

Если вы не будете осторожны с использованием команд git add, то можете случайно добавить в индекс файлы, которые там быть не должны. git rm может удалить их из индекса, но одновременно сотрет и из файловой системы (рабочего дерева). Это не всегда то, что требуется.

Используйте вместо этого git reset :

противоположна git add

Вопрос 11. Когда следует использовать git rebase вместо git merge?

Предназначение этих команд git – интеграция изменений из одной ветки в другую, но делают они это по-разному.

Предположим, у вас сложилась такая ситуация:

После обычного мержа репозиторий будет выглядеть так:

А после git rebase – так:

Rebase указывает на то, что коммиты нужно буквально перенести со старого места на новое.

Учитывайте следующие факторы:

Источник

🐉 Объяснение репозиториев Kali Linux [с примерами]

В этой статье мы рассмотрим репозитории Kali Linux, но перед этим давайте разберемся, что такое репозитории вообще и что они означают.

Что такое репозитории Linux?

Если вы работали с каким-либо дистрибутивом Linux, вы наверняка сталкивались со словом “репозитории”, особенно при установке программного обеспечения или обновлении и модернизации системы.

Репозитории в системах Linux означают удаленное место хранения, откуда Ваша система извлекает и устанавливает программное обеспечение и пакеты.

Поэтому, когда вы выполняете такую команду, как:

вы просто извлекаете информацию о пакетах и их обновлениях из удаленного хранилища.

Большинство этих репозиториев основаны на дистрибутивах.

Репозитории Kali Linux отличаются от тех, которые используются в таких дистрибутивах, как BlackArch или Debian.

Даже если ситуация может заставить вас добавить репозиторий из другого дистрибутива в вашу систему, это не рекомендуется, даже если они используют один и тот же менеджер пакетов.

Репозитории Kali Linux по умолчанию

Как и любой другой дистрибутив Linux, Kali Linux также поставляется с собственными репозиториями, из которых вы можете устанавливать и обновлять системные пакеты.

Эти репозитории находятся в файле sources.list в каталоге /etc/apt.

Когда вы устанавливаете Kali Linux в первый раз, вы должны увидеть следующие репозитории по умолчанию в файле sources.list.

Вы можете просмотреть этот файл, выполнив приведенную ниже команду:

Если вы не получаете аналогичного результата, есть три наиболее вероятные причины:

ПРИМЕЧАНИЕ:Начиная с версии Kali Linux 2020.3, сетевые репозитории по умолчанию включены, даже если установка была выполнена без подключения к Интернету.

Переключение веток Kali Linux / регулярных репозиториев

Kali Linux поддерживает несколько веток.

В этой статье мы рассмотрим три основные.

Чтобы переключиться на любую из этих веток, вам нужно закомментировать репозиторий вашей текущей ветки в файле sources.list и добавить репозиторий нужной вам ветки.

Kali-rolling

Это основная ветка, включенная по умолчанию в вашей системе Kali Linux.

Эта ветка постоянно обновляется и берет большинство пакетов из ветки kali-dev.

Kali-last snapshot

Эта ветка является point-release, которая предоставляет пользователям гораздо более стабильное программное обеспечение и ПО:

Kali-experimental

Содержит пакеты, которые еще тестируются из ветки kali-bleeding edge.

Формат репозиториев Kali Linux

Как вы заметили, репозиторий – это не просто ссылка.

Он разделен на различные разделы:

Репозитории, не относящиеся к системе Kali Linux

Если вы хотите установить дополнительное программное обеспечение, вам может потребоваться добавить внешние репозитории, отличные от тех, которые предназначены для системы Kali Linux.

Эти новые репозитории НЕ должны добавляться в файл /etc/apt/sources.list.

Вместо этого они хранятся в собственном отдельном каталоге.

Наиболее распространенным путем для внешних репозиториев является каталог /etc/apt/sources.list.d.

Например, чтобы установить Signal на Kali Linux, нам нужно добавить репозиторий deb [arch=amd64] https://updates.signal.org/desktop/apt xenial main в каталог /sources.list.d.

ПРИМЕЧАНИЕ:Установка репозиториев Kali Linux на другой дистрибутив, например Ubuntu или Debian, может привести к поломке системы. Вы можете не заметить этого сразу, но по мере того, как вы продолжаете добавлять новые пакеты и обновлять систему, вы увеличиваете вероятность того, что ваша система не будет работать. Аналогично, добавление репозиториев другого дистрибутива в Kali Linux может нарушить работу вашей установки Kali.

Заключение

Тема “Репозитории Linux” может быть довольно сложной, особенно если вы только начинаете работать с системами Linux.

Это руководство дает вам более глубокое понимание репозиториев и того, как переключаться между различными ветками Kali Linux.

Несмотря на то, что мы в основном сосредоточились на ветке Kali-rolling, не стесняйтесь изучать другие ветки Kali.

Источник

Удачная модель ветвления для Git

В этой статье я представляю модель разработки, которую использую для всех моих проектов (как рабочих, так и частных) уже в течение года, и которая показала себя с хорошей стороны. Я давно собирался написать о ней, но до сих пор не находил свободного времени. Не буду рассказывать обо всех деталях проекта, коснусь лишь стратегии ветвления и управления релизами.

В качестве инструмента управления версиями всего исходного кода она использует Git.

Почему Git?

За полноценным обсуждением всех достоинств и недостатков Git в сравнении с централизованными системами контроля версий обращайтесь к всемирной сети. Там Вы найдёте достаточное количество споров на эту тему. Лично же я, как разработчик, на данный момент предпочитаю Git всем остальным инструментам. Git реально смог изменить отношение разработчиков к процессам слияния и ветвления. В классическом мире CVS/Subversion, из которого я пришёл, ветвление и слияние обычно считаются опасными («опасайтесь конфликтов слияния, они больно кусаются!»), и потому проводятся как можно реже.

Но с Git эти действия становятся исключительно простыми и дешёвыми, и потому на деле они становятся центральными элементами обычного ежедневного рабочего процесса. Просто сравните: в книгах по CVS/Subversion ветвление и слияние обычно рассматриваются в последних главах (для продвинутых пользователей), в то время как в любой книге про Git они бывают упомянуты уже к третьей главе (основы).

Благодаря своей простоте и предсказуемости, ветвление и слияние больше не являются действиями, которых стоит опасаться. Теперь инструменты управления версиями способны помочь в ветвлении и слиянии больше, чем какие-либо другие.

Но хватит говорить об инструментах, давайте перейдём к модели разработки. Модель, которую я хочу представить, — это, по сути, просто набор процедур, которые исполняет каждый член команды, чтобы все вместе могли достичь высокой управляемости процесса разработки.

Децентрализованный, но централизованный

Предлагаемая модель ветвления опирается на конфигурацию проекта, содержащую один центральный «истинный» репозиторий. Замечу, что этот репозиторий только считается центральным (так как Git является DVCS, у него нет такой вещи, как главный репозиторий, на техническом уровне). Мы будем называть этот репозиторий термином origin, т.к. это имя и так знакомо всем пользователям Git.

Каждый разработчик забирает и публикует изменения (pull & push) в origin. Но, помимо централизованных отношений push-pull, каждый разработчик также может забирать изменения от остальных коллег внутри своей микро-команды. Например, этот способ может быть удобен в ситуации, когда двое или более разработчиков работают вместе над большой новой фичей, но не могут издать незавершённую работу в origin раньше времени. На картинке выше изображены подгруппы Алисы и Боба, Алисы и Дэвида, Клэр и Дэвида.

Технически это реализуется несложно: Алиса создаёт удалённую ветку Git под названием bob, которая указывает на репозиторий Боба, а Боб делает то же самое с её репозиторием.

Главные ветви

Мы считаем ветку origin/master главной. То есть, исходный код в ней должен находиться в состоянии production-ready в любой произвольный момент времени.

Ветвь origin/develop мы считаем главной ветвью для разработки. Хранящийся в ней код в любой момент времени должен содержать самые последние изданные изменения, необходимые для следующего релиза. Эту ветку также можно назвать «интеграционной». Она служит источником для сборки автоматических ночных билдов.

Когда исходный код в ветви разработки (develop) достигает стабильного состояния и готов к релизу, все изменения должны быть определённым способом влиты в главную ветвь (master) и помечены тегом с номером релиза. Ниже мы рассмотрим этот процесс в деталях.

Следовательно, каждый раз, когда изменения вливаются в главную ветвь (master), мы по определению получаем новый релиз. Мы стараемся относиться к этому правилу очень строго, так что, в принципе, мы могли бы использовать хуки Git, чтобы автоматически собирать наши продукты и выкладывать их на рабочие сервера при каждом коммите в главную ветвь (master).

Вспомогательные ветви

Помимо главных ветвей master и develop, наша модель разработки содержит некоторое количество типов вспомогательных ветвей, которые используются для распараллеливания разработки между членами команды, для упрощения внедрения нового функционала (features), для подготовки релизов и для быстрого исправления проблем в производственной версии приложения. В отличие от главных ветвей, эти ветви всегда имеют ограниченный срок жизни. Каждая из них в конечном итоге рано или поздно удаляется.

Конечно же, с технической точки зрения, у этих ветвей нет ничего «специфического». Разбиение ветвей на категории существует только с точки зрения того, как они используются. А во всём остальном это старые добрые ветви Git.

Ветви функциональностей (feature branches)

Могут порождаться от: develop
Должны вливаться в: develop
Соглашение о наименовании: всё, за исключением master, develop, release-* или hotfix-*

Ветви функциональностей (feature branches), также называемые иногда тематическими ветвями (topic branches), используются для разработки новых функций, которые должны появиться в текущем или будущем релизах. При начале работы над функциональностью (фичей) может быть ещё неизвестно, в какой именно релиз она будет добавлена. Смысл существования ветви функциональности (feature branch) состоит в том, что она живёт так долго, сколько продолжается разработка данной функциональности (фичи). Когда работа в ветви завершена, последняя вливается обратно в главную ветвь разработки (что означает, что функциональность будет добавлена в грядущий релиз) или же удаляется (в случае неудачного эксперимента).

Ветви функциональностей (feature branches) обычно существуют в репозиториях разработчиков, но не в главном репозитории (origin).

Создание ветви функциональности (feature branch)

При начале работы над новой функциональностью делается ответвление от ветви разработки (develop).

Добавление завершённой функциональности в develop

Завершённая функциональность (фича) вливается обратно в ветвь разработки (develop) и попадает в следующий релиз.

Конечно, такой подход создаёт некоторое дополнительное количество (пустых) объектов коммитов, но получаемая выгода более чем оправдывает подобную цену.

Ветви релизов (release branches)

Могут порождаться от: develop
Должны вливаться в: develop и master
Соглашение о наименовании: release-*

Ветви релизов (release branches) используются для подготовки к выпуску новых версий продукта. Они позволяют расставить финальные точки над i перед выпуском новой версии. Кроме того, в них можно добавлять минорные исправления, а также подготавливать метаданные для очередного релиза (номер версии, дата сборки и т.д.). Когда вся эта работа выносится в ветвь релизов, главная ветвь разработки (develop) очищается для добавления последующих фич (которые войдут в следующий большой релиз).

Новую ветку релиза (release branch) надо порождать в тот момент, когда состояние ветви разработки полностью или почти полностью соответствует требованиям, соответствующим новому релизу. По крайней мере, вся необходимая функциональность, предназначенная к этому релизу, уже влита в ветвь разработки (develop). Функциональность, предназначенная к следующим релизам, может быть и не влита. Даже лучше, если ветки для этих функциональностей подождут, пока текущая ветвь релиза не отпочкуется от ветви разработки (develop).

Очередной релиз получает свой номер версии только в тот момент, когда для него создаётся новая ветвь, но ни в коем случае не раньше. Вплоть до этого момента ветвь разработки содержит изменения для «нового релиза», но пока ветка релиза не отделилась, точно неизвестно, будет ли этот релиз иметь версию 0.3, или 1.0, или какую-то другую. Решение принимается при создании новой ветви релиза и зависит от принятых на проекте правил нумерации версий проекта.

Создание ветви релиза (release branch)

Ветвь релиза создаётся из ветви разработки (develop). Пускай, например, текущий изданный релиз имеет версию 1.1.5, а на подходе новый большой релиз, полный изменений. Ветвь разработки (develop) готова к «следующему релизу», и мы решаем, что этот релиз будет иметь версию 1.2 (а не 1.1.6 или 2.0). В таком случае мы создаём новую ветвь и даём ей имя, соответствующее новой версии проекта:

Мы создали новую ветку, переключились в неё, а затем выставили номер версии (bump version number). В нашем примере bump-version.sh — это вымышленный скрипт, который изменяет некоторые файлы в рабочей копии, записывая в них новую версию. (Разумеется, эти изменения можно внести и вручную; я просто обращаю Ваше внимание на то, что некоторые файлы изменяются.) Затем мы делаем коммит с указанием новой версии проекта.

Эта новая ветвь может существовать ещё некоторое время, до тех пор, пока новый релиз окончательно не будет готов к выпуску. В течение этого времени к этой ветви (а не к develop) могут быть добавлены исправления найденных багов. Но добавление крупных новых изменений в эту ветвь строго запрещено. Они всегда должны вливаться в ветвь разработки (develop) и ждать следующего большого релиза.

Закрытие ветви релиза

Когда мы решаем, что ветвь релиза (release branch) окончательно готова для выпуска, нужно проделать несколько действий. В первую очередь ветвь релиза вливается в главную ветвь (напоминаю, каждый коммит в master — это по определению новый релиз). Далее, этот коммит в master должен быть помечен тегом, чтобы в дальнейшем можно было легко обратиться к любой существовавшей версии продукта. И наконец, изменения, сделанные в ветви релиза (release branch), должны быть добавлены обратно в разработку (ветвь develop), чтобы будущие релизы также содержали внесённые исправления багов.

Первые два шага в Git:

Теперь релиз издан и помечен тегом.

Чтобы сохранить изменения и в последующих релизах, мы должны влить эти изменения обратно в разработку. Делаем это так:

Этот шаг, в принципе, может привести к конфликту слияния (нередко бывает, что причиной конфликта является изменение номера версии проекта). Если это произошло, исправьте их и издайте коммит.

Теперь мы окончательно разделались с веткой релиза. Можно её удалять, потому что она нам больше не понадобится:

Ветви исправлений (hotfix branches)

Могут порождаться от: master
Должны вливаться в: develop и master
Соглашение о наименовании: hotfix-*

Ветви для исправлений (hotfix branches) весьма похожи на ветви релизов (release branches), так как они тоже используются для подготовки новых выпусков продукта, разве лишь незапланированных. Они порождаются необходимостью немедленно исправить нежелательное поведение производственной версии продукта. Когда в производственной версии находится баг, требующий немедленного исправления, из соответствующего данной версии тега главной ветви (master) порождается новая ветвь для работы над исправлением.

Смысл её существования состоит в том, что работа команды над ветвью разработки (develop) может спокойно продолжаться, в то время как кто-то один готовит быстрое исправление производственной версии.

Создание ветви исправлений (hotfix branch)

Ветви исправлений (hotfix branches) создаются из главной (master) ветви. Пускай, например, текущий производственный релиз имеет версию 1.2, и в нём (внезапно!) обнаруживается серьёзный баг. А изменения в ветви разработки (develop) ещё недостаточно стабильны, чтобы их издавать в новый релиз. Но мы можем создать новую ветвь исправлений и начать работать над решением проблемы:

Не забывайте обновлять номер версии после создания ветви!

Теперь можно исправлять баг, а изменения издавать хоть одним коммитом, хоть несколькими.

Закрытие ветви исправлений

Когда баг исправлен, изменения надо влить обратно в главную ветвь (master), а также в ветвь разработки (develop), чтобы гарантировать, что это исправление окажется и в следующем релизе. Это очень похоже на то, как закрывается ветвь релиза (release branch).

Прежде всего надо обновить главную ветвь (master) и пометить новую версию тегом.

Следующим шагом переносим исправление в ветвь разработки (develop).

У этого правила есть одно исключение: если в данный момент существует ветвь релиза (release branch), то ветвь исправления (hotfix branch) должна вливаться в неё, а не в ветвь разработки (develop). В этом случае исправления войдут в ветвь разработки вместе со всей ветвью релиза, когда та будет закрыта. (Хотя, если работа в develop требует немедленного исправления бага и не может ждать, пока будет завершено издание текущего релиза, Вы всё же можете влить исправления (bugfix) в ветвь разработки (develop), и это будет вполне безопасно).

И наконец, удаляем временную ветвь:

Заключение

Хотя в этой модели ветвления совершенно нет ничего принципиально нового, «большая картинка», с которой начинается эта статья, зарекомендовала себя в наших проектах с самой лучшей стороны. Она формирует элегантную мысленную модель, которую легко полностью охватить одним взглядом, и которая позволяет сформировать у команды совместное понимание процессов ветвления и слияния, действующих на проекте.

Высококачественная PDF-версия этой картинки свободна для скачивания здесь. Распечатайте её и повесьте у себя на стену, чтобы к ней можно было обратиться в любой момент.

Прим. переводчика: статья не новая, ссылка на оригинал уже появлялась на хабре. Этот перевод — для тех, кому английский ещё даётся не так легко (а также для моих коллег, среди которых я занимаюсь пропагандой, хехе). Для автоматизации описанных в статье процедур автор создал проект gitflow, который можно найти на github.

Источник