jtm@x1c ~ % ls
TODO acme aux bin doc down git go mail mnt music rom www xen 

• acme - additional scripts for acme.
• aux - synonymous with “junk”.
• doc - images, documents, slides, etc.
• down - downloads
• mail - emails in Maildir format.
• www - source code for a static site.
• xen - vm configurations.

I’ve been meaning to add a cron job to delete anything in down that’s older than three days.. that folder tends to blow up.

To keep junk from accumulating in $HOME, I use a shell function called “t” that will automatically cd to a temporary scratch space, so I don’t have to think about cleaning up junk that I don’t intend to keep. I use this almost every day.

function t {
  cd $(mktemp -d /tmp/$1.XXXX)
}

It seems like I’m the only here whose $HOME looks like a junkyard.

$HOME is read-only:

• New applications are not allowed to create directories or files in $HOME.
• Existing non-compliant applications are gradually replaced by compliant ones.

All dirs lowercase for better auto-completion.

• .cache: XDG cache dir

• .config: XDG config dir

• .local: XDG “local” dir

• apps: unmanaged third-party application binaries

• audios: subfolders music and casts

• backup: obvious

• code: sources for my coding projects

• desktop: files that are displayed on the dektop

• documents: obvious

• downloads: obvious

• fonts: symlink to .local/share/fonts/

• images: pictures, screenshots, wallpapers (I wanted to find a different name, because of the possible confusion with CD images, but the time made this concern obsolete)

• public: shared directory, network-accessible

• remote: remote mounts

• videos: obvious

Honestly,

not.

$ ls -F
adm/ bak/ local/ mdc/ pro/ src/ x

• adm: shitty administrative tasks, taxes, official letters, etc
• bak: static read-only content, pdf and djvu books, music, test images
• local: like /usr/local but for my user, ~/local/bin is in my PATH
• mdc: teaching-related stuff, with one sub-folder for each course and each phd student
• pro: non-teaching related professional projects
• src: source codes compiled locally, including my repos
• x: text-file with a to-do list

$ ls|wc -l
121

Don’t even know if it would be worth it to try to organize.

Downloads bin img lib sites src tmp torrents who www

I have an archive/0next folder where I put any files which are not actively being edited (or stored in my personal monorepo in ~/sys).

Every 6-12 months I will rename 0next to archive-yyyy-mm-dd, and also save tarballs to AWS glacier and a Blu-ray disc.

The benefits of this system are that I have a clear distinction between mutable files and immutable files. At any one time I only have a few GBs of working files. The rest is checksummed and trivially easy to recover (rm + s3 cp)

Otherwise it’s a standard layout: documents, downloads, etc.

• dev – for development projects,
• dev/<programming language name> – for my C++ projects/inventions/snippets in this language,
• dev/<programming language name>/tests – for snippets related to a programming language that test one concept, helps to learn the language and reference this particular feature in the future,
• temp – a directory for various temporary stuff that I know can be removed, everything here is either truly temporary or can be easily regenerated,
• temp/build – development artifacts built from sources inside dev directory. Normally I use cmake (for c/c++) everywhere so that it always supports out-of-tree build. This way I can just remove all binaries instantly without figuring out how to clean some particular source tree,
• lab – my playground, testing some tools, resources for scripts,
• env – sourced shell scripts on machines that require some more environment settings. I use it on MSYS2 to integrate Visual Studio installation into bash command line,
• .dotfiles – my dotfiles, configs are symlinked to this directory,
• tasks - at work, I use it for Jira tickets,
• req/<name> - if someone wants something from me that requires preparation of some files, often I setup a directory here with person’s name, and I put files in its own dir,
• bin - added to $PATH for my user, some executables are symlinked from ~/temp/build/ to here, or directly from ~/dev/ if they’re scripts,
• apps – locally installed apps (IntelliJ IDEA, Eclipse, Ghidra, etc),

bin, downloads, drawings, game-ideas, games, gaming, models, music, my.src, presentations, school, src, sync, tmp, work. Can’t remember when I actually came up with this structure but it’s basically embedded in my brain by now.

$ ls
code  data  snap  tmp

• code - holds every projet I download/work on locally. I have one subdirectory for work
• data - subdivided for any kind of data (images, videos, certs, nodes, templates, …) also hold mountpoints
• data/$MOUNT - named after what’s mounted (onedrive, sharepoint, etc…)
• snap - Auto-created by the snap command. If you know how to get rid of that, I’d be thankful !
• tmp - Non-persistent data. Either temp scripts or web downloads. I’ll mount it as tmpfs someday.

There are also multiple hidden directory that I use on a daily basis:

• ~/.local/bin - personnal scripts.
• ~/.cache/mail - emails in Maildir format (sync’d over IMAP).
• ~/.pw - passwords in encrypted format (see safe).

There are a few directories present on all of my machines:

• bin - scripts, tmp binaries
• mnt - user mounts
• workspace - everything related to code
  • $lang/$project - projects grouped by language
  • misc/$project - projects using multiple languages, configs, documentation
• xdg user dirs (empty except for Downloads)

Mine’s a mess, but I know where everything is, so I rarely bother cleaning it up.

I have:

~/bin/
~/data/  - I added this recently when I was downloading shapefiles to play with GIS.  Basically just a collection of different data sets/
~/Downloads/
~/music/
~/images/  - I like playing with computer graphics, and the output goes here
~/pdfs/ - Books and papers in PDF form
~/src/ - My source code
~/oss_src/ - Open source projects I build from source but don't plan on contributing code to (SBCL, Emacs, etc.)

• ~/bin
• ~/bin/foo.app (the target directory of some locally compiled project, like emacs)
• ~/bin/foo -> foo.app/bin/foo (see, I don’t want to pollute my path, so I put a symlink in ~/bin that points at the binary.)
• ~/bin/bar (shell script)
• ~/scratch (This is a directory I create on all my machines. It’s not exactly tmp. I use it like a junk drawer and workspace. It’s currently 7.6gb on my work machine and there are like three specific files in there that I know of. The rest could be deleted. The oldest files in there are from 2012.)
• ~/src or ~/projects (First I had src and it was a mixture of my projects, third party projects that I’d modified, and third party projects that I have no intention of modifying. Later, I got the idea of separating the wheat from the chaff. But, I’m pretty sure I now have some non-modified third party projects in my ~/projects now, because ~/src wasn’t mounted the other day or something, or I’m just really messy??)
• ~/Downloads -> ~/downloads (Now that /u/soc shared this “read-only $HOME” idea with me, I won’t have to create this symlink anymore.)
• ~/media or /media (These only exist on the older machines and they have subdirs like music and video)
• ~/old-home, ~/namagiri-home, ~/debzero-home (Of all my junk in $HOME, these are probably what I’m most ashamed of. They are just full copies of various previous $HOMEs on previous incarnations of the same machine or other machines. hold on let me hit ctrl-r real quick to show you something: ssh -i ~/old-home/hobbes/.ssh/id_rsa *****.*** See? Ashamed. So many reasons.)

I don’t organize my $home. I’m a chaotic type of person. the oldest directory bears a september 1997 timestamp.

I use lots of finding “functions” which utilize locate or fd and lr

for example

lr -G -om $(fd --maxdepth 1 -t d '[a-zA-Z0-9]{1,10}-[0-9]{1,5}-sql$' ${HOME})

lists all project directories named like (customer abbreviation)-(ticket number)-sql

Some of these funktions are piped to fzf -because the list became too long- so I can find anything even quicker than the orderly and tidy guys click through the deep project directory hierarchy with the mouse in file browser.

A similar function finds sublimetext project files, and the subsequent fzf opens the project in sublimetext.

So my approach is to have a consistent naming and use custom tools to find things.

cadey:cadey@kahless ~ ./rw
$ ls
backup/  bin/  code/  dl/  go/  irc/  life/  music/  org/  pictures/  prefix/  public_html/  sdk/  snap/  texmf/  tmp/

• backup: backups
• bin: random tools that aren’t properly installed in other ways
• code: where I write code in
• dl: downloads
• go: my $GOPATH
• irc: IRC logs, many gigabytes of them
• life: where I keep some private keys and information
• music: music that mpd cycles through
• org: from a failed org-mode experiment of mine
• pictures: mostly archives from image boorus
• prefix: my $PREFIX for software that’s installed less improperly
• public_html: https://xena.greedo.xeserv.us
• sdk: where my go compilers live (artifact of https://godoc.org/golang.org/dl)
• texmf: I think TeXLive did this
• tmp: temporary files

I keep all code inside ~/src sorted by theme. And search file system with Alfred to open projects in VS Code or cd quickly to folder in iTerm.

On Windows, aka where my more important private documents live (laptops are ephemeral): hardly at all.

On Linux, I’ve long stuck mostly with the Ubuntu/Debian defaults (which means Freedesktop I guess):

• So ~/Documents
• and ~/Pictures
• and ~/Downloads
• Also I use ~/code for my code, subdivided by work/github/misc/dotfiles (from git)
• and a ~/tmp
• and a ~/bin

I have a few files in .config/ but it’s just one start and end-hook for zsh to overwrite params.

I really don’t have a strong opinion on any of this. Except that I’m lazy and thus need a short bin and tmp dir :P

$ ls -F
Archive.zip  Maildir/     bin@         repos/       sandbox/

• Archive.zip created every few days that zips Maildir
• Maildir mail contents
• bin symlinks to repos/bin_files/ -> https://github.com/zg/bin_files
• repos/ contains repositories I’ve cloned (including https://github.com/zg/dot_files, which I’ve symlinked contents up to ~, e.g. ~/.zshrc points at ~/repos/dot_files/.zshrc)
• sandbox/ experimenting, so it’s a bag of dirt

This is every folder I keep on all of my unix-like installations. I’ve found that this layout is pretty all- encompassing and is easy to look through.

repos - git repos and folders of code that I didn’t write docs - any documents, books, code that isn’t in a repo, etc downloads - self explanatory media - all of my photos, music, and videos files - backups of files games - halo 2 and 3 running via wine, and ROM archives .scripts - everything that I want to be executable that I don’t want in my $PATH .minecraft - the most essential folder of the entire computer

• prog/ - in-dev programming projects, basically whatever I write from scratch or fork for tweaking
• dnload/ - downloads, further organised in coarse-grained subdirs, like nim-etc/, or editors-etc/, … - I try to never download anything without putting it in a subdir (old or new)
• $MY_NAME/ - personal stuff, mostly in subdirs named by date, e.g. “2019-12 taxes/” etc.
• photos/ - photos & videos, in dated subdirs, e.g. “2019-12-01..03 Some Place, trip with Some Friend/”
• drafts/ - attempt at a log/notes, not working well yet
• work/ - subdir present only at work, with subdirs for various tasks, and a separate mess in every one of them
• bin/ - scripts
• go/ - autogenerated by Go
• tmp/ - stuff
• a few temp. files lying around

I think that’s mostly all, though I’m doing it from memory. Also I am trying to use home-manager, works for me for some stuff (esp. vimrc) but not for everything.

Meme content/saves: I wget them directly into the home dir and move them into a archive storage at the beginning of each month.

Git/sourcecode: Lives in ~/src, usually

Config/Scripts: in ~/.config, which is tracked in git. There are various symlinks into ~/.config.

Accounts on shared hosts also have a public readable public_html, even if there is no http server running usually.

Like jtm, i use mktemp directories as scratchpad.

• devel Projects I have personally written.
• dl Assorted downloads.
• games Source code and other files for (non-packaged, non-steam) games I play.
• lang Miscellaneous conlang files.
• media.txt List of media I would like to or have read/watched/listened to.
• music Various musical projects.
• opt The contents of /opt bind-mounted since I ran out of space on /.
• pictures Pictures.
• pnp Pen-and-paper rpg files.
• school Files I created for school.
• serial.txt Documentation for my usb-serial converter so I don’t forget what wire are which.
• software Source code for any software I want to build/work on.
• Steam Steam games not installed on my SSD.
• taxes Copies of my tax returns and other forms.
• videos Videos I have recorded.
• work Copies of work-related forms.

code documents downloads local sync private work

• sync is a symlink to my dropbox folder under .local
• private is the encfs mountpoint for a encrypted disk image in dropbox
• local is bin/var/cache etc

fixed the casing on documents & downloads with xdg vars, which most of the time works.

bin, code, games, docs, dotfiles, downloads, vids, pics and leet. The last dir leet is something I’ve been keeping around in my home dir since my early Linux days – it essentially has code that isn’t mine, or other “leet” stuff. Haven’t bothered renaming it to something more mature. :’)

The games dir is hardly ever populated, but it’s for when I have non-Steam games that I decide to play.

$ ls # i'm actually at work and just guesstimating what's on my computer from what's on my server

band_project_names bin c-programming documents downloads erlang elixir forth game nim python retro src TODO websites

basically organised by what they are. src/ is like /opt or /usr/local/src but shorter to type. websites is ripped websites.

ls -l -d */

Downloads/ Mail/ Pictures/ bin/ docs/ sync/ work/

I… don’t. Mind you, I have been trying, but I’d probably need to have at it for a week straight to remove/organize all the cruft that has been accumulating over the last few years.

I have sketched a tentative folder layout, though, which is in use on my netbook (and partially on my laptop):

• doc/: assorted personal documents (PDF scans/JPEG photos + org-mode notes)
  • academy/
  • archive/
  • finance/
  • journal/
  • medical/
• dev/: my own repositories, what I am actively developing
• dat/: miscellaneous data files, minus books
• etc/: assorted scripts & dotfiles, installed in their proper place via stow
• lib/: books & assorted reading material, organized according to the Universal Decimal Classification - e.g.,
  • 0.Science_and_Knowledge/
    • 02.Librarianship/
      • 025.450.Decimal_classifications/
  • 1.Philosophy_Psychology/
  • 2.Religion_Theology/
  • 3.Social_sciences/
  • …
  • A.Fiction/
    • Pratchett_Terry/
• tmp/: temporary files, including browser downloads and repos that I’m just checking out

I name most files according to the following pattern, while taking care to not include “weird characters” (or even just spaces) in my filenames:

[Author.][Date.][Series-NN.]Title[--tag-tag].ext

It can be a bit of an hassle, but it makes locate actually useful.

• repos - for WIP code
• old-repos - for code I consider not under active development
• church - a farm for ideas. I’ll write lots of experimental code here that I then borrow in more cohesive/focused projects
• life - orgmode life planner files, symlinked from dotfiles
• books - epub files, pdfs, etc. I’ve accumulated
• bin - custom scripts/executables to put in PATH
• school
• dotfiles

My $HOME directory contains some config files, a Desktop folder (where I keep everything of value) and a Downloads folder, which is sort of an inbox of things to review.

I mainly work in the Desktop, which contains:

• personal: which contains all my dotfiles (symlinked to where they should be), my files (invoices, ID and passport scans, digital backup of important paper documents…), my projects (basically a clone of all my repos and stuff in the works), my sites (SSH keys, Ansible playbooks, Terraform files, Kubernetes manifests, Docker stack files… As well as the source of my static sites) and my scripts (local cron jobs, mini utilities I use all the time, etc.). Also my encrypted password database file.
• studies: I’m on my third year in university for CS, one folder per subject and a Python script where I track all my grades.
• work: I do AWS as a side gig, so one folder per client, and one subfolder per project. Oh, and my CV in English and Spanish.

I keep everything in Desktop so that I can restic it all at once into my over-engineered backup system.

I’ve been happily using this system for half a decade, and I’m very happy with it.

I don’t think your system for file org is much important, but rather sticking to it and using it daily. I’m writing this off my memory, because I know where everything is and that’s what makes it productive.

I’ve got (copied from my emacs.d):

~/code/: programming and sysadmin related files

~/code/{c,haskell,go,...}: directories devoted to specific programming languages

~/code/etc/...: various other projects

~/dl/: downloads gathering directory, preferably empty

~/doc/: texts, presentations and notes

~/doc/org/: most org-mode related files

~/media/: general directory for digial media

~/media/{img,vid,music,...}: specific media directories

~/etc/: various other directories

~/etc/bin/: user binaries

~/etc/{mail,news,pub}: gnus related directories

and a function like this in by bashrc:

goto() {
	case $1 in 
	read) 		cd ~/doc/read			;;
	vm)   		cd ~/code/etc/vm		;;
	c)      	cd ~/code/c				;;
	img)		cd ~/media/img			;;
	compsci)	cd ~/doc/read/compsci	;;
	go)			cd ~/code/go/src/		;;
	lisp)		cd ~/code/lisp/			;;
	web|www)	cd ~/code/web/www/		;;
	dl)			cd ~/dl/				;;
	pers)		cd ~/doc/pers/			;;
	uni)		cd ~/doc/uni/			;;
	esac
}

The main part of my $HOME is a hierarchy:

std/bin
std/cfg
std/cfg/templates
std/lib
std/lib/perl
std/lib/perl/...
std/lib/sh
std/lib/vim
std/lib/vim/...
std/libexec

which contains almost all of my configuration. Various dotfiles like .bashrc and .vimrc are symlinked into $HOME from std/bin. I replicate this hierarchy across 1000+ servers to give me my standard environment on those servers. I have a separate $HOME/bin for local additions applicable to only a single server environment. Almost all of my non-dotfile $HOME is symlinks.

bin

binaries and scripts I want to include in my $PATH

development

I organize everything by repositories, like

• development/sr.ht/jussi/repo-name
• development/github.com/metosin/reitit

documents

A lot of various documents from my download directory, sorted by filetype, client name or content. I automate sorting these using Hazel.

archive

Automated by hazel as well. After a file has been in documents for 4 months, it’ll be archived (or deleted, depends on various things like content and client).