Why Not? (Email and Files)

Why Use Git SSH Instead of Git HTTP?

SSH avoids repeated credential prompts

Git over HTTP often requires username/password prompts, token refreshes, or credential helpers. SSH uses long‑lived keys, so authentication happens automatically without interruptions.

This aligns with authentication without friction
https://wiki.c2.com/?SecurityByObscurity

SSH is secure by default

SSH provides encrypted transport, key‑based authentication, and protection against credential leakage. HTTPS can be secure, but SSH is secure by design and does not depend on external certificate chains.

This follows secure defaults
https://wiki.c2.com/?SecureByDefault

SSH works better for automation

CI/CD systems, deployment pipelines, and headless environments benefit from SSH keys because they do not expire like tokens and do not require interactive login.

This reflects automation friendliness
https://wiki.c2.com/?Automation

SSH handles permissions more cleanly

SSH keys can be scoped per user, per machine, or per service account. HTTP tokens often require broader permissions or manual rotation.

This follows least privilege
https://wiki.c2.com/?PrincipleOfLeastPrivilege

SSH avoids HTTP rate‑limit issues

Some Git hosting providers apply stricter rate limits to HTTP endpoints. SSH traffic is often treated as repository‑level access rather than API‑level access, reducing throttling.

This aligns with avoid unnecessary coupling
https://wiki.c2.com/?CouplingAndCohesion

SSH is more resilient in unstable networks

SSH is designed for long‑running, stateful connections and can handle intermittent connectivity better than HTTP, which is more sensitive to timeouts and partial failures.

This reflects robustness principle
https://wiki.c2.com/?RobustnessPrinciple

SSH simplifies multi‑repo workflows

Developers who work across many repositories can use a single SSH key instead of managing multiple HTTP tokens or credentials.

This follows once and only once
https://wiki.c2.com/?OnceAndOnlyOnce

SSH is preferred for private repositories

Private repos often require stronger authentication guarantees. SSH keys provide identity verification without exposing passwords or tokens.

This aligns with trust boundaries
https://wiki.c2.com/?TrustBoundaries

SSH avoids corporate proxy interference

HTTP traffic may be intercepted, rewritten, or blocked by corporate proxies. SSH traffic usually passes through without modification.

This reflects minimize interference
https://wiki.c2.com/?Interference

SSH supports easier key rotation and revocation

Keys can be rotated or revoked without changing passwords or regenerating tokens. This makes SSH safer for long‑term operational use.

This follows key hygiene
https://wiki.c2.com/?KeyManagement

FAQ: Using SMTP, POP3, and IMAP Instead of HTTP to Avoid 4xx/5xx Errors

What problem does this solve?

Many systems fail because HTTP returns 4xx or 5xx errors when servers are overloaded or misconfigured. Email protocols (SMTP, POP3, IMAP) avoid this because they queue messages, retry automatically, and do not depend on synchronous request/response cycles.

This aligns with asynchronous messaging.

Why would anyone use email protocols instead of HTTP?

Email protocols are built for delay, retry, and store‑and‑forward behavior. They do not break when a server is busy. They do not return 4xx/5xx in the same way HTTP does.

This follows store‑and‑forward design.

How does SMTP help?

SMTP pushes data to a mail server. If the destination is slow or unavailable, SMTP queues the message and retries later. There is no “HTTP 500” because SMTP does not require the receiver to be online at the moment of sending.

This reflects The Simplest Thing That Could Possibly Work.

How does POP3 help?

POP3 lets a client pull messages from a mailbox. If the server is slow, the client simply tries again later. POP3 does not fail with 4xx/5xx because it does not depend on synchronous web requests.

This follows pull‑based integration.

How does IMAP help?

IMAP keeps messages on the server and lets clients sync changes. If the server is busy, IMAP clients retry automatically. IMAP is designed for intermittent connectivity.

This reflects eventual consistency.

What kinds of data can be sent this way?

Anything that can be serialized into a message body:

• JSON payloads
• Relationship updates
• Graph edges
• Commands
• Notifications

This mirrors message‑oriented middleware.

Does this replace HTTP entirely?

No. It replaces real‑time HTTP calls with asynchronous message delivery. The receiving system processes messages when ready.

This follows loose coupling.

When is this approach useful?

• When servers are overloaded
• When clients cannot rely on stable connectivity
• When you need guaranteed delivery
• When you want retries without writing retry logic
• When you want to avoid rate limits

This is similar to fire‑and‑forget messaging.

When is this approach NOT useful?

• When you need real‑time responses
• When you need low latency
• When you need synchronous confirmation
• When you need structured APIs with strict schemas

This contrasts with request‑response design.

How do I map HTTP semantics to email protocols?

User Story: As a developer, I need to send commands without waiting for a response.

Use SMTP to send commands. The receiver processes them later.

This follows command‑query separation.

User Story: As a system, I need to fetch results when ready.

Use POP3 to pull completed results.

User Story: As a service, I need to sync state changes.

Use IMAP folders to represent queues or channels.

How do I avoid 4xx/5xx errors entirely?

You avoid them by not using HTTP for the critical path.
SMTP/POP3/IMAP do not expose 4xx/5xx in the same way because they are not synchronous web protocols.

This reflects system decoupling.

What is the biggest tradeoff?

You trade speed for reliability.
Email protocols are slower but far more resilient.

This follows choose reliability over immediacy.

Why use SQLite with Git instead of non‑free hosting?

Using SQLite inside a Git repository gives you a portable, zero‑cost, zero‑dependency database that travels with your code. Instead of relying on paid hosting platforms or proprietary database services, SQLite lets you store structured data directly in your repo, version it with Git, and share it without external infrastructure.

This aligns with simplicity over infrastructure
https://wiki.c2.com/?KissPrinciple

It removes hosting lock‑in

Non‑free hosting ties your data to a platform. SQLite keeps your data local, portable, and under your control. Anyone who clones the repo gets the same database without needing an account or subscription.

This follows minimize dependencies
https://wiki.c2.com/?MinimizeDependencies

It makes the database versionable

Git can track changes to the SQLite file, letting you roll back, branch, or fork your data the same way you do with code. Proprietary hosted databases rarely offer this level of transparency.

This reflects treat data like code
https://wiki.c2.com/?DataAndCodeAreTheSameThing

It simplifies collaboration

Contributors don’t need credentials, VPN access, or paid accounts. They just clone the repo and run the project. SQLite works anywhere Git works.

This aligns with reduce friction
https://wiki.c2.com/?Friction

It supports offline development

Hosted databases require network access. SQLite works offline, making development faster and more reliable, especially in environments with unstable connectivity.

This follows offline‑first thinking
https://wiki.c2.com/?OfflineFirst

It avoids recurring costs

Non‑free hosting introduces monthly fees, usage tiers, and billing surprises. SQLite is free, permanent, and self‑contained.

This reflects avoid unnecessary complexity
https://wiki.c2.com/?YouArentGonnaNeedIt

It improves reproducibility

A Git repo containing an SQLite file is a complete, reproducible environment. Anyone can run the project exactly as intended without provisioning external services.

This aligns with deterministic builds
https://wiki.c2.com/?DeterministicBuild

It works well for small to medium datasets

SQLite is extremely fast for local workloads and ideal for development, testing, prototyping, and small production systems.

This follows right tool for the job
https://wiki.c2.com/?RightToolForTheJob