מתוך הצורך הקיומי לשימוש בגיט, קיימת רמת מיומנות בסיסית הנפוצה בקרב אנשי תוכנה.
נקרא לה "רמה 2".
רוב אנשי התוכנה נמצאים ברמה 2. הם יודעים לעבוד בצורה שוטפת עם גיט, וכבר לא נתקלים בבעיות רציניות איתו (אין כבר מצבי "Detached from head" שכיחים כמו בהתחלה), אבל עדיין יש עוד הרבה בגיט שאינו מוכר ואינו מובן.
המציאות מוכיחה שבהחלט אפשר לעבוד ברמה 2, לאורך שנים - ולהפיק תוכנה שימושית ומועילה (אולי אפילו מעולה).
מצד שני... קצת חבל. לשמוע מושגים ולא להבין מה הם אומרים?
לי זה קצת חבל ולכן אנסה לתת הסברים קצרים אך משמעותיים על כמה מונחים שבחרתי שנמצאים בנקודה הזו: שמם מוכר - אך יש ערפל גדול לגבי המהות שלהם, ומה הם עושים. דיסאינפורמציה גדולה מאינפורמציה.
ייתכן גם שאני טועה לחלוטין, ורק קומץ סטודנטים, למדעי-הרוח, בשנה ראשונה לא מכירים את המונחים הללו 😊.
Rebase
rebase הוא דרך חלופית ל merge על מנת למזג עבודה בין branches.
יש הנחה ששמעתי הגורסת שמשתמשי SVN לשעבר, הרגילים לעבור על branch יחיד (להלן "trunk") - נוטים להשתמש ב rebase כי הוא מזכיר את הכלי הקודם שלהם. לא יודע.
בעוד השימוש בפקודת
git merge מייצרת היסטוריה של branches מקבילים המתמזגים זה לתוך זה כמו מסילות רכבת בתחנת רכבת גדולה באירופה, rebase משמר היסטוריה שנראית כמו "מסילה בודדה".
 |
אותו קוד, אותם שינויים - שיטת מיזוגים שונה (בד"כ ה rebase יהיה ארוך יותר) |
Merge - מציג את המצב המסובך כפי שהוא.
Rebase - יוצר מציאות קלה יותר למעקב - אך יש מחירים לייצר אותה.
נניח שיש לנו branch עם 6 commits שאנחנו רוצים למזג ל master.
כאשר אנו משתמשים ב merge - זו פעולה אחת, עם סיכוי מסוים לקונפליקטים. הקונפליקטים נוצרים ע"פ המצב הסופי של ה branch שלי מול המצב הסופי של ה master.
rebase הוא מורכב יותר: הוא ייקח את ה branch שלי, commit אחר commit, ויטמיע אותם בראש ה master branch כאילו רק עכשיו כתבתי אותם. אחד אחרי השני.
הסיכוי לקונפליקטים שצריך לפתור גדל משמעותית: ייתכן שכתבתי קוד ב commit מס'3 שיצור קונפליקט, אבל הסרתי את הקוד הזה ב commit מס'5 (המאוחר יותר ב branch).
אם הייתי עובד עם merge לא הייתי צריך להתעסק עם הקונפליקט (הזמני) הזה -הקוד הסופי אינו מכיל אותו.
ב rebase אני צריך לפתור אותו. אם ב commit מס'4 היה שינוי נוסף בקוד הזה - ייתכן וייווצר קונפליקט נוסף שיהיה עלי לפתור.
בקיצור: rebase יוצר היסטוריה שקל יותר להבין, במחיר של פתירת קונפליקטים רבים יותר בעת המיזוג.
מתי זה משתלם?
עבור רוב הפרויקטים זה לא משתלם. בפרויקטים בהם עוברים על ההיסטוריה פעמים רבות ומנסים להבין אותה - זה עשוי להשתלם.
Rebase נפוץ בשימוש, יחסית, בפרויקטי Open Source מרובי תורמים זרים - כלומר: תורמים שלא מכירים זה את זה ולכן התקשורת ביניהם היא פחות יעילה. במקרים האלו - היסטוריה נקיה יכולה לחסוך הרבה בעיות תקשורת, ולהצדיק את המחיר הנוסף בביצוע rebase.
נ.ב: בעוד את פקודת git merge מפעילים מתוך branch היעד (אליו רוצים למזג), את פקודת git rebase מפעילים מתוך branch המקור - ה branch אשר את תוכנו רוצים למזג/"להרכיב" על branch אחר.
Fast Forward
אין סיכוי שלא נתקלתם במונח Fast Forward (להלן FF) בעבודה עם גיט.
"טוב, קרה פה משהו מהיר. נראה שאין בעיות. יופי - נמשיך הלאה!" - היא התגובה המקובלת להודעה של גיט שבוצע FF.
בואו נבין טיפה יותר:
בעצם FF הוא אופטימיזציה של גיט על מנת לפשט את ההיסטוריה.
כאשר יש לי branch (למשל: feature branch) שאני רוצה למזג (למשל: ל master) אבל ה master לא השתנה מאז שהתפצלתי ל feature branch - אפשר לפשט את הדברים.
merge בשלב כזה ל master הוא כאילו הוספתי את ה commits שלי ,לא ל feature branch - אלא ישירות ל master.
התוצאה הרי הייתה זהה.
יש פה גם עניין של חיסכון ברמת המימוש הפנימי של גיט: בוודאי שמעתם ש branch הוא בעצם רק pointer.
על מנת לבצע FF כל מה שגיט צריך הוא להפנות את המצביע (branch) בשם "master" להצביע לנקודה של המצביע "feature branch".
אם מסיבה כלשהי חשוב לכם להדגיש את ההיסטוריה כפי שקרתה - אתם יכולים להורות ל git לבצע merge ללא FF.
זה כל הסיפור.
Git Revert
את הפקודה הזו כדאי להכיר כי היא מאוד שימושית ברגעים מסוימים. אני לא בטוח כמה אנשים מודעים אליה. הרבה פעמים אנשים עם ניסיון בכלי version control אחרים נוטים להתבלבל ולחשוב ש
git revert עושה מה שבעצם
git reset עושה.
הפקודה
git revert HEAD~2 (אנו מכוונים ל commit X, הרי הוא Head פחות 2 צעדים אחורה) - מנסה ליצור commit חדש המסומן כ X- אשר מהווה את ההופכי של X ומבטל את כל הפעולות שנעשו.
לאחר ש commit -X ייווצר - כל התוספות של y ו z - עדיין יהיו תקפות, לא ביטלנו אותן.
מתי הדבר שימושי? למשל כאשר יש בעיה בסביבת production או staging שאנו רוצים לפתור מהר, ואנו יודעים איזה commit אחראי לה. ניתן אח"כ לעשות revert ל X- - ולקבל בחזרה את השינויים של X למערכת.
אם יש התנגשות שגיט לא יודע לפתור (בד"כ הוא עושה עבודה יפה מאוד) - אזי הוא ייתן לכם לפתור את הקונפליקטים.
ניתן לקרוא ל git revert --abort (ממש כמו merge) - אם הסתבכתם בהתרה שלהם.
revert ניתן גם לעשות מתוך ה UI של github ולפתוח ממנו מיד Pull Request - מה שמאוד נוח.
Git ReReRe (ידוע גם כ Re3)
הנה פקודה ששמה נשמע מאיים ומסתורי כאחד. רבים שמעו עליה (כי מישהו בסביבתם השתמש בה) - אבל אין להם מושג ירוק במה בעצם מדובר.
השם הלא-שגרתי הוא קיצור לא
Reuse
Recorded
Resolution או "שימוש-חוזר בפתרונות מוקלטים".
שימוש נפוץ בפקודה היא בסיטואציות בהן לא עובדים ב Continuous Delivery אלא ב long feature branches.
למשל: אני עובד על פיצ'ר במשך שבועיים-שלושה, ורוצה כל יום למשוך שינויים מה master.
לרוע המזל אני נתקל יום אחרי יום באותו ה merge conflict כי אני עובד על קטע קוד שעובר שוב ושוב שינויים גם על גבי ה master.
תסריט נפוץ אחר הוא כאשר עובדים עם rebase, ואז ישנם הרבה קונפליקטים דומים. למשל: אני עושה rebase ל branch עם 10 commits המכיל 4-5 קונפליקטים דומים על אותו האזור בדיוק. אני רוצה שגיט ילמד איך פתרתי את הקונפליקט הפעם הראשונה - ו"יסתדר לבד" בפעמים הבאות.
רהרהרה היא גם פקודה וגם קונפיגורציה. אנו אומרים לגיט להקליט את ה מיזוגים שאנו עושים (בעקבות rebase, merge, cherry-pick וכדומה) - בכדי שישמש בהם כ reference ל conflict resolution אוטומטי בעתיד.
הפעלת הקונפיגורציה הבסיסית נראית כך:
git config --global rerere.enabled 1
בכל פעולה בה יש מיזוג של קוד (merge, rebase, ועוד) והיה קונפליקט שנפתר על ידי ידנית - גיט ישמור "fingerprint".
ה fingerprint הוא ספציפי לקובץ מסוים, ומכיל את הקונפליקט: מה היה לפני, בשני ה branches שביניהם יש קונפליקט - ואיך נראה הקוד לאחר שפתרתי את הקונפליקט.
בעזרת pattern matching דיי שמרני (אין פה היבטים מתקדמים של "למידת מכונה"), גיט יזהה מקרים דומים - ויבצע את אותו הטיפול שאני ראיתי אותו. הקונפליקט לא חייב להיות זהה 1:1 ברמת הקוד - גיט יכול לזהות שינויים קלים ב pattern ולהתייחס אליהם בצורה נכונה.
מצד אחד יש כאן משהו מאוד נוח שיכול לחסוך לי זמן יקר של טיפול בקונפליקטים.
מצד שני יש כאן סיכון מסוים:
- שגיט יבצע טעות, ויבצע merge שמתאים ל pattern שהוא זיהה - איך אינו נכון.
- אני ביצעתי טעות ולימדתי את גיט/רהרהרה פתרון שגוי - שהוא יחזור עליו עוד מספר פעמים עד שאזהה את הטעות.
האם גיט רהרהרה שווה את הסיכון? התשובה כנראה מאוד אינדיבידואלית.
רהרהרה מכיל גם מנגנוני תיקון, כמו הפקודה
git rerere forget path_spec - המאפשרים לי לתקן למידה לא-טובה, אם זה גם אומר שעלי להשקיע עבודה נוספת / המנגנון לא פועל בצורה אוטומטית לגמרי.
סיכום
נגענו בכמה פקודות / מנגנונים בגיט - שעשויים להישמע "מאיימים" כאשר לא מכירים אותם.
אני מקווה שהצלחנו להסיר מעט מהערפל ולהראות שהשד לא כ"כ נורא.
אולי אפילו נצליח להשתמש בגיט בצורה קצת יותר חכמה.
שיהיה בהצלחה!
---
לינקים רלוונטיים
Git Flight Rules - דוגמאות והסברים על מגוון פעולות בגיט.
מדריך לשימוש בגיט רהרהרה