Show HN: A visual guide to learning Jujutsu (JJ)(excalidraw.com)
excalidraw.com
Show HN: A visual guide to learning Jujutsu (JJ)
https://excalidraw.com/#json=kMtNOJfH_UUOzBqt7WXx9,cyuXonQjb-Kor72f0F5YXg
Draft version of first two chapters, looking for feedback!
13 comments
The presentation software itself (Excalidraw) makes this nearly unusable for me:
When it opened up the entire left-half of my screen is blank, and the diagrams are obviously cut off on the right. There is no apparent way to scroll horizontally (excepting a mouse with a horizontal scroll mechanism of some sort): There is no horizontal scroll bar and neither the arrow-keys nor click-and-drag serve to scroll horizontally. Zooming out made things a bit clear what was going on, (margin notes shifted the content far to the right).
Firefox, 1920x1200 screen.
When it opened up the entire left-half of my screen is blank, and the diagrams are obviously cut off on the right. There is no apparent way to scroll horizontally (excepting a mouse with a horizontal scroll mechanism of some sort): There is no horizontal scroll bar and neither the arrow-keys nor click-and-drag serve to scroll horizontally. Zooming out made things a bit clear what was going on, (margin notes shifted the content far to the right).
Firefox, 1920x1200 screen.
middle button click&drag or left+right click&drag :)
Maybe I'm out of the loop here, but scanning over this I can't help but ask myself: "Why Jujutsu?"
I don't understand what the point is over just using git. The top intro defined some JJ names for git things, but it's not clear why I would want or need this. What problem does it solve with using git?
I don't understand what the point is over just using git. The top intro defined some JJ names for git things, but it's not clear why I would want or need this. What problem does it solve with using git?
Ideally, reduces cognitive complexity because you don't have to think about the staging area anymore, just commits.
I recently started trying it out at work and I like how fluent it makes what would be more advanced git operations like squashing and rebasing.
Issues I've run into have been understanding its version of branches (bookmarks), understanding its merge conflict indicators, and its lack of respect for git skip-worktree.
I recently started trying it out at work and I like how fluent it makes what would be more advanced git operations like squashing and rebasing.
Issues I've run into have been understanding its version of branches (bookmarks), understanding its merge conflict indicators, and its lack of respect for git skip-worktree.
> Ideally, reduces cognitive complexity because you don't have to think about the staging area anymore, just commits.
My git use is mostly a direct translation of mercurial (which I learned first), and the staging area is really optional. The only time I ever type `git add` is when adding a new file; otherwise I just
I guess jj is different still (by way of ~autocommitting), but my point stands.
My git use is mostly a direct translation of mercurial (which I learned first), and the staging area is really optional. The only time I ever type `git add` is when adding a new file; otherwise I just
vi foo.txt
git commit foo.txt
I guess jj is different still (by way of ~autocommitting), but my point stands.
> Ideally, reduces cognitive complexity because you don't have to think about the staging area anymore, just commits.
This is the thing I don't like about jj. I know it makes splitting easy, but splitting is harder than selectively adding after blindly merging all changes.
This is the thing I don't like about jj. I know it makes splitting easy, but splitting is harder than selectively adding after blindly merging all changes.
> but splitting is harder than selectively adding after blindly merging all changes.
Is the scenario that you make many changes in the working copy and then run `git add -p` a few times until you're happy with what's staged and then you `git commit`? With jj, you would run `jj split` instead of the first `git add -p` and then `jj squash -i` instead of the subsequent ones. There's no need to do anything instead of `git commit`, assuming you gave the first commit a good description when you ran `jj split`. This scenario seems similarly complex with Git and jj. Did you have a different scenario in mind or do you disagree that the complexity is similar between the tools in this scenario? Maybe I'm missing some part of it, like unstaging some of the changes?
Is the scenario that you make many changes in the working copy and then run `git add -p` a few times until you're happy with what's staged and then you `git commit`? With jj, you would run `jj split` instead of the first `git add -p` and then `jj squash -i` instead of the subsequent ones. There's no need to do anything instead of `git commit`, assuming you gave the first commit a good description when you ran `jj split`. This scenario seems similarly complex with Git and jj. Did you have a different scenario in mind or do you disagree that the complexity is similar between the tools in this scenario? Maybe I'm missing some part of it, like unstaging some of the changes?
> This scenario seems similarly complex with Git and jj.
It is in number of commands ran, but there's a few annoyances around changes getting into the repo automatically.
There's a lot of git commits coming from jj's constant snapshots. Maybe this is a good thing overall, but it brings some silly issues,
What to do when data that shouldn't leave the dev machine gets to the repo? I'm thinking secrets, large files, generated files. - Leaking secrets by mistake seems easier. - Getting large files/directories into the git snapshots might degrade git's performance.
It seems that you need to be diligent with your ignores or get forced to learn more advanced commands right away. I guess there's a more advanced history scrub command around though.
It is in number of commands ran, but there's a few annoyances around changes getting into the repo automatically.
There's a lot of git commits coming from jj's constant snapshots. Maybe this is a good thing overall, but it brings some silly issues,
What to do when data that shouldn't leave the dev machine gets to the repo? I'm thinking secrets, large files, generated files. - Leaking secrets by mistake seems easier. - Getting large files/directories into the git snapshots might degrade git's performance.
It seems that you need to be diligent with your ignores or get forced to learn more advanced commands right away. I guess there's a more advanced history scrub command around though.
[deleted]
I remember complaining about this to Martin early on and he mentioned he found not having a staging area simpler, and I see why whenever I try to switch commits from a dirty workspace that has conflicts with other branches.
Maybe if in git the "trash" that makes a commit dirty was commit-local, then you'd get to move around freely while still having a staging area to cherry pick your changes. Sounds trickier than just not having a staging area (and may be flawed), but gives back the control you have in git over what gets into the repo.
Maybe if in git the "trash" that makes a commit dirty was commit-local, then you'd get to move around freely while still having a staging area to cherry pick your changes. Sounds trickier than just not having a staging area (and may be flawed), but gives back the control you have in git over what gets into the repo.
conceptually simpler, + easier to revert things.
in my case, i abandoned advanced git-ing because it's too much pain for little gain and i typically forgot everything by the time i'd actually need it. nowadays i only use the basics commands with the occasional cp -r.
with jj i get the gain with little pain.
in my case, i abandoned advanced git-ing because it's too much pain for little gain and i typically forgot everything by the time i'd actually need it. nowadays i only use the basics commands with the occasional cp -r.
with jj i get the gain with little pain.