That came out wrong, sorry. I only meant inquire specifically about your familiarity with version control software and the rest of your reply gives me a reasonably good idea.
First off I should clarify both my understanding of a few terms as they relate to VCS and in particular DVCS.
- version: the contents of a file or folder structure at any given moment
- snapshot: a record that enables to completely reproduce a specific version
- patch: a full description of the differences between any two versions
- VCS: a program that can store and reproduce specific versions
- DVCS: a VCS that allows multiple people to independently store versions
The ability to record and restore versions is the very core functionality of a VCS. Every VCS has some notion of snapshots regardless of how it processes versions internally.
Most of the time you should not have to worry about the precise ways in which a VCS reproduces a version, especially if you are the only one making changes. What you care about is recording changes, reviewing other versions (snapshots) and comparing versions (patches). The rest is outright counter intuitive and you should not feel bad being confused.
The difficult bit is dealing with independent changes in the same exact place in a file. It is so difficult that for the longest time the solution was to prevent the recording of any independent changes. For individuals this didn’t cause any problems to speak of, small teams working together closely could coordinate to work around the problem. Large groups of people working on the same project with little to no contact for long periods were not much worse off just making copies by hand because as you noted, snapshots are easier.
The Git/Mercurial/Bazaar wave of DVCS is essentially just automating the process of periodically taking snapshot after snapshot from each developer, comparing each of those snapshots to what you have one by one and combining them when and if need to. Depending on what you are working on you may incorporate recent changes before much folders ones, which is why ordering changes by time doesn’t really work with DVCS.
Large teams have to compare different versions all the time and apply changes from one snapshot to another, which is the extent of the “patch oriented” nature of those systems. The main difference between Bazaar and Git is that it doesn’t expose any of the complexity when you are working on your own and even makes it relatively easy to work on multiple different things in parallel on your own, although you still have to eventually apply each branch one at a time when you want to make it all work together.
The problem that Pijul tries to address is dealing with each separate snapshot as a separate version. Being able to combine patches in any order means you are no longer applying them one at a time. Furthermore, it means that it does not matter how anyone else did it as long as you get the same result. Does it help when working on your own?
That depends. When your changes can go in any order you can work on different areas in any order without having to figure out the right branch for each area before you have even started.