If only life was that simple that it could be enclosed into series of two digits categories.

The problem with such strongly hierarchical system is that it fails if there is some document, note, picture, etc. that would be useful to keep in multiple locations. Obviously we can introduce links between objects, but I believe tags are more comfortable to use.

Hierarchical system, folders are artifacts of the physical world in which a single object, tool, pipe, screw, book cannot be in two places at the same time. In the abstract world of computers a note about new game could be in #games, #fun, #to-check, #interesting-ideas, #great-graphics, etc.

Paraphrasing Greenspun's tenth rule [1]

Any sufficiently complicated library management system contains an ad-hoc, informally-specified, bug-ridden, inconsistent implementation of half of the Dewey System [2].

[1] https://en.wikipedia.org/wiki/Greenspun%27s_tenth_rule

[2] https://en.wikipedia.org/wiki/Dewey_Decimal_Classification

As this thread currently has a lot of critics, I just want to put in a personal plug for JD. I've been using it for some time now for family and personal data and it has been enormously helpful. It's true that it is occasionally vexing to have to choose one category for a given thing, but (a) it's usually not, (b) it's ok to reorganize categories, (c) I have found that often if there's something important that fits equally well in more than one category, (c1) either I need to refactor my categories, or (c2) it's probably going to be ok if I just pick one and allow myself to recategorize later. This almost never happens anyway.

And in the mean time, all my stuff is searchable, browsable, findable, and tidy.

I'm not saying it will work equally well in all environments or for all purposes, but for mine, it solved many years' worth of stress.

This is effectively how formal military instructions are structured - and generally US code for that matter, with chapters generally reserved for certain functions going down to the .01 decimal specificity [1]

Way back in 2010 or so I published a series of instructions for the 36th Wing that followed this kind of naming/information numbering convention which was frustrating to fit into, but ultimately once you understand the framework it's faster to write.

That isn't to say it isn't confusing and complicated - which happens to everything at scale - simply that this kind of structure for documentation is pretty common and literally battle tested.

[1]https://www.esd.whs.mil/Portals/54/Documents/DD/iss_process/...

I incorporated some of these ideas like 10-15 years ago.

My top level relations:

* Fun: Sex, drugs, rock & roll

* Home: Rent, buy, interior, yard, cars, places

* Meta: This system

* Mind: Philsophy, language, math, art, music, science

* Money: Accounts, investments, Bitcoin

* People: Family, friends, everyone

* Self: Fitness, health & illness, spirit, food, fashion

* Tools: Computing, devices, productivity, maker, crafts

* Work: Career, job

Roget's original thesaurus, which divides every word into 6 (or something) top-level relations was also an inspiration.

These are my root items in Workflowy (with its infinitely nested bullets).

I star active projects so they show up in the sidebar. I shift-drag (to mirror) items out of projects into the root (above the relations) to serve as my daily todo list. All in all, simple, efficient, and comprehensive.

If anyone has implemented this successfully/satisfactorily please post your folder hierarchy so everyone can compare notes and improve their organization.

I've been chipping away at moving to my own flavor of JD over the last year. One of the first things I did was add one higher level with broad categories, numbered as x00. Tis way things are broadly organized, I still don't have to 'fundamentally' go more than two folders deep or 'have more than 100 folders', but I can use it for my entire work life despite having 100-ish actual technical projects.

Backporting old docs to this system is a real chore and honestly, I haven't been very disciplined about that part, besides moving old Project folders under the top-level Projects folder. But this is always going to be an issue with any new filing system, and I don't think there's a lot of value in doing it. Maybe would be an interesting programmatic exercise. But I, hotsauceror at his keyboard, am NOT going to go and retroactively assign a 753.0026 etc identifier to every document lol...

My rough, rough hierarchy is as follows:

  100 - Administrative
    - 110 Interview Notes
    - 110.001-eng-john-smith.md
    - 120 Onboarding
    - 130 Performance
    - 140 Training + Certification
    - 150 Travel + Expense

  200 - Analysis
    - 210 Code Review
    - 220 Performance Tuning
    - 230 Technical Specs

  300 - Documentation
    - 310 HOWTOs and Runbooks
    - 320 Technical Specifications
    - 330 Environment
    - 340 Processes

  400 - Meetings (this is a catchall)
    - YYYY-MM-DD-annual-project-plan.md
    - YYYY-MM-DD-budget.md
    - YYYY-MM-DD-new-policy-rollout.md

  500 - Operations
    - 510 Stack #1
      - 510.001-turn-it-off-and-back-on-again.md
    - 520 Stack #2
      - 520.001-reset-proxysql-after-network-partition.md
    - 530 ...

  600 - Troubleshooting (another outlier)
    - yyyy-mm-dd-stack-2345-bad-plan
    - yyyy-mm-dd-stack-1234-cpu-peg
    - yyyy-mm-dd-stack-3456-non-yielding-scheduler

  700 - Projects
    - 701 Project 01
    - 702 Project 02
    - 703 Project 03...

  800 - Reports

  900 - Training
    - 901 Brown Bags / Lunch+Learn
    - 902 Terraform Certification
    - 903 AWS Certification

It seems like nothing of use is gained by replacing folder names with numbers that index those names aside from making the path shorter. In a library this is useful because books have to be stored physically in order, but a computer does not have these restrictions. You could just as easily apply the same set of rules without the numbers and see similar results, with the advantage that the names of things reflect what they are. You also wouldn't have to create silly rules like "1- is always project management", because under the new system, "project management" will always be project management.

He does seem to address this at least somewhat[0], but the justification is so flimsy it's hardly worth addressing. In essence, he doesn't like alphabetical ordering because the index can change when something new is added. He would prefer new folders to be inserted at the end of the list. He is evidently unaware that folders can be sorted by creation date.

[0] https://johnnydecimal.com/10-19-concepts/11-core/11.02-areas...

Couple caveats that I think should be included:

Use this for your own files where no one else has to find anything.

Avoid reorganizing other people's files.

If you do the organizing, it may make sense to you, but may not for other people.

Adding the decimals has the primary benefit of nothing being recognizable from before, so that new brain maps can be made, not horribly and painfully mangled, warped and twisted from the old maps.

If you have to navigate one of these systems and you didn't create it, use search and hope files are named well, and hope the creator didn't go overboard with making foldets. Otherwise, welcome to a little hell of clicking into a million empty folders and never being able to find anything.

Has anyone mentioned Aristotle yet? His abstraction of categorizability works, but is so obviously wrong once you have to accomplish any practical task.

For us, organic folder structure development for as long as possible, or avoiding folders as much as possible is better. Then, some intelligent and pragmatic decision making, and no hard and fast rules. We are human friendly first, where file systems are primarily intended for human navigation.

This pops up on HN regularly. Was extensively discussed at https://news.ycombinator.com/item?id=25398027

Interestingly, we have a similar "BASIC line numbering" system in our company. Allows for easy traversing the directories if you can remember the numbers (I cannot), such as "05_Contracts/15_Employees/041_John_Doe/07_Testemonies".

I have been using JD for a while now, to the point that I built a CLI for it (using Deno).

But I just enjoy the speed of feeling like I can cd to any directory at any time in like... 8 keypresses (`jd 20.21` is an alias I use to cd).

https://github.com/bpevs/johnny_decimal

https://johnny.bpev.me/

Edit: I had a separate hierarchy I used on my work machine when I was still working at a larger company, but this is the one from my personal machine (with some redacted)...

  10-19 Notes
    10 Quick [Daily-life kind of stuff]
      10.01 Daily Notes
      10.02 Cooking
      10.03 Listening Notes
      ...
    11 Research
      11.00 Device Setup
      11.01 Project Name 1
      11.02 Project Name 2
    12 Reference [Basically categorizing random notes]
      12.00 Unsorted
      12.05 History and Current Events
      ...
      12.28 Spatial Audio
      12.29 Music, Cognition, and Computerized Sound
    13 Travel
      13.01 中文
      ...
      13.10 Maps
    18 bpev.me
    19 Documents
      [Various documents here]
  20-29 Projects [Active Projects]
    20 Code
      20.00 gists
      20.01 bpev.me
      [insert projects I am committing to often]
    21 Media
      21.01 Music
        [insert Music album work here]
  30-39 Archives
    30 Code
      30.03 favioli
      30.04 johnny_decimal
      .....
      basically, maintanence-mode projects.
      If I start committing on a more regular cadence, I move to `20 Code`
    31 Media
      I have a separate, date-based hierarchy within these...
      31.01 Music
      31.02 Photos
      31.03 Videos
      31.04 Memes
      31.05 Screenshots
    39 Backups
      39.01 Contacts
      39.03 bpev.me
      39.04 Savefiles
      39.05 Applications

> Nothing is more than two clicks away

> An important restriction of the system is that you’re not allowed to create any folders inside a Johnny.Decimal folder.

This being said immediately after a screenshot with three levels of directories confuses me. One problem I immediately identified with this system is that I would have to take extra steps to peek into the applicable directory to see what the current index is...

I'm always looking for a good organizational methodology. This seems to be per project, no? Any suggestions for a system for overall data organization?

Gosh, that's a really awful explanation. Not sure I get this correctly, but the gist is, you organize things by nesting general Categories with specialized categories and put a number on them. With the "lifehack" that the first digit is the general category, and the second digit is the specialized category? And then every folder under a specialized category gets another number? And this is only meant per Project? Not globally? Meaning every project can have slightly different categories & numbers? Have I understood this correctly?

How does this handle inter-project-files? What exactly is a project even in this context? How does it handle things which can be in multiple categories? This smells for like someone pressing everything into a hard form to circumvent the flaws of their tools, instead of getting better tooling.

I don't plan to use this, but I think I get why it might work.

(1) Although it's just a hierarchy/tree, which is nothing new, its size and shape is (supposed to be) a sweet spot. There are trade-offs with hierarchy sizes and shapes, so a sweet spot is a plausible idea.

(2) By limiting the size of the tree, you force people all across the organization to share the same parts of it rather than giving them private spaces they control exclusively. This means they are forced to work together on how information is organized. This could encourage there being one coherent idea of how information is organized. Everyone will have to agree on how it's organized, and everyone will be more familiar with how others' stuff is organized.

(3) The numbers are small enough that you can remember them and talk about them. When you ask someone where something is, they can give you the answer directly instead of promising to send you a link. (It's like how you can read an IPv4 address off one screen and go type it into a config file on another computer, whereas unfortunately this is not easy with IPv6.) This increases the odds of success in finding the info.

I wrote an article about this system a while ago: https://www.dsebastien.net/2022-04-29-johnny-decimal/

I rely on it a lot for my personal data and projects. The simplicity and constraints have a positive impact on the usability of the organized information

I think JD main value resides in the restrictions it suggests. They will work for some people, for others they will not, and others like me will adopt JD in an informal way. For example my most used folders, loosely corresponding to main areas of focus have unique numeric prefixes, but inside them the folders do not follow the numeric prefix approach. What I appreciate is having the same numeric prefix in all the applications I happen to use, like GMail labels, task manager projects, Evernote notebooks, and file systems.

It's always boggled my mind how disorganized most companies are with written information. It's always a wiki here, 7 different file shares over there, most of the latest data is on workers' desktops named "mgmt report 04032023 latest jb edits 2.0.doc". Constant stream of "can you send me the thingamajig file?"

And yet, we've all been to a library. Information organized by topic, then by author, and inside the books everything is further organized into chapters, and then there's an index referencing all of that (plus a card catalog/search system).

I use something similar to the Johnny Decimal system described at work, except the high level is by project not by topic. I find chronological filing split into projects (i.e. chunks of time/money/effort) matches my workday better.

Every time I think about implementing this I realize the categories I have today and the categories I have five years from now are unlikely to mesh well.

At least based on my priorities from five years ago.

This seems like one particular example of a good general set of principles: organize things intentionally, put things in one place, use hierarchies with a branching factor of about ten. The specifics beyond that are probably not worth arguing about.

I'm messy, I like being messy.

I cannot follow any of those organizational, rigidly structured methods. They make me anxious, I much rather live in my mess and let it automatically prioritize stuff for me.

Things I don't know where I left are likely unimportant, and no energy should be wasted on them.

I think I finally made peace with my mess.

When I first saw this, I thought it looked silly and too simple to be useful.

The other day I looked at my DEVONthink database I’ve populated over the last 15 years or so, and what do ya know. It has a couple dozen top-level folders, each with a handful of folders inside, and that’s about it. I didn’t deliberately set out to do this, but “Banking/{Bank1|Bank2|Bank3}”, “Medical/{Me,wife,kid}”, “Taxes/{2020,2021,2022}”, and so on evolved that way anyway.

I love the idea of tagging, but turns out nearly all the information I care to store long-term can be filed more easily than it can be tagged. It’s rare that I want to have the same doc in 2 places, mainly limited to when I’m collecting information to send to someone else (e.g. filing taxes, applying for a business loan). When that happens, I just - shocker! - make copies of those docs in a new folder I’ve created to collect everything I need. DEVONthink makes the copy a zero-sized reference to the original doc and gives each copy a special icon so you know it’s a duplicate.

So basically, Johnny Decimal couldn’t possibly work for me, and yet I ended up with a sad version of the exact same thing on my own naturally. Well, huh. Maybe it’s not so silly after all.

(Also, regarding tagging: the idea of a database with a few tens of thousands of files in the same namespace, searchable by tagging, gives me hives. I know people do this all the time, and it’s a “me problem” that it bothers me, but oh, how it bothers me.)

I'm going to try this with my Firefox bookmarks. They're already a bloody mess, and I need to get rid of 404ing ones anyway. Except that it'll be Johnny Octal. (reason: https://en.wikipedia.org/wiki/The_Magical_Number_Seven,_Plus... )

This whole discussion of hierarchy vs. tags feels like discussing if hammers are better or worse than screwdrivers, with each people assuming nails or screws out of nowhere. Some things for example organise themselves naturally into hierarchies, such as biological species (both the "old" taxonomy and cladistics are tree-based models.); odds are that the same applies to tags, with some junk out there being specially well suited for tagging.

There's also the possibility that different people do work better with one or another.

It would be specially useful to identify corner cases where each fails to deliver. Both systems are bound to have flaws; the "right" one is not the perfect one, but the one with the flaws that are easier to address and/or tolerate.

A few people mentioned items that could be assigned to multiple nodes as a shortcoming of the hierarchical system, but isn't this rather easy to solve with a disambiguation rule? e.g. for Johnny Decimal, "if an item can be reasonably assigned to two numbers, pick the smaller one." I also don't see much of a problem with synonyms, or in this case links.

I was working on something like this but for physical objects.

Fine grained categories take up a lot of space and involve a lot of containers,which then creates more objects to manage. They also take Moore effort to put things away, for only small gains in retrieval speed unless your memory is good enough to find the category box right away.

My theory is an organization system should be optimized for storage rather than retrieval as that is what takes time and effort.

But I have a lot of trouble with numbers or abstract symbols and don't want to spend forever learning them, so I use three letters abbreviations.

All the categories are based on observation of what is already close together, rather than by trying to create a system logically, to take advantage of things I've seen in one place long enough to remember, and not have to relearn the location.

So, I have a category BAM, for bulk artificial materials. This exists because there was a bunch of paint, some cleaning supplies, and paper towels stored together.

There's also TAM, tapes, attachments, and materials. This has some screws, some ratchet straps, and some balsa wood and steel wire, some foam tape, and some keyring split rings, and a bunch of other stuff.

If things overflow a container, I split them into subcategories.

I was inspired by Johnny Decimal and developed my own system for organizing my personal/family files. I don't have the same "search for it" requirement, or need to talk to other people about the organization of the files and don't use any of the numbering system they have, which may sound like it's not inspired by Johnny Decimal, but it sure is!

At the root I have a small number of ALLCAPS folders. Those each have a small number of ALLCAPS folders themselves, and nothing else. In a few cases the hierarchy goes a little deeper than that, but not much deeper.

An ALLCAPS folder can either be part of this ALLCAPS hierarchy and contain other ALLCAPS folders and nothing else, or it can be an ALLCAPS leaf: contain normal folders and nothing else.

The final rule is that nothing is allowed to depend on any relative hierarchy until you get into one of the folders inside an ALLCAPS leaf.

What this means is I can reorganize any time I want by moving or renaming any ALLCAPS folders at any time, or any of the folders inside an ALLCAPS leaf. I find this distinction relieving. I don't have to get the perfect organization forever, I just have to organize it in a way that works for me right now, and I can reorganize any part of it at any time without worrying about it.

This is one area where LLMs will help tremendously. I've always hated the Save operation, because it forces you to think about a name that describes what you're working on, even though the idea isn't fully formed yet.

I'm pretty sure Microsoft will integrate LLMs to automate file naming, and I hope other systems follow suit.

More interestingly, LLMs will easily organize data hierarchically based on the contents. I hope this becomes a reality this or next year.

I hate manually organizing a filesystem.

Johnny here.

I was mid-reply and I realised I was typing out my problem statement, so I’ll just paste it here. This is a work in progress.

---

# The problem

When we kept everything on paper, organised people had these things called filing cabinets. They stored all of their documents in them in a structured way so that they could find them again.

Now those same people store all of their files in arbitrarily named folders on their company’s shared drive and wonder why they can’t find anything.

## Information wasn’t always free

When we kept everything on paper, generating information came with a cost. Paper cost money. Typing out a document took real effort. Duplicating a document meant a trip to the photocopier.

Every document produced was a tangible thing. It was there, on your desk. You couldn’t ignore it.

Now anyone can duplicate anything, instantly, invisibly, for free. We assume this is an improvement.

Is it?

## You had to be organised

When we kept everything on paper, you had to be organised. There was no other option.

If you weren’t organised, the information was lost. Not lost as in ‘it’ll take me a while to find it’: lost as in ‘gone forever’.

Now you can be disorganised, but at what cost? The cost is the time it takes you to find a thing; it is the risk that the thing that you find is a duplicate or an old version. It is the constant frustration that comes from knowing that something exists, but having no idea where it is.

We all feel this every day and we have come to believe that it is normal.

It is not normal.

## Why aren’t we given training?

When we kept everything on paper, it was someone’s job to organise it. This was an occupation: you were trained. You became an expert.

Now we employ Gen Z’s who didn’t grow up with the concept of ‘a file’ yet we expect them to navigate the byzantine hierarchy of the company’s SharePoint.[genz]

[genz]: https://www.theverge.com/22684730/students-file-folder-direc...

You work at a keyboard all day, so we make you sit through a module so you know to bend your knees when you lift a box.

But when it comes to information management: you’re on your own.

When it gets bad enough you need this for an organization, you hire a "librarian"[0], it's literally their job to classify and keep track of information. They have a whole degree program called Library and information science.

Let the experts handle this stuff. How many times have you found some super important production piece being handled in a disaster of Excel and 400 different versions all named ridiculous things, and nobody knows which is the right one to use? Why? Because they didn't bring software development in soon enough.

0: Librarian is our commonly understood word for the broad profession of information management, but the experts tend to have many different job titles for their discipline, get a subject matter expert(I'm not one) to help you track down the right job title for your specific project.

I like PARA a lot, which has some great ideas: https://fortelabs.com/blog/para/

Never used such system, but I'm inclined to believe in its promises. In addition to what I've recently commented in another HN post [1], this system also slightly resembles the classification system used in accounting. At a first glance those account numbers look cryptic and arbitrary, but soon enough you realize how helpful they are on enabling accountants to communicate and creating journal entries.

[1] https://news.ycombinator.com/item?id=36301140

Question aside. Can anyone recommend any opensource de-duplication tool(s)? I've realized that I have the same data over many drives but manually going through them even for a single drive will take a ton of time. I'm wondering if there's something smart enough where you input paths to be scanned and magically outputs de-duplicated data to a single coherent place...

Edit: Some corrections. I forgot to mention which OS: GNU/Linux and/or BSDs.

Ok, this made me look into why not the Dewey.

It seems too hard to memorize the numbers for first time placement.

So let's make a program that asks us when moving it into our collections?

`dewey <file to organize>`

Will then lead you down a tree of decisions. Insta-organized. It's so good I just might try it.

(The file will move to wherever your organized files are specified in your .config/dewey.conf)

On Windows this could be a right-click -> Dewey, where it then pops up a small window to pick the categorization.

My grandpa was very interested in libraries. He had drawers full of index cards[1] for his personal library, organized using the Dewey decimal system[2].

When he first got a computer, back in Windows 3.11 days, it only seemed natural to use what he was familiar with. So he would store documents and emails in directories based on the Dewey decimal system.

However a problem quickly arose. A document might pertain to multiple topics. With index cards this was simple, you just noted the book or document on each of the relevant index cards.

With files however it was less clear. The only way he found was to save the same file in multiple directories. With the obvious nightmare of keeping it all in sync.

It got somewhat better when I taught him how to make shortcuts to the documents, but still...

[1]: https://en.wikipedia.org/wiki/Index_card

[2]: https://en.wikipedia.org/wiki/Dewey_Decimal_Classification

We implemented this for our shared storage at $DAYJOB. We had a long tail of decade old files on our shared drive, so we started again with the Johnny Decimal system on a new one. It's helped tremendously for us for finding stuff.

I had previously implemented it on my personal Nextcloud instance, but found it to be less impactful, as I already tended to over-organize my digital files.

Oh, now I understand where the directory structure comes from at work.

I hate it.

The problems I have with it (some of them implementation details that can probably be fixed)

- On smaller projects, you have a big directory tree of nothing, with maybe a quarter of the directories being populated. This is because it starts from a template.

- You tend to get long directory paths, enough to get over MAX_PATH in some instances, don't fit in a single line, etc...

- Remembering arbitrary numbers is hard. Try using arbitrary numbers in your code for your variables, I am sure it will be appreciated...

- And especially when there are several number based systems in place. So you have the software version number, the ticket number, the number system used by your customer, etc... Do you really want another number system on top of that?

- The article says there is no overlap. There is never "no overlap" in the real life. For example, as a dev, I should have nothing to do in the "sales" folder, except that the technical specifications are here because they are part of the contract. It really belongs in both "sales" and "dev".

- I still use search as may primary tool.

Note that someone mentioned the military. I have worked on defense contracts, they are the worst. Acronyms and codes everywhere, I guess they are too special to name things with regular words. And I am talking about the unclassified stuff, it is even worse when confidential information is involved: "The name should follow the ZB4455 convention, ZB4455 is in document L45.34c, can I have L45.34c? No it is classified, but actually, it just means it should be lowercase and start with an underscore." So I wouldn't take what the military does as a good example.

I love everything about this: the concept, even the name. I feel Johnny Decimal just needs a graphic. From a few minutes of Googling, I think something like this: https://clipart-library.com/img1/1252227.gif

Related:

Johnny.Decimal – A System to Organize Projects - https://news.ycombinator.com/item?id=36300472 - June 2023 (1 comment)

Johnny.Decimal - https://news.ycombinator.com/item?id=25398027 - Dec 2020 (187 comments)

Johnny.Decimal – A system to organise projects - https://news.ycombinator.com/item?id=13770827 - March 2017 (2 comments)

More Karl Voit: (1) "Managing Digital Files (e.g., Photographs) in Files and Folders" at https://karl-voit.at/managing-digital-photographs/

(2) "TagTrees: Improving Personal Information Management Using Associative Navigation" at https://karl-voit.at/tagstore/en/papers.shtml

(3) "TagTree: Storing and Re-finding Files Using Tags" at https://karl-voit.at/tagstore/downloads/Voit2011.pdf

As said before about in the post "BIG DATA is just data", a lot of information is worthless after 1 or 2 years and most after 5 years. Long term value data seems to be stored in IT systems' DBs rather successfully.

And I have so far always find important emails (notably because important topics are easily found emails chains and far more often than not in the dedicated meeting report).

Structuring data is cultural so you should rather learn to use the system used by your organization. Only super small teams and solo-founders need to think about how to store data. Most workers should follow their community to let other people find the information.

Folders, drawer, cabinet have been around for 3 centuries at least and imho, we are not gonna reinvent the wheel with this or that way to structure information.

Decimal organization is a good system... but it's explained here in a completely obnoxious way that makes you want to hate it.

Firstly, I strongly recommend just reading up on Dewey Decimal[0] (which is what JD cribs almost everything conceptually from), there's a decent explanation about it on Wikipedia. Should help you "get" the categories you might want to make a bit more.

Secondly, don't marry yourself to JDs limitations. The site likes to evangelicize about some things that really aren't as important as you might think. Feel free to ignore something if it doesn't work for you - in particular the "no subfolders" rule might just... not be worthwhile to follow.

Personally I've always pretty much ignored this rule - if you look at Dewey, the left hand of the number is meant to be a classification for the broad category while the number on the right is meant for the broad project. In other words, applying a decimal organization system to specific files? Yeah not what it's meant for, don't do that.

Even in a library, where Dewey is used, an individual books Dewey Classification isn't actually unique to that book. For example all books on MySQL will have the same Dewey Class.

Build it as a system that works for you, don't try to forcefully refit your system to match the explanation of this website. Also, don't use it for small projects. That'll just make it a bigger mess than it's worth. Stick a small project in a bigger folder system, it'll work way better that way.

As for mental mapping - keep a readme file to just list the broad categories in the top of the structure, it'll help a lot. The site recommends spreadsheets but really, that's wayy overkill and will just cause dumb overhead each time you have to add a file.

[0]: https://en.wikipedia.org/wiki/Dewey_Decimal_Classification

Melvil Dewey[1] started this way, but then things got bigger, and a cast of clerks were born to serve the system.

[1] https://en.wikipedia.org/wiki/Melvil_Dewey

I've used this system for a few years in the past. It's definitely handy for some people, but it didn't fit my use case. I now store all important documents/photos/backups in the cloud and consider the computer to be basically throwaway.

One organizational system many programmers may appreciate is keeping your git/GitHub repos in the same place, under `.../g/<username>/<reponame>`. Huge fan of this method.

This can work extremely well for one or two people. It becomes a problem when different people need to agree on what are the 10 things, categorization and maintenance.

I have been using JD for several years to organize both my personal documents as well as my business’ documents. I think the system works really well.

One thing I have learned to do which bends the rules a bit is to use date stamped folders in the lowest level instead of XX.YY.

Examples of places where I use this with success is for folders containing: meeting minutes, travel documents, receipts, etc.

If i did this with my e-mail i would have over 1000 in some folders.

"It’s very unlikely you will end up with a hundred categories." -the page

Exactly this will result in about 20-30 folders for most, with any real amount of documents some folders might hold 100-1000 docs.

The advise you should take from this is that forcing structure is useful. Look att large code repos for example.

I am obssessing over this when maintaining my knowledge/artifact base. Currently I am keeping it in git repository with few categories and I use 3 mechanisms - tags on end of file names and directories, iso8601 dates as prefix on some locations, and nothing on thrid ones.

So,

1. notes a-la gists use tags:

    'notes/Rsync notes #cli #foss #notes #x-platform.md'
    'notes/Windows initialization #windows #powershell.md'
    'notes/Modafinil notes #medical #nootropic.md'

    'work/meetings/2023-01-03 Project XYZ meeting #project-xyz.md'

    'dms/wallpapers/w1.png; w2.png ...'
    'dms/shopping/2023-06-13 Dyson Absolute 15/README.md; receipt.jpg'

CTRL+P to quickly find stuff by name or tags, and vscodes very fast ripgrep search to get files containing any content - so I just need to remember any word or phrase to find it. If I can't remember anything I browse over tags (having handy script to display all of them) or dates (since I usually know a time range). As another mechansism, I use double commander file manager with its fuzzy file names search to get interactive lists by typing tags or keywords while in particular folder.

To encrypt some pages I use GPG with vscode extension.

This serves me well, and I don't get lost, either when searching for previous knowledge or when trying to find where the single one is.

I evaluated Johnny Decimal prior to this, and it didn't fit this workflow - seems ad hoc enough so I can live without it and has nothing tags or good search can't solve. Also, it feels not flexible enough particularly as stuff can't have multiple categories. Tags are much better mechanism for information organization, you just need to keep them organized, keep their number relatively low, and have mechanism for delete/merge/move/rename which is simple enough here as it is all on the file system and is a few shell commands away.

Terrible advice. Abitrary rules (make 10 folders!) is just utterly bonkers for everyone except a small subset of people who could categorise their life in this way.

It really grates on me when people offer solutions that work for them, as if they will work for everyone.

No.

The system is spoiled by confusion between division into 10 and division into 100. This creates extra levels so that the implementation does not live up to its "two clicks away" promise.

For instance, in the site's own structure, we have

  11-core/11.01-introduction

  10-19-concepts/11-core/11.01-introduction

Isn't there a division into ten needed there?

If the bottom level never goes beyond 00-09, the zero is redundant. It's actually a three level system with a branching factor of 10, and you might as well just have

  10-concepts/11-core/1-introduction

  10/11/1

  concepts -> 10

  10/core -> 11

  10/11/introduction -> 1

Symlinks going from symbolic to numeric is probably the right direction. The OS symlink resolution then teaches the users what the categories are:

  $ realpath --relative-to=. concepts/core/introduction
  10/11/01

  11.1 -> 10/11/1

I stumbled on this system several years ago and found it useful as inspiration for organizing my external storage.

My top level categories are `inbox` (stuff that isn't sorted yet), `Media` (stuff that other people made), and `Vault` (stuff that I made).

`Media` contains `Audiobooks`, `Books`, `Courses`, `Films`, `TV`, `Music`, and `Broadway.

`Vault` contains `Backups`, `Projects`, `Audio`, Video`, and `Photos`.

Anything one layer deeper is either a file of the type described by the parent folder name or a folder containing related files (ex: `Video/2023-06-12 makers.dev 119` is a folder containing the raw recordings and processed end video and audio for my podcast).

I've got about 10TB and tens of millions of files organized in this system. It works better than anything else I've tried.

> and the cues that Google uses to determine what’s useful — the links that are the fabric of the internet — just don’t exist at work.

Says someone who’s never worked at Google and used Moma. I still don’t understand why Google doesn’t offer Moma as a on-prem thing to replace JIRA’s suite. Is the market too small? They used to have an on-prem appliance way back when but surely a container package is all you need these days?

I freaking love this sidebar design

What about project folders like git repos and all that ? How do they fit into this system ?

Absolutely no. For all the reasons listed here: https://heyluddite.com/post/4043411544/how-to-name-folders

As if Melvil Dewey and William Gibson had a child...

Part of me originally thought that Johnny Decimal would be in groups of 10.

But first visit to their web site shows numberings exceeding 10.

Ok.

Still a novel idea worth pursuing.

[dead]

The fact that this indistinguishable from satire is an incredible feat. Very well done.

This seems pretty backwards in the age of AI, where semantic search can ingest and numerically sort embeddings with extraordinary finesse.