Awesome-Jj: Jujutsu Things

How easier than `git rebase -i`? Running this command, opens your editor of choice with this text & an extensive help commented out at the bottom:

    pick 5340360 # First commit.
    pick 12ccd8a # Second commit.
    pick a2b6a59 # Fourth commit.
    pick 2a648f2 # Commit #4.
    pick 6bb5d98 # Commit #5.
    pick af1f2fe # Commit #6.
    pick 7e99e85 # Commit #7.
    pick 7567b18 # Commit #8.
    pick c23819d # Commit #9.
    pick 50941da # Commit #10.

You edit it to (due to help don't really have to remember a single command):

    pick 5340360 # First commit.
    pick a2b6a59 # Fourth commit.
    pick 2a648f2 # Commit #4.
    reword 12ccd8a # Second commit.
    edit 6bb5d98 # Commit #5.
    squash 7e99e85 # Commit #7.
    pick af1f2fe # Commit #6.
    squash 7567b18 # Commit #8.
    drop c23819d # Commit #9.
    pick 50941da # Commit #10.

And then after letting you reword 12ccd8a, edit 6bb5d98, write new messages for (post-edit) 6bb5d98&7e99e85, and af1f2fe&7567b18, you get:

    pick 5340360 # First commit.
    pick 2448f03 # Fourth commit.
    pick 9cefee3 # Commit #4.
    pick 1259a52 # Second "Hi" commit.
    pick 2ca48d8 # Commit #5.Commit #7.
    pick 4bf7bcd # Commit #6.Commit #8.
    pick dbbb733 # Commit #10.

And if you messed up anything, you can always undo it by using your `git reflog`. No matter what you did, you can always go back a previous state! Each state is stored as new commit.

    dbbb733 (HEAD -> master) HEAD@{18}: rebase (finish): returning to refs/heads/master
    dbbb733 (HEAD -> master) HEAD@{19}: rebase (pick): Commit #10.
    4bf7bcd HEAD@{20}: rebase (squash): Commit #6.Commit #8.
    cdc47c1 HEAD@{21}: rebase (pick): Commit #6.
    2ca48d8 HEAD@{22}: rebase (squash): Commit #5.Commit #7.
    6a6fccc HEAD@{23}: commit (amend): Commit #5.
    86ca5f8 HEAD@{24}: rebase (edit): Commit #5.
    1259a52 HEAD@{25}: rebase (reword): Second "Hi" commit.
    b33f89c HEAD@{26}: rebase (reword): Second commit.
    9cefee3 HEAD@{27}: rebase (pick): Commit #4.
    2448f03 HEAD@{28}: rebase (pick): Fourth commit.
    5340360 HEAD@{29}: rebase: fast-forward
    d1406ed HEAD@{30}: rebase (start): checkout d1406ed8145dc84695eb622bc6b3fc078e8098df
    50941da HEAD@{31}: commit: Commit #10.
    c23819d HEAD@{32}: commit: Commit #9.
    7567b18 HEAD@{33}: commit: Commit #8.
    7e99e85 HEAD@{34}: commit: Commit #7.
    af1f2fe HEAD@{35}: commit: Commit #6.
    6bb5d98 HEAD@{36}: commit: Commit #5.
    2a648f2 HEAD@{37}: commit: Commit #4.
    a2b6a59 HEAD@{38}: commit: Fourth commit.
    12ccd8a HEAD@{39}: commit: Second commit.
    5340360 HEAD@{40}: commit (initial): First commit.

Feel like git has a reputation for being hard even for things they're not that much.

I'd been concerned about that initially, but setting up some gitgnores made this a complete non problem for me. .scratch/ for a lot, *.scratch, and ig-*.

It's also so easy to go back to the change latter and remove the files (after they're already copied elsewhere, or just operations log to go get) that it's really not a problem to just let stuff get in your commits.

In git there's such a strong incentive to do things right, to make clean commits. Imo one of the huge strengths of JJ is abandoning the obsession, and having far far far better tools to clean up after.

Some techniques for this are covered in: https://docs.jj-vcs.dev/latest/FAQ/#how-can-i-keep-my-scratc... and https://docs.jj-vcs.dev/latest/FAQ/#how-can-i-avoid-committi...

    git checkout combined-commit
    git reset --soft previous-version
    git commit -C @

  git reset HEAD^
  git add -p
  git commit -C HEAD@{1}

  git commit -m tmp
  git rebase -i HEAD^^ # Use the "edit" action for the first commit
  git add -p
  git commit -m first
  git rebase --continue
  git reset HEAD^

    git commit -m tmp
    git checkout @~
    git reset --soft previous-version # which you get from the reflog
    git commit -C @
    git rebase @~ branch-you-were-on --onto=@  # not of much use, when you only have a single commit you are throwing away in the next step, but when you are editing something earlier, this is likely what you want.
    git reset @~

    git commit -m tmp
    git rebase @~2 # break after first commit
    git reset --soft previous-version
    git commit -C @
    git rebase --continue
    git reset @~

    git rebase -i @~ --autostash # break after first commit
    git reset --soft previous-version
    git commit -C @
    git rebase --continue

    git rebase -i @~ --autostash
    # add as the first line:
    pick previous-version
    git rebase --continue

https://jj-for-everyone.github.io is the most approachable jj tutorial I've seen. I wouldn't say it focuses on workflows, but it does take a "learn by doing" approach a bit more than the "data model first" approach it sounds like you might prefer.

It's still a young tool, it's not surprising that tutorials are a bit lacking (honestly there are surprisingly many for its age). Maybe be the change you want to see in the world and make one? (Which would be an... interesting... way to learn the tool for sure).

Same. It's how I learned Docker and Kubernetes, study the concepts, then I can ask "what's the specific command to do A,B,C" instead of an open ended "how do I do X".

Have you tried it yet? I found the tutorials a bit convoluted. But just giving it a go for a couple of days gave me more in practice than reading docs for a week could. It's not to say the docs couldn't be better - just maybe it's not as much of a barrier as you think.

Jjui is incredible. I keep shouting it from every rooftop that I find. So good, in fact, that I'd argue it should be made an official TUI