The Jujutsu version control system(neugierig.org) |
The Jujutsu version control system(neugierig.org) |
The killer feature that I love the most is a small one, but it's that commit messages can be made ahead of time rather than after-the-fact. So I can sit down at my desk, say
jj new -m "Work on XYZ feature"
jj new -m "Working on UVW feature"
I have thought about this recently, and it feels like jj would be a lot easier to teach to new users than git.
For one, jj lets you work on things directly without having to worry about an index, while still giving you all the advantages of one if you're advanced enough to need that.
THe commands also feel a lot easier to explain than in git. For example, you use `edit` to change what commit you're working on, `restore` to copy a file from a commit to your working directory (and abandon your changes to it), and `abandon` to drop a commit completely. Meanwhile, git has `checkout`, `restore`, `switch`, `reset` and `reset --hard`, which all do various parts of one or more of these.
The one that stood out in my mind:
`jj checkout` and `jj merge` are both deprecated; use `jj new` instead to replace both of these commands in all instances.
Rationale: jj checkout and jj merge both implement identical functionality, which is a subset of jj new. checkout creates a new working copy commit on top of a single specified revision, i.e. with one parent. merge creates a new working copy commit on top of at least two specified revisions, i.e. with two or more parents.
The only difference between these commands and jj new, which also creates a new working copy commit, is that new can create a working copy commit on top of any arbitrary number of revisions, so it can handle both the previous cases at once. The only actual difference between these three commands is the command syntax and their name. These names were chosen to be familiar to users of other version control systems, but we instead encourage all users to adopt jj new instead; it is more general and easier to remember than both of these.I'm daily driving Jujutsu, and maybe you should too - https://news.ycombinator.com/item?id=42380306 - Dec 2024 (47 comments)
Others:
Git and Jujutsu: In Miniature - https://news.ycombinator.com/item?id=42111597 - Nov 2024 (72 comments)
Jujutsu (jj), a Git compatible VCS - https://news.ycombinator.com/item?id=41895056 - Oct 2024 (110 comments)
Steve's Jujutsu Tutorial - https://news.ycombinator.com/item?id=41881204 - Oct 2024 (116 comments)
Jujutsu Strategies - https://news.ycombinator.com/item?id=41468750 - Sept 2024 (1 comment)
Jujutsu: A Next Generation Replacement for Git - https://news.ycombinator.com/item?id=40908985 - July 2024 (80 comments)
Lazyjj: TUI for Jujutsu/Jj - https://news.ycombinator.com/item?id=40859315 - July 2024 (1 comment)
A better merge workflow with Jujutsu - https://news.ycombinator.com/item?id=40842762 - July 2024 (90 comments)
GG, a GUI for Jujutsu - https://news.ycombinator.com/item?id=39713896 - March 2024 (2 comments)
jj init – getting serious about replacing Git with Jujutsu - https://news.ycombinator.com/item?id=39232456 - Feb 2024 (110 comments)
Jujutsu: A Git-compatible DVCS that is both simple and powerful - https://news.ycombinator.com/item?id=36952796 - Aug 2023 (261 comments)
Jujutsu: A Git-compatible DVCS that is both simple and powerful - https://news.ycombinator.com/item?id=36371138 - June 2023 (1 comment)
Jujutsu – A Git-compatible DVCS that is both simple and powerful - https://news.ycombinator.com/item?id=30398662 - Feb 2022 (228 comments)
Kudos for the article. I have been seeing jj here and there, but this is the first that made me want to try it.
Someone has made a VSCode plugin but it's closed source and I believe it will be paid at some point? https://www.visualjj.com/
If you are willing to use a TUI, jj-fzf (https://github.com/tim-janik/jj-fzf) has been wonderful and development is extremely active too.
I exclusively use git through the GUI, but the jj CLI improves so much over the git CLI that I'm willing to live with the CLI for now.
Still hoping that the GUIs become more polished though, and also for Inteliij IDEA integration.
Yes, regular git plugins sort-of mostly works, but it's different enough to introduce a lot of painful edges when you do.
This lets you work on things without having to worry about giving it a name. This turns out to be pretty helpful when you're experimenting — just "jj new <revision>" and start editing. If it turns out to be something you want to share, "jj bookmark create <name>" and then you can push it. (You can also push without giving it a name, in which case you'll get a git branch with a name based off of the change id.)
Change IDs stay constant with each change, so you use those as a type of branch name when switching between the features you're working on.
What you do need is a good way to visualize what work you have in flight. With Jujutsu that's as simple as typing in `jj` on the command line.
At Facebook it was common for even junior devs to have 5-6 changes in flight with nary a branch in sight, and experienced devs like myself routinely had dozens.
To the extent that Jujutsu is similar to any other systems, it is most similar to Sapling — both have a Mercurial heritage (Sapling is derived from hg, while Jujutsu is a new codebase with an hg-inspired UX). However, Jujutsu introduces a number of fantastic improvements over Sapling, such as first-class merge conflicts and automatic working copy snapshots. See my testimonial, the top one on this page:
https://jj-vcs.github.io/jj/latest/testimonials/#what-the-us...
I no longer do VCS development, but I'm a very happy full-time jj user. I've also helped onboard a number of people onto it.
(Personally, I'm just happy that after the dark era of Git's branch-first UX being dominant, the anonymous heads/commit-first UX pioneered by Mercurial is making a resurgence. The vast majority of developers prefer a commit-first UX, and it is so much easier to explain things like stacked commits if you don't have to introduce git rebase -i.)
One of my favorite things about Sapling is that all commits are automagically backed up to the cloud. The D in DVCS is not important for roughly every project ever. So I’m not sure how to feel about “every state is a commit”.
JJ is useful for those of us who understand the shittiness of Git but have to work in a world that got locked into path dependent network effects by VC money.
> When I left Google three years ago I recall they were trying to figure out what to do about either making Git scale, or adopting Mercurial, or what.
Rarely had to consult the docs for weird edge cases and generally operation felt natural and seamless. It was easy to onboard new devs of all experience levels.
I switched to git 5 years back and I still feel lost sometimes and inadvertently end up in detached head state once in a while. Git feels really "unnatural" or "unintuitive" to me in some way that Mercurial never did (I can't put my finger on why because I never gave Mercurial much thought).
if you take the time to learn it, the underlying data model for git makes sense, leading to the tools making sense, for those that put in the time investment to understand the underlying data model. This meant that there was a bunch of git expertise floating around IRC and mailing lists. Git tooling also wasn't super opinionated, letting pre-git workflows be run on git with little modification (which is also its problem, but does drive adoption). Sure, a recommended workflow has emerged, but that came later. By the time GitHub started in 2008, that was three years after its invention and use on the Linux kernel and git already had the mindshare and intertia. Without VC funding, GitLab or BitBucket or even Google Code might be the dominant platform, but it really was git's speed and fast branching, and proven scalability from managing Linux kernel development that led to git's rise as the preferred solution. (Its inability to handle monorepos like Google/Meta wasn't an issue for that time.)
Mercurial's lack of speed and inflexibility are what hurt adoption. VC money pouring in might have saved it, by somehow addressing those two issues, but unfortunately we'll never know. Mercurial's workflow is pretty central though so I doubt its community would have supported changes to the central workflow. Moving from Subversion to a DVCS (aka mercurial/hg or git) required learning a new tool and being forced to change workflow on top of that made the decision to go with git easier since a git expert could make a company-specific cheat sheet that didn't also require learning and adapting to a new way of working at the same time.
Most of the world was on SVN by the time git came around, and Git-svn was a pretty popular adapter. You could use git and its fast local branching before the company turned to git. I really can't stress the fast local branching enough as a reason for git winning. SVN server-side branches took forever to be created (even with the underlying data not actually being copied) and I remember even just running "hg" and no arguments being slow.
VC funding helped GitHub, but git still would have won out because hg didn't have a dev community to rival the Linux Kernel. Maybe Wikipedia/Wikimedia, but that's a much smaller codebase.
It ended on a bitter note when Microsoft bought them, sure. But let's not rewrite history, GitHub was not dumped on the market by deep-pocketed VCs. GitHub was self-funded from 2007 to 2012, at which point it was wildly popular and used a big cash injection to get to where it is now. By the time that happened it had the #1 position in commits per month and was about to become #1 in repos hosted also.
If I'm on a project with change AAA -> BBB, suppose my friend authors CCC and I author DDD.
So my history looks like:
AAA ----> BBB ----> DDD
(immutable) (immutable) (mutable)
AAA ----> BBB ----> CCC
(immutable) (immutable) (mutable)
AAA -> BBB -> CCC (immutable)
\
'-> DDD (mutable)
AAA -> BBB -> CCC (immutable) -> DDD (mutable)jj force pushes by default, but unlike git, the force push defaults to the "safe" variant (similar to git's --force-with-lease). So you won't accidently overwrite someone else's changes with your force push.
The fact that change ID is stable is very convenient for humans - means you have something explicit to hold on to as everything else may change over time.
While working on a stack of changes, you should be able to check out an earlier commit, amend it, and have its descendants be automatically rebased. Of course you should be able to -- this is a natural and straightforward way to think about working on changes, and builds on prior knowledge about how to work with individual commits and how to rebase them onto a newer upstream. Now compare this to git rebase -i.
This was definitely a really big complaint. Python's just slow to start up, and last I checked Python 3 makes things even worse here.
Startup time really made me believe that the optimal language to write CLI tools is Rust.
[0] https://en.wikipedia.org/wiki/Distributed_version_control#Hi...
Then when you have the changes lined up you --amend that same commit.
You then add your changes and "git commit --amend".
(These could be aliases. Mine are "ci" and "ca" respectively.)
The automatic snapshots provide a great degree of UX coherence — definitely more than Sapling currently does. (When I last chatted with the Sapling folks, they were quite interested in porting some Jujutsu features over to it.)
> The automatic snapshots provide a great degree of UX coherence — definitely more than Sapling currently does.
Don’t think I understand what this means.
You know how sl amend and sl fold/squash are two different commands, right? Well, jj amend is actually an alias for jj squash. And that's just the beginning.
Regarding uploading, yeah, you'll likely have to have some heuristics, but Mononoke is generally built for very high throughput. The heuristics might just be around local debouncing and aggressive expiry of uncommitted snapshots in the cloud. But in general, it's worth thinking about the local moment-to-moment UX independently of commit cloud considerations.