Najlepsza praktyka: przechowywanie wersji oprogramowania [zamknięte]

Czy istnieje jakaś wskazówka lub standardowa najlepsza praktyka w zakresie wersji oprogramowania tworzonego w wolnym czasie dla zabawy, ale mimo to będą używane przez niektórych ludzi? Myślę, że konieczna jest wersja takiego oprogramowania, abyś wiedział o wersji, o której mówi (np. W celu naprawy błędów, wsparcia itd.).

Ale gdzie mam rozpocząć wersjonowanie? 0.0.0? lub 0,0? A jak zwiększyć liczby? główna wersja. drobne zmiany? i czy żaden system zatwierdzania wersji nie powinien być inną wersją? czy jest to tylko w przypadku wersji, które są wykorzystywane w produktywny sposób?

Powinieneś zacząć od wersji 1, chyba że wiesz, że pierwsza wersja, którą „wypuszczasz”, jest w jakiś sposób niekompletna.

Jeśli chodzi o sposób zwiększania wersji, to zależy od ciebie, ale użyj głównej, mniejszej numeracji kompilacji jako przewodnika.

Nie musisz mieć każdej wersji, którą zobowiązujesz się do kontroli źródła, jako innej wersji - wkrótce będziesz miał bardzo duży numer wersji. Musisz tylko zwiększyć numer wersji (w jakiś sposób), kiedy wypuszczasz nową wersję na świat zewnętrzny.

Więc jeśli wykonasz poważną zmianę, przejdź z wersji 1.0.0.0 do wersji 2.0.0.0 (na przykład zmieniłeś WinForms na WPF). Jeśli dokonasz mniejszej zmiany, przejdź z wersji 1.0.0.0 do 1.1.0.0 (dodano obsługę plików png). Jeśli dokonasz drobnej zmiany, przejdź od 1.0.0.0 do 1.0.1.0 (naprawiłeś kilka błędów).

Jeśli naprawdę chcesz uzyskać szczegółowe informacje, użyj ostatecznej liczby jako numeru kompilacji, który zwiększałby się przy każdym zameldowaniu / zatwierdzeniu (ale myślę, że to idzie za daleko).

Chciałbym użyć x.y.zpewnego rodzaju wersji

x- główne wydanie
y- niewielkie wydanie
z- numer kompilacji

Zasadniczo podążam za tym wzorem:

• zacznij od 0.1.0

• kiedy jest gotowy, rozgałęziam kod w repozytorium źródłowym, oznaczam 0.1.0 i tworzę gałąź 0.1.0, nagłówek / pień zmienia się w migawkę 0.2.0 lub coś podobnego

• Dodam nowe funkcje tylko do pnia, ale poprawki do backportu do oddziału i z czasem go uwalniam 0.1.1, 0.1.2, ...

• Deklaruję wersję 1.0.0, gdy produkt jest uważany za kompletny i nie ma istotnych niedociągnięć

• od tego momentu - każdy może zdecydować, kiedy zwiększyć wersję główną ...

Używam tej reguły do ​​moich aplikacji:

xyz

Gdzie:

• x = główny numer wersji, 1- ~.
• y = numer funkcji, 0–9. Zwiększ tę liczbę, jeśli zmiana zawiera nowe funkcje z poprawkami błędów lub bez nich.
• z = numer poprawki, 0– ~. Zwiększ tę liczbę, jeśli zmiana zawiera tylko poprawki błędów.

Przykład:

• W przypadku nowej aplikacji numer wersji zaczyna się od 1.0.0.
• Jeśli nowa wersja zawiera tylko poprawki błędów, zwiększ numer poprawki, aby numer wersji wynosił 1.0.1.
• Jeśli nowa wersja zawiera nowe funkcje z poprawkami błędów lub bez nich, zwiększ numer funkcji i zresetuj numer poprawki do zera, aby numer wersji wynosił 1.1.0. Jeśli liczba funkcji osiągnie 9, zwiększ główny numer wersji i zresetuj numer funkcji i poprawki do zera (2.0.0 itp.)

Używamy abcd gdzie

• a - major (zwiększany przy dostawie do klienta)
• b - drobna (zwiększana przy dostawie do klienta)
• c - korekta (zwiększona w wersjach wewnętrznych)
• d - kompilacja (zwiększana przez tempomat)

Jeszcze innym przykładem takiego A.B.Cpodejścia jest wersja pakietu Eclipse . Pakiety Eclipse mają raczej czwarty segment:

W Eclipse numery wersji składają się z czterech (4) segmentów: odpowiednio 3 liczb całkowitych i ciągu znaków major.minor.service.qualifier. Każdy segment zawiera inną intencję:

• główny segment wskazuje na uszkodzenie interfejsu API
• mniejszy segment wskazuje zmiany „widoczne z zewnątrz”
• segment usługi wskazuje poprawki błędów i zmianę strumienia programowania
• segment kwalifikatora wskazuje konkretną kompilację

Istnieje również system wersjonowania data , np: YYYY.MM, YY.MM,YYYYMMDD

Jest to dość pouczające, ponieważ pierwsze spojrzenie daje wrażenie o dacie premiery. Ale wolę schemat Xyz, ponieważ zawsze chcę znać dokładny punkt produktu w jego cyklu życia (Major.minor.release)

Podstawowa odpowiedź brzmi „to zależy”.

Jaki jest twój cel w wersjonowaniu? Wiele osób korzysta z version.revision.build i tylko reklamuje wersję.revision na świecie, ponieważ jest to wersja wydana, a nie wersja deweloperska. Jeśli użyjesz „wersji” odprawy, szybko przekonasz się, że numery wersji stają się duże.

Jeśli planujesz swój projekt, zwiększam wersję dla wydań z drobnymi zmianami i wersję dla wydań z poważnymi zmianami, poprawkami błędów lub funkcjonalnością / funkcjami. Jeśli oferujesz wersje beta lub nocne wersje kompilacji, rozszerz wersję, aby uwzględnić kompilację i zwiększ ją w każdej wersji.

W końcu jednak to zależy od ciebie i musi mieć sens.

Jak mówi Mahesh: użyłbym wersji Xyz

x - główne wydanie y - niewielkie wydanie z - numer kompilacji

możesz dodać datę / godzinę, może zamiast z.

Zwiększasz wersję mniejszą, gdy masz inną wersję. Wersja główna prawdopodobnie pozostanie na poziomie 0 lub 1, zmienisz to, gdy naprawdę dokonasz dużych zmian (często, gdy twoje oprogramowanie jest w stanie niezgodnym z poprzednimi wersjami lub zmieniłeś cały framework)

Wiesz, że zawsze możesz sprawdzić, co robią inni. Oprogramowanie typu open source zazwyczaj umożliwia dostęp do swoich repozytoriów. Na przykład możesz skierować przeglądarkę SVN na http://svn.doctrine-project.org i rzucić okiem na system kontroli wersji używany w prawdziwym projekcie.

Numery wersji, tagi, wszystko tam jest.

Stosujemy podejście abc, takie jak:

przyrost „a”, jeśli nastąpiły jakieś poważne zmiany w aplikacji. Podobnie jak aktualizujemy aplikację .NET 1.1 do .NET 3.5

przyrost „b”, jeśli wystąpią drobne zmiany, takie jak nowy CR lub Enhancement.

zwiększ „c”, jeśli w kodzie występują poprawki błędów.

Zaczynam wersjonowanie od najniższego (bez poprawek) segmentu. Nie ograniczam tego segmentu do 10. O ile nie śledzisz kompilacji, musisz tylko zdecydować, kiedy chcesz zastosować przyrost. Jeśli masz fazę kontroli jakości, może to być miejsce, w którym zastosujesz przyrost do najniższego segmentu, a następnie następny segment, gdy przejdzie kontrolę jakości i zostanie zwolniony. Pozostaw najwyższy segment dla głównych zmian zachowania / interfejsu użytkownika.

Jeśli jesteś podobny do mnie, uczynisz z niego hybrydę metod, aby dopasować tempo rozwoju oprogramowania.

Myślę, że najbardziej akceptowany wzorzec abc lub abcd, szczególnie jeśli masz mieszankę QA / Compliance. Miałem tak dużo problemów z randkami, będąc regularną częścią wersji, że zrezygnowałem z tego.

Nie śledzę kompilacji, więc lubię używać wzorca abc, chyba że w grę wchodzi poprawka. Kiedy muszę zastosować poprawkę, wówczas stosuję parametr d jako datę i godzinę. Przyjąłem parametr czasu jako d, ponieważ zawsze istnieje potencjał kilku w ciągu jednego dnia, gdy rzeczy naprawdę wybuchają w produkcji. Segment d stosuję tylko (RRRRMMDDGGNN) tylko wtedy, gdy rozchodzę się w celu uzyskania poprawki produkcyjnej.

Osobiście nie byłbym przeciwny schematowi oprogramowania va.b revc, w którym c oznacza RRRRMMDDGGMM lub RRRRMMDD.

Wszystko, co powiedział. Jeśli po prostu złapiesz narzędzie do skonfigurowania i uruchomienia go, unikniesz bólu głowy związanego z opiniami na temat wersji i możesz po prostu powiedzieć „użyj narzędzia” ... ponieważ wszyscy w procesie programowania są zazwyczaj tak zgodni .