• Croquette@sh.itjust.works
    link
    fedilink
    arrow-up
    0
    ·
    7 months ago

    I know this is a meme post, but can someone succinctly explain rebase vs merge?

    I am an amateur trying to learn my tool.

    • jaemo@sh.itjust.works
      link
      fedilink
      arrow-up
      0
      ·
      7 months ago

      Merge keeps the original timeline. Your commits go in along with anything else that happened relative to the branch you based your work off (probably main). This generates a merge commit.

      Rebase will replay all the commits that happened while you were doing your work before your commits happen, and then put yours at the HEAD, so that they are the most recent commits. You have to mitigate any conflicts that impact the same files as these commits are replayed, if any conflicts arise. These are resolved the same way any merge conflict is. There is no frivolous merge commit in this scenario.

      TlDR; End result, everything that happened to the branch minus your work, happens. Then your stuff happens after. Much tidy and clean.

      • Croquette@sh.itjust.works
        link
        fedilink
        arrow-up
        0
        ·
        7 months ago

        Thanks for the explanation. It makes sense. To my untrained eyes, it feels like both merge and rebase have their use. I will try to keep that in mind.

        • aubeynarf@lemmynsfw.com
          link
          fedilink
          arrow-up
          1
          ·
          6 months ago

          Never use rebase for any branch that has left your machine (been pushed) and which another entity may have a local copy of (especially if that entity may have committed edits to it).

        • JackbyDev@programming.dev
          link
          fedilink
          English
          arrow-up
          0
          ·
          7 months ago

          Yes. They do. A lot of people will use vacuous terms like “clean history” when arguing for one over the other. In my opinion, most repositories have larger problems than rebase versus merge. Like commit messages.

          Also, remember, even if your team/repository prefers merges over rebases for getting changes into the main branch, that doesn’t mean you shouldn’t be using rebase locally for various things.

          • Croquette@sh.itjust.works
            link
            fedilink
            arrow-up
            0
            ·
            7 months ago

            How would rebasing my own branch work? Do I rebase the main into my branch, or make a copy of the main branch and then rebase? I have trouble grasping how that would work.

            • JackbyDev@programming.dev
              link
              fedilink
              English
              arrow-up
              1
              ·
              7 months ago

              You’re still rebasing your branch onto main (or whatever you originally branched it off of), but you aren’t then doing a fast forward merge of main to your branch.

              The terminology gets weird. When people say “merge versus rebase” they really mean it in the context of brining changes into main. You (or the remote repository) cannot do this without a merge. People usually mean “merge commit versus rebase with fast forward merge”

              • jaemo@sh.itjust.works
                link
                fedilink
                arrow-up
                0
                ·
                7 months ago

                https://gitmoji.dev/

                Quasi parallel reply to your other post, this would kind of echo the want for a capital letter at the start of the commit message. Icon indicates overall topic nature of commits.

                Lets say I am adding a database migration and my commit is the migration file and the schema. My commit message might be:

                     🗃️ Add notes to Users table
                

                So anyone looking at the eventual pr will see the icon and know that this bunch of work will affect db without all that tedious “reading the code” part of the review, or for team members who didn’t participate in reviews.

                I was initially hesitant to adopt it but I have very reasonable, younger team mates for whom emojis are part of the standard vocabulary. I gradually came to appreciate and value the ability to convey more context in my commits this way. I’m still guilty of the occasionally overusing:

                   ♻️ Fix the thing
                

                type messages when I’m lazy; doesn’t fix that bad habit, but I’m generally much happier reading mine or someone else’s PR commit summary with this extra bit of context added.

                • Deebster@programming.dev
                  link
                  fedilink
                  arrow-up
                  1
                  ·
                  7 months ago

                  I looked at it and there’s a lot of them!

                  I see things like adding dependencies but I would add the dependency along with the code that’s using it so I have that context. Is the Gitmoji way to break your commits up so that it matches a single category?

                  • jaemo@sh.itjust.works
                    link
                    fedilink
                    arrow-up
                    2
                    ·
                    7 months ago

                    Yes, that is another benefit, once you start getting muscle memory with the library. You start to parcel things by context a bit more. It’s upped my habit of discrete commit-by-hunks, which also serves as a nice self-review of the work.

    • letsgo@lemm.ee
      link
      fedilink
      arrow-up
      0
      arrow-down
      1
      ·
      7 months ago

      Merge gives an accurate view of the history but tends to be “cluttered” with multiple lines and merge commits. Rebase cleans that up and gives you a simple A->B->C view.

      Personally I prefer merge because when I’m tracking down a bug and narrow it down to a specific commit, I get to see what change was made in what context. With rebase commits that change is in there, but it’s out of context and cluttered up with zillions of other changes from the inherent merges and squashes that are included in that commit, making it harder to see what was changed and why. The same cluttered history is still in there but it’s included in the commits instead of existing separately outside the commits.

      I honestly can’t see the point of a rebased A->B->C history because (a) it’s inaccurate and (b) it makes debugging harder. Maybe I’m missing some major benefit? I’m willing to learn.