content(blog): tag filesystem

fezcode · fezcode · commit 2c187f1d379e · 2026-02-18T22:01:17.000+03:00
diff --git a/public/posts/tag-file-systems-explained-go-implementation.txt b/public/posts/tag-file-systems-explained-go-implementation.txt
@@ -0,0 +1,153 @@
+# Escape the Hierarchy Trap: How Tag File Systems Work
+
+We’ve been living in a tree for 50 years.
+
+Ever since the dawn of modern computing, we’ve organized our digital lives into **Hierarchical File Systems**. You have a root, you have branches (folders), and you have leaves (files). It’s neat, it’s tidy, and it’s also **fundamentally broken** for the way we actually think.
+
+Why? Because a file often belongs in more than one place.
+
+Is that `invoice.pdf` in `/Work/Invoices`, or is it in `/Clients/ACME/2024`? In a hierarchy, you have to choose. You either duplicate the file (wasteful), use symlinks (messy), or just hope your future self remembers your arbitrary decision.
+
+Enter: **The Tag File System (TFS)**.
+
+---
+
+## What is a Tag File System?
+
+In a Tag File System, the physical location of a file is irrelevant. Instead of being "inside" a folder, a file is "associated" with one or more **tags**.
+
+Think of it like Gmail labels vs. Outlook folders. In Outlook, an email is in a folder. In Gmail, an email has labels. You can view your "Taxes" label and your "Important" label, and the same email appears in both.
+
+### The Semantic Shift
+- **Hierarchical:** Path-based (`/home/user/photos/cats/oscar.jpg`)
+- **Tag-based:** Attribute-based (`oscar.jpg` + `type:photo` + `subject:cat` + `name:oscar`)
+
+---
+
+## How it Works Under the Hood
+
+How do you actually build this? You can't just delete folders and expect your OS to keep working. Most Tag File Systems are implemented as **overlays**.
+
+### 1. The Database Approach
+The most common way to implement a TFS (like the excellent [TMSU](https://tmsu.org/)) is to use a sidecar database—usually **SQLite**.
+
+The database maps file hashes or paths to a list of tags.
+
+```mermaid
+graph LR
+    subgraph Database
+        Files[Files Table]
+        Tags[Tags Table]
+        Map[File_Tags Mapping]
+    end
+
+    FileA[cat.jpg] --> Files
+    Tag1[#pets] --> Tags
+    Tag2[#cute] --> Tags
+
+    Files --- Map
+    Tags --- Map
+```
+
+### 2. The FUSE Magic
+To make this usable by your favorite apps (like Photoshop or VLC), these systems use **FUSE (Filesystem in Userspace)**.
+
+FUSE allows a program to "pretend" to be a disk partition. When you browse a FUSE-mounted Tag File System, the folders you see aren't real. If you enter a directory named `query/cats+cute/`, the FUSE driver:
+1. Intercepts the `ls` command.
+2. Queries the SQLite database for files tagged with both "cats" and "cute".
+3. Returns those files as if they were actually sitting in that folder.
+
+---
+
+## Let's Build a Simple Tagger in Go
+
+If we wanted to build a tiny version of this, we'd start with a way to track these relationships. Here is a conceptual implementation using Go and a simple map (in reality, you'd use SQL).
+
+```go
+package main
+
+import (
+	"fmt"
+)
+
+type FileID string
+
+type TagSystem struct {
+	// Maps Tag -> Set of FileIDs
+	Tags map[string]map[FileID]bool
+	// Maps FileID -> Set of Tags (for quick lookup)
+	Files map[FileID]map[string]bool
+}
+
+func NewTagSystem() *TagSystem {
+	return &TagSystem{
+		Tags:  make(map[string]map[FileID]bool),
+		Files: make(map[FileID]map[string]bool),
+	}
+}
+
+func (ts *TagSystem) TagFile(file FileID, tag string) {
+	if ts.Tags[tag] == nil {
+		ts.Tags[tag] = make(map[FileID]bool)
+	}
+	if ts.Files[file] == nil {
+		ts.Files[file] = make(map[string]bool)
+	}
+	ts.Tags[tag][file] = true
+	ts.Files[file][tag] = true
+}
+
+func (ts *TagSystem) Query(tags ...string) []FileID {
+	if len(tags) == 0 {
+		return nil
+	}
+
+	// Start with the first tag's files
+	results := make(map[FileID]bool)
+	for f := range ts.Tags[tags[0]] {
+		results[f] = true
+	}
+
+	// Intersect with subsequent tags (AND logic)
+	for _, tag := range tags[1:] {
+		for f := range results {
+			if !ts.Tags[tag][f] {
+				delete(results, f)
+			}
+		}
+	}
+
+	var final []FileID
+	for f := range results {
+		final = append(final, f)
+	}
+	return final
+}
+
+func main() {
+	tfs := NewTagSystem()
+
+	tfs.TagFile("vacation_01.jpg", "2024")
+	tfs.TagFile("vacation_01.jpg", "beach")
+	tfs.TagFile("work_notes.pdf", "2024")
+	tfs.TagFile("work_notes.pdf", "boring")
+
+	fmt.Println("Files from 2024 at the beach:", tfs.Query("2024", "beach"))
+	// Output: [vacation_01.jpg]
+}
+```
+
+---
+
+## The Trade-offs
+
+Tag file systems sound like paradise, but why aren't we all using them as our primary OS?
+
+1. **The "Clean Room" Problem:** Hierarchies are low-maintenance. You just throw a file in a folder. Tags require **discipline**. If you don't tag your files, they vanish into a black hole.
+2. **Standardization:** There is no "Tagging Standard." If you move your files from Linux (TMSU) to macOS, your tags don't come with you unless they are embedded in the file metadata (like EXIF or ID3 tags).
+3. **Performance:** Querying a database with 10 million files and complex tag intersections can be slower than a simple directory lookup.
+
+## Summary
+
+Tag File Systems represent a move from **location-based** computing to **meaning-based** computing. While we might not be ready to ditch folders entirely, adding a tagging layer to your workflow—especially for large media libraries or research papers—can save you from the "Where did I put that?" nightmare.
+
