For what it’s worth, I’m trying the following, which is a take on Option 3:
Consider a married couple each with their own business and a drama club they run together.
Person A Person B
=============================================
10-19 Life Admin === 10-19 Life Admin
20-29 Biz Admin =/= 20-29 Biz Admin
30-39 Biz Product =/= 30-39 Biz Product
40-49 Personal =/= 40-49 Personal
50-59 Drama Club === 40-49 Drama Club
10-19 is shared (i.e. synced and identical for both people).
The next three are numbered identically in each person’s system, but are not shared. Finally, 50-59 is shared/synced.
The principle: the shape of the system is agreed on/shared by all members, but what each section actually contains is specific to each person. However, the members can’t just make new areas for themselves. Only certain agreed-upon sections may be ‘overshadowed’ by a local replacement. It’s reminiscent of object-oriented inheritance in programming terminology. Or the Unicode Private Use Area, if I my use an even geekier example.
This has a slight advantage over making an area for each member, since only one area is used up for each member, instead of, say six areas for a family of six.
To the original question: If there were children, they could have a 40-49 Personal to arrange as they see fit. What is more, this family could agree to split the admin into two areas, one that was unambiguously shared (household admin) and one that was person-bound and not shared. That has the disadvantage of straying farther and farther from standard JD layout.
I echo @aviskase’s sentiment that in a household, the most practical is to have it all be based on trust and delegation and not overengineer it. Hence no need to split things up too much. At the same time, @Jayde20’s case illustrates when that might not be sufficient.
Taking my example above, we could go more fine-grained within 10-19 to control what gets synced to each person. I’m using Syncthing so I can use ignore files to control patterns of filenames which get synced to each device. As per Johnny’s description of the problem:
This actually takes us pretty far I think. Assuming privacy/security is not an issue (i.e. this doesn’t work for @Jayde20 ):
- Alex, on his device, adds an ignore rule for the 10-19 IDs which only relate to Charlie (or for a +CH suffix or something). And vice versa. Now they don’t get each other’s stuff. Maybe there’s a shared NAS or server with a full copy so they can still access each other’s files occasionaly for admin purposes.
- big datasets are in separate areas, which are not synced between Alex and Charlie at all (or maybe they are synced encrypted, as a backup).
- when Charlie goes to uni, they don’t have to do anything: everything related to them is already synced!
However, now there’s a security issue: Alex’s personal data are now on a laptop in another city, lying around on library desks or connecting to insecure wifi networks in cafes. At this point, it might be better for Charlie to break the sync connection for 10-19, and delete everything not relevant to their new indepentent life.
And, finally, while this is possible with Syncthing ignore patterns, it gets ugly with more complicated patterns. Imagine trying to not share most of Alice’s ‘stuff’, but she does want to share the paperwork for her car, since Mum and Dad take care of the maintenance … it’s probably possible with careful ordering of ignore/include rules, but not something for your average user.