Что такое Git и Subversion? - PullRequest
       13

Что такое Git и Subversion?

13 голосов
/ 13 февраля 2010

Я вижу много сайтов, ссылающихся на git, github, svn, subversion и т. Д., Но я никогда не знал, что это за штука. Я также слышу много терминов, таких как «svn repo», «commit» и «push» - я пробовал поискать в Google, но мне кажется, что я так мало знаю об этом предмете, что даже не знаю, с чего начать.

Может ли кто-нибудь дать мне начальный толчок, чтобы я мог продолжить исследования самостоятельно? О чем все это?

Спасибо!

ребята: большое спасибо за все действительно длинные и всеобъемлющие объяснения. Хотелось бы, чтобы я мог выбрать более одного ответа, но, к сожалению, SO не позволяет этого (они должны иметь функцию голосования за 1, 2 и 3 место или что-то в этом роде). спасибо всем большое!

Ответы [ 7 ]

23 голосов
/ 13 февраля 2010

Контроль версий (a.k.a. контроль версий).

Рассмотрим следующую проблему. Вы работаете над проектом с кем-то еще и делитесь файлами. Вам обоим нужно поработать, скажем, над "WhwhatController.java". Это огромный файл, и вы оба должны отредактировать его.

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

Старое, примитивное «решение» этой проблемы состояло в том, чтобы иметь механизм проверки / возврата. Когда вам нужно отредактировать файл, вы «извлекаете его», и файл блокируется, так что никто не может редактировать его, пока вы не разблокируете его, «отметив его». Это делается с помощью соответствующего программного обеспечения, например, невероятно глупого кусочка Microsoft SourceSafe. Но когда люди забывают «зарегистрировать файл», никто больше не может редактировать этот файл, пока он используется. Затем кто-то уходит в отпуск или покидает проект по какой-то другой причине, и в результате возникает бесконечный хаос, растерянность и, как правило, немало утерянного кода. Это добавляет огромную управленческую работу.

Затем появился CVS и впоследствии Subversion, которую авторы называют «CVS сделано правильно», поэтому CVS и Subversion - это, по сути, одна и та же идея. С тех, нет фактической проверки. Вы просто редактируете нужные вам файлы и регистрируете их. Обратите внимание, что фактические файлы хранятся на центральном сервере, и каждый пользователь также запускает программное обеспечение на своих рабочих станциях. Это расположение на сервере называется хранилищем.

Теперь, что произойдет, если два человека работают над одним файлом в CVS / Subversion? Они объединяются, как правило, с использованием GNU diff и patch. 'diff' - это утилита, которая извлекает разницу между двумя файлами. «patch» использует такие «diff» файлы для исправления других файлов.

Так что, если вы работаете с WhwhatController.java в одной функции, а я работаю над тем же файлом в другой функции, то когда вы закончите со своими вещами, вы просто отметите их и внесете изменения применяются к файлу на сервере. Между тем, моя локальная копия не знает о ваших изменениях, поэтому ваши изменения не влияют на мой код. Когда я закончу с изменениями, я также проверю файл. Но теперь у нас есть этот, казалось бы, сложный сценарий.

Давайте назовем оригинальный файл WheverController.java файлом А. Вы редактируете файл, и в результате получается файл B. Я редактирую тот же файл в другом месте, без ваших изменений, и этот файл является файлом C.

Теперь у нас, похоже, есть проблема. Изменения в файлах B и C являются изменениями в файле A. Таким образом, в случае смешно отсталого барахла, такого как SourceSafe или Dreamweaver, обычно заканчиваются изменениями файла B (потому что он был зарегистрирован первым).

CVS / Subversion и предположительно Git (о котором я почти ничего не знаю) создают патчи вместо просто переопределения файлов.

Разница между файлом A и C создается и становится патчем X. Разница между A и B создается и становится патчем Y.

Затем исправления X и Y применяются к файлу A, поэтому конечным результатом является файл A + изменения, внесенные в B и C на наших соответствующих рабочих станциях.

Обычно это работает безупречно. Иногда мы можем работать над одной и той же функцией в одном и том же коде, и в этом случае CVS / Subversion уведомит программиста о проблеме и представит проблему в самом файле. Эти проблемы обычно легко решаются, по крайней мере у меня никогда не было проблем с их решением. Графические утилиты, такие как Visual Studio, Project Builder (Mac OS X) и тому подобное, обычно показывают как файлы, так и конфликты, так что вы можете выбрать, какие строки вы хотите сохранить, а какие выбросить ... и затем вы также можете редактировать файл вручную, если вы хотите объединить конфликт вручную.

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

Надеюсь, это объясняет.

РЕДАКТИРОВАТЬ: Есть много других преимуществ с приличными системами контроля версий, такими как Subversion и, вероятно, Git. Если есть проблема, вы можете вернуться к другим версиям, чтобы вам не приходилось сохранять все резервные копии вручную. На самом деле, по крайней мере с Subversion, если я что-то напутал или захочу взглянуть на старую версию кода, я могу сделать это, не мешая чужой работе.

9 голосов
/ 13 февраля 2010

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

Некоторые преимущества контроля версий:

  • Ветви. Вы можете создать новую ветку для каждой ошибки, например, над которой вы работаете, без вмешательства в код другого разработчика. Большинство систем контроля версий будут делать дешевые копии, то есть новая ветвь будет занимать (почти) лишнее место.
  • Управление версиями. Вы всегда можете вернуться к старым версиям, обновить их до новых версий или просмотреть журнал фиксации, чтобы увидеть, что произошло с кодом. Инструменты GUI, такие как TortoiseSVN, даже предоставляют утилиты diff, которые графически показывают разницу. Термин «зафиксировать» в основном означает помещение новых версий файлов в хранилище (или добавление / удаление файлов). Системы контроля версий также поддерживают «объединение», то есть автоматическое объединение изменений в файле, который был изменен несколькими людьми (часто на основе строк).
  • Одновременная разработка. У нескольких разработчиков может быть своя собственная "рабочая копия" (также называемая "оформлением заказа"). Это означает, что - даже если вы не используете ветки - ваша локальная копия кода будет компилироваться, даже если другие в настоящее время работают над проектом (потому что у них есть собственные рабочие копии). Когда вы чувствуете, что текущий код может быть полезен для других, вы можете зафиксировать свои изменения, а другие могут обновить свою копию.
  • Центральное хранилище и резервное копирование. Это действительно для CVS / Subversion / ..., а не для GIT. Это преимущество, потому что есть центральное место для фиксации изменений и получения изменений от других разработчиков.
  • Распространение. Но это действительно для GIT (не для Subversion). Это означает, что для проекта может быть несколько репозиториев, независимых друг от друга. Например, ядро ​​Linux имеет это. Люди могут «вытащить» свой собственный репозиторий, в котором они работают, - он действует как полный репозиторий, то есть коммиты создаются локально, а не на сервере. Если вы хотите включить исправления из репозиториев других людей (или из общедоступных репозиториев, таких как kernel.org ), вы просто «вытягиваете» эти изменения в локальное репо. Если вы хотите передать кому-то свой патч, вы «проталкиваете» свои изменения в удаленном репо (если у вас есть права).

Надеюсь, что объяснил термины, которые вы упомянули. Я думаю, что хорошее начало работы с контролем версий - это Subversion, использующая TortoiseSVN для Windows , если это возможно. Есть даже бесплатная книга об этом - Контроль версий с Subversion .

8 голосов
/ 13 февраля 2010

Это все разные версии системы контроля версий:

http://en.wikipedia.org/wiki/Revision_control

7 голосов
/ 23 февраля 2010

" The Git Parable " Тома Престона-Уорнера (mojombo), одного из сотрудников GitHub, описывает, как могла быть создана система контроля версий, такая как Git, .... в то же время, описывая, почему кому-то нужна и нужна (распределенная) система контроля версий.

См. также статью " Визуальное руководство по управлению версиями " в Better Explained.


Существует много преимуществ использования системы контроля версий.Давайте перечислим их в порядке возрастания сложности: увеличение количества разработчиков, увеличение размера проекта / истории проекта, более сложные рабочие процессы и т. Д.

Один разработчик, одна ветвь

Даже если выВы являетесь единственным (единственным) разработчиком вашего проекта, и (по крайней мере, на данный момент) вы не планируете его менять, система контроля версий по-прежнему полезна.Это позволяет:

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

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

    Вы также хотели бы знать, что вы сделали,и над чем вы работали в последнее время.Это означает, что вы должны описать каждый набор изменений (каждый коммит).

  • Аннотировать файл / историю просмотра .Если у вас нет идеальной памяти, иногда вам захочется узнать, почему (и когда, и в случае, когда есть несколько разработчиков, которые) написали данный набор строк.Комментариев не всегда достаточно.Для этого вы можете использовать (если ваша система управления версиями предоставляет) построчные аннотации истории файлов (scm annotate или scm blame) или другие подобные инструменты, такие как так называемый «поиск по кирке» в Git, где вы ищете / просматриваете историюдля коммитов, которые вводили или удаляли данную строку.

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

  • История деления на ошибки .Современные системы контроля версий предлагают альтернативный (для вставки операторов печати или отладчика) способ поиска ошибок ... в некоторых случаях на keast.Когда вы замечаете ошибку или получаете сообщение об ошибке, и эта ошибка не является результатом последнего изменения, вы можете использовать систему контроля версий (csm bisect) для автоматического поиска коммита, который привел к ошибке (первый коммит, который дал ошибку),Система контроля версий находит такой коммит, используя деление пополам на истории проекта, извлекая (проверяя) версии, которые вы пометили как хорошие (без ошибок) или плохие, пока не найдет коммиты, которые привели к ошибке.

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

Несколько ветвей

Позже вам понадобится еще одна особенность системы контроля версий: возможность параллельно работать над различными направлениями разработки (разновидностями) вашего проекта, так называемыми ветками .Это включает, но не ограничивается:

  • Taging Releases . Когда вы публикуете новую версию своего проекта для широкой публики, вы хотите пометить (пометить) выпущенную версию. Таким образом, когда кто-то скажет вам, что в версии X.Y вашего проекта есть ошибка, вы сможете проверить эту версию и проверить, можете ли вы воспроизвести эту ошибку (и, возможно, найти ошибку посредством деления на части, см. Выше). Это может быть полезно, даже если вы не выпускаете свой проект, если вы используете, возможно, разные версии, развернутые в разных местах.

    Для этого теги должны быть неизменяемыми (конечно).

  • Долгоживущие ветви . Давайте предположим, что вы выпустили свой проект, и кто-то нашел ошибку. Вы, вероятно, захотите быть ebale, чтобы поставить (выпустить) исправленную версию, не останавливая работу над новыми функциями, и не отправляя версию из разработки, которая может быть нестабильной и содержать множество других ошибок. Также вы хотели бы, чтобы исправление также было в версии, над которой вы работаете (если оно не было исправлено независимо).

    Для этого вы должны использовать долгоживущие ветки: поддержка ветка, в которую вы будете вносить только исправления ошибок, и разработка ветка ( или транк ), где вы будете выполнять новую работу, вводить новые функции и т. д. Может быть больше веток с различной стабильностью. Например, проект Git имеет четыре таких ветки: «maint» для исправлений ошибок, «master» для достаточно стабильных изменений, «next»; для разработки и ветки 'pu' или "предлагаемые обновления". В других рабочих процессах у вас есть отдельная ветка обслуживания (исправления ошибок) для каждого выпуска.

    Цитируя Джоэла Спольски: «Разделение стабильного кода и кода разработчика - это именно то, что должен делать контроль над исходным кодом».

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

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

Несколько разработчиков

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

См. Также " Понимание управления версиями ", работа в стадии разработки Эрика С. Рэймонда (автора, среди прочего, "Catedral and Bazaar" и "Искусство программирования Unix") для описания различных методов, которые система контроля версий использует для совместной работы.

4 голосов
/ 13 февраля 2010

Git и Subversion (также известные как svn) являются системами контроля версий, контроля версий или версий. Они помогают вам управлять исходным кодом и отслеживать историю изменений каждого файла, управляемого системой. Могут быть полезны ссылки на статьи в Википедии.

github - сервис для размещения и управления git-репозиториями. По сути, он помещает репозиторий в оперативный режим, чтобы несколько человек могли легко взаимодействовать с репозиторием.

Команда commit обычно хранит набор изменений в репозитории исходного кода. Это создает новую ревизию в хранилище.

Команда push применяется только к распределенным системам управления версиями, таким как git или mercurial (также известная как hg). Push позволяет переносить изменения из одного хранилища в другое. Понятие распределенных систем контроля версий заключается в том, что у каждого пользователя есть свой собственный репозиторий. Когда пользователь завершает изменения, он отправляет их в другие хранилища (возможно, в центральное хранилище проектов или в качестве исправления для хранилища другого пользователя).

Смысл этих систем в

  • хранить историю процесса разработки
  • расширение сотрудничества между несколькими разработчиками
  • разрешить восстановление и исправление старых версий кода
  • связать изменения исходного кода с конкретными функциями или ошибками (см. Fogbugz и kiln)
  • создание вариантов кода (веток) для экспериментов или параллельной разработки
2 голосов
/ 13 февраля 2010

Взгляните на первую главу (бесплатная, онлайн) книга о подрывной деятельности . Описывает, что такое системы контроля версий (например, subversion).

2 голосов
/ 13 февраля 2010

Хранилища исходного кода.

По сути, это способ обмена кодом между командами с возможностью видеть, кто «совершил» (добавил) какой код в какое время и кто что изменил в какое время и т. Д.

...