Aufbau eines persönlichen Wissensmanagementsystems
Wie du als Entwickler ein nachhaltiges Wissensmanagement aufbaust: Notiz-Frameworks, Verknüpfungsstrategien und Wiederfinden mit Zinseszins.
Jeder Entwickler liest Dokumentation, debuggt kryptische Fehler und entdeckt bessere Vorgehensweisen. Das meiste davon verflüchtigt sich innerhalb weniger Wochen. Ein persönliches Wissensmanagementsystem (PKM) erfasst, ordnet und holt das Gelernte wieder hervor, damit es sich aufbaut, statt zu verblassen.
Dabei geht es nicht darum, die richtige App zu finden. Werkzeuge sind weniger wichtig als das System, das du darauf aufbaust. Eine simple Struktur aus Textdateien mit guten Gewohnheiten schlägt ein ausgefeiltes Tool ohne Prozess dahinter.
Die Angewohnheit des Erfassens
Der wichtigste Teil des Wissensmanagements ist, Informationen genau in dem Moment festzuhalten, in dem du auf sie stößt. Wartest du auch nur 30 Minuten, ist der Kontext meist schon verloren.
## Capture Template (daily-notes/2021-06-25.md)
### Debug: PostgreSQL connection pool exhaustion
- **Context**: Production alert at 2pm, API response times spiked to 8s
- **Root cause**: Long-running analytics query was holding connections
for 45+ seconds, exhausting the 20-connection pool
- **Fix**: Separate read replica connection pool for analytics queries
with statement_timeout of 30s
- **Ref**: https://wiki.postgresql.org/wiki/Number_Of_Database_Connections
- **Tags**: #postgresql #connection-pool #production-incident
### TIL: CSS `aspect-ratio` works on replaced elements
- Using `aspect-ratio: 16/9` on an img tag prevents layout shift
without needing the padding-bottom hack
- Still need width OR height set — aspect-ratio calculates the other
- **Tags**: #css #layout-shift #performanceDie Erfassungsvorlage hat fünf Felder: Kontext (warum du das nachgeschlagen hast), Inhalt (was du gelernt hast), Quelle (wo du es gefunden hast), Verknüpfungen (womit es zusammenhängt) und Tags.
Organisieren mit Maps of Content
Flache Tag-Systeme stoßen mit wachsendem Umfang an ihre Grenzen. Maps of Content (MOCs) sind Index-Notizen, die verwandte Notizen zu einer navigierbaren Struktur zusammenführen.
## Database Performance MOC (mocs/database-performance.md)
### Connection Management
- [[connection-pooling-essentials]] — pool sizing, pgBouncer config
- [[database-connection-exhaustion-debug]] — production incident, read replica fix
- [[connection-timeout-strategies]] — statement_timeout, idle_in_transaction
### Query Optimization
- [[sql-query-optimization-guide]] — EXPLAIN ANALYZE, index selection
- [[slow-query-log-analysis]] — pg_stat_statements, identifying hot paths
- [[n-plus-one-query-patterns]] — ORM pitfalls, dataloader pattern
### Indexing
- [[database-indexing-deep-dive]] — B-tree, GIN, partial indexes
- [[composite-index-ordering]] — column order matters, left-prefix rule
- [[index-bloat-management]] — REINDEX, pg_repack, monitoring
### Scaling Patterns
- [[read-replica-architecture]] — connection routing, replication lag
- [[database-sharding-strategies]] — hash, range, directory-based
- [[connection-pool-per-service]] — microservices isolation patternMOCs funktionieren, weil sie widerspiegeln, wie dein Gehirn Wissen organisiert, nicht in starren Hierarchien, sondern in thematischen Clustern. Eine Notiz über Connection Pooling kann im MOC "Datenbank-Performance" auftauchen und ebenso in einem MOC "Produktionsvorfälle".
Die Zettelkasten-Verlinkungsstrategie
Einzelne Notizen entfalten ihre Kraft erst durch Verlinkung. Die Zettelkasten-Methode erzeugt ein Netzwerk, in dem jede Notiz mit verwandten Ideen verbunden ist.
## Note: Statement Timeout Strategy (notes/statement-timeout-strategy.md)
**ID**: 2021-06-25-1403
**Tags**: #postgresql #timeout #resilience
Setting `statement_timeout` at the connection pool level prevents
any single query from holding resources indefinitely.
```sql
-- Per-connection pool timeout (set in pgBouncer or application config)
ALTER ROLE analytics_reader SET statement_timeout = '30s';
ALTER ROLE api_reader SET statement_timeout = '5s';
-- Per-query override when needed
SET LOCAL statement_timeout = '60s';
SELECT * FROM expensive_analytics_view;
Different roles get different timeouts based on their expected query patterns. The API pool gets a strict 5s timeout because any query taking longer than that should be moved to a background job.
Links:
- Relates to: [[connection-pooling-essentials]] — pool configuration
- Triggered by: [[database-connection-exhaustion-debug]] — discovery context
- Supports: [[circuit-breaker-pattern]] — timeout is a form of circuit breaking
- See also: [[timeout-retry-backoff-pattern]] — what happens after timeout
Jede Notiz verlinkt nach vorn (was sie ermöglicht) und nach hinten (was zu ihr geführt hat). Mit der Zeit zeigen die am stärksten verlinkten Notizen die zentralen Konzepte deiner Wissensbasis.
## Workflows zum Wiederfinden
Wissen, das du nicht wiederfindest, ist Wissen, das du nicht hast. Baue das Wiederfinden fest in deinen Alltag ein.
```typescript
// Simple local search script for markdown knowledge base
import { readdir, readFile } from 'fs/promises';
import { join } from 'path';
interface SearchResult {
file: string;
line: number;
context: string;
score: number;
}
async function searchNotes(
query: string,
notesDir: string
): Promise<SearchResult[]> {
const results: SearchResult[] = [];
const queryTerms = query.toLowerCase().split(/\s+/);
const files = await readdir(notesDir, { recursive: true });
for (const file of files) {
if (!file.endsWith('.md')) continue;
const filePath = join(notesDir, file);
const content = await readFile(filePath, 'utf-8');
const lines = content.split('\n');
for (let i = 0; i < lines.length; i++) {
const lower = lines[i].toLowerCase();
const matchCount = queryTerms.filter(t => lower.includes(t)).length;
if (matchCount > 0) {
const start = Math.max(0, i - 1);
const end = Math.min(lines.length, i + 2);
results.push({
file,
line: i + 1,
context: lines.slice(start, end).join('\n'),
score: matchCount / queryTerms.length,
});
}
}
}
return results
.sort((a, b) => b.score - a.score)
.slice(0, 20);
}
// Usage: search("connection pool timeout postgres")
// ❌ Searching only by filename
const result = notes.filter(n => n.filename.includes(query));
// Misses notes where the content matches but the filename doesn't
// ✅ Multi-signal search: filename + content + tags + links
function searchScore(note: Note, query: string): number {
const terms = query.toLowerCase().split(/\s+/);
let score = 0;
for (const term of terms) {
if (note.filename.toLowerCase().includes(term)) score += 3;
if (note.tags.some(t => t.includes(term))) score += 2;
if (note.content.toLowerCase().includes(term)) score += 1;
if (note.links.some(l => l.toLowerCase().includes(term))) score += 1;
}
return score;
}Die beste Wissensbasis ist die, in der du auch wirklich suchst. Wenn du dich dabei ertappst, dasselbe Problem zu googeln, das du vor sechs Monaten schon gelöst hast, versagt dein Retrieval-System.
Regelmäßige Wiederholung
Neue Notizen brauchen Verstärkung. Eine wöchentliche Review-Gewohnheit verhindert, dass Wissen verkümmert.
## Weekly Review Template (templates/weekly-review.md)
### Date: 2021-06-25
#### New Notes This Week (review for accuracy and links)
- [ ] Statement timeout strategy — linked to connection pooling?
- [ ] CSS aspect-ratio discovery — linked to performance MOC?
- [ ] Production incident postmortem — root cause documented?
#### Random Resurfacing (revisit 3 random older notes)
- [ ] [[distributed-tracing-fundamentals]] — still accurate?
- [ ] [[feature-flags-at-scale]] — any new patterns learned since?
- [ ] [[oauth2-flows-demystified]] — relevant to current project?
#### MOC Updates
- [ ] Database Performance MOC — add new connection pool notes
- [ ] Production Incidents MOC — add this week's incident
#### Gaps Identified
- Need deeper notes on pgBouncer configuration
- Missing: comparison of connection pooling libraries for Node.jsDas wöchentliche Review erfüllt drei Aufgaben: Es festigt neues Wissen, holt altes Wissen wieder hervor und deckt Lücken auf. Der Abschnitt "zufälliges Auftauchen" sorgt dafür, dass neue Notizen die älteren nicht verdrängen.
Dateisystemstruktur
Halte die Dateistruktur einfach. Komplexität in der Organisation erzeugt Reibung, die die Gewohnheit im Keim erstickt.
knowledge-base/
├── daily/ # Quick captures, inbox
│ ├── 2021-06-23.md
│ ├── 2021-06-24.md
│ └── 2021-06-25.md
├── notes/ # Processed, permanent notes
│ ├── connection-pooling-essentials.md
│ ├── statement-timeout-strategy.md
│ └── css-aspect-ratio-layout-shift.md
├── mocs/ # Maps of Content (index notes)
│ ├── database-performance.md
│ ├── frontend-performance.md
│ └── production-incidents.md
├── projects/ # Project-specific knowledge
│ ├── migration-to-k8s/
│ └── auth-service-redesign/
├── templates/ # Capture and review templates
│ ├── daily-note.md
│ ├── weekly-review.md
│ └── incident-postmortem.md
└── README.md # How this system works
Drei Ordner decken 90 % des Workflows ab: daily für Rohcaptures, notes für aufbereitetes Wissen und mocs für die Navigation. Alles andere ist optional.
Die wichtigsten Erkenntnisse
- Sofort erfassen — schreib es auf, sobald du es lernst, nicht später, wenn der Kontext schon weg ist
- Maps of Content nutzen, um Notizen in navigierbaren Clustern zu organisieren statt in starren Ordnerhierarchien
- Konsequent verlinken — jede Notiz sollte mit mindestens 2-3 verwandten Notizen verbunden sein
- Wiederfinden fest in den Workflow einbauen — wenn du etwas nicht in 30 Sekunden findest, verbessere deine Suche
- Wöchentlich reviewen — neue Notizen festigen, alte wieder hervorholen und Wissenslücken erkennen
- Die Struktur minimal halten — drei Ordner (daily, notes, MOCs) decken die meisten Workflows ab
