Temporal Analysis: Git's Evolutionary Trajectory

Status: Canonical reference. Tracking Git's unified manifestation through time — from creation to present. Understanding how a specific software system evolves through the lattice.

1. Purpose

Biology tracked species through geological time — how E. coli's unified manifestation changed from earliest prokaryote to modern organism. We do the same for Git — track its structural position from initial creation (2005) through present, seeing how its unified manifestation changes at each transition point.

This reveals the DYNAMICS of software evolution: how systems move through lattice positions, what drives transitions, and what constraints shape the path.

2. Git's evolutionary trajectory

2.1 Pre-Git: The problem space (pre-2005)

Before Git, Linux kernel development used BitKeeper (proprietary). When BitKeeper revoked its free license, Linus Torvalds needed a replacement. The design constraints:

• Must handle Linux kernel scale (thousands of files, millions of lines)
• Must support distributed development (no central server)
• Must be FAST (Linus's primary requirement)
• Must guarantee data integrity (cryptographic verification)

These constraints shaped Git's INITIAL POSITION in the lattice.

2.2 Epoch 1: Initial Git (April 2005 — first weeks)

Linus wrote the initial Git in about 2 weeks. It was a content-addressable filesystem, not a version control system.

U(Git, April 2005) = (
  Substrate:  (E3, I-Full, T1, M0, X0, P0)
  Bridge:     (Enc2-custom format, Hsh-Full-SHA1, Prt0, Prs1-loose objects, Sch0, Net0)
  Surface:    (D3, Sh1, Ac1-hash lookup, Mt1-manual, Pg0, Ch0, Pc1-CLI, Pn1-CLI, Bn0, Au0, Hs1-object DAG, Ev0)
  Ecosystem:  (Vc1-Linus's tool, Ex0, Ru0, Dv0, Ig0, Gv0, Tp0, Eo0, Io0)
)

Key features of initial position:

• I-Full and Hsh-Full FROM DAY ONE — content addressing was the CORE design decision
• T1 (flat object storage, no real tree management UI)
• M0, X0, P0 — no emit, no dispatch, no peer. Just store and retrieve by hash.
• Prs1 — loose objects in filesystem directories
• Ecosystem: Vc1 — personal tool for one person

What this tells us: Git started at the CONTENT-ADDRESSING ATTRACTOR {E-high, I-Full, T-low, everything else 0}. The identity primitive was maximal from the start. Everything else was minimal. The initial design was the SEED CRYSTAL — content addressing.

2.3 Epoch 2: Basic VCS features (mid-2005)

Within months, Git gained: commit objects, tree objects, branch refs, basic merge, diff.

U(Git, mid-2005) = (
  Substrate:  (E-Full, I-Full, T2, M0, X0, P0)
  Bridge:     (Enc2, Hsh-Full, Prt0, Prs2-loose+packs starting, Sch0, Net0)
  Surface:    (D-Full, Sh2, Ac2-log+diff, Mt2-commit, Pg0, Ch1-merge, Pc1, Pn1, Bn0, Au0, Hs3-full commit DAG, Ev0)
  Ecosystem:  (Vc2-Linux kernel team, Ex1-email patches, Ru0, Dv0, Ig0, Gv0, Tp0, Eo0, Io0)
)

Transitions:

• E3→E-Full: typed objects (blob, tree, commit, tag) fully specified
• T1→T2: tree objects represent directory hierarchy
• Hs1→Hs3: commit DAG IS version control — full history reconstructible
• Vc1→Vc2: now used by Linux kernel team (dozens of developers)
• Ex0→Ex1: patches shared via email (email as exchange mechanism)

What drove these transitions: The NEED for version control (not just content storage). Commit objects added temporality (Hs). Tree objects added hierarchy (T). These are FORCED by the use case — you can't do version control without commits and trees.

2.4 Epoch 3: Pack files and network protocol (late 2005 - 2006)

Git gained: packfile format (compressed object storage), git-fetch/git-push, remote tracking branches, basic HTTP and SSH transport.

U(Git, 2006) = (
  Substrate:  (E-Full, I-Full, T2, M0, X0, P0)
  Bridge:     (Enc3-packfile, Hsh-Full, Prt2-pack protocol, Prs3-loose+pack, Sch0, Net2-remotes)
  Surface:    (D-Full, Sh2, Ac2, Mt2, Pg0, Ch2-merge+fetch, Pc1, Pn1, Bn2-remotes, Au1-ssh keys, Hs-Full, Ev0)
  Ecosystem:  (Vc3-open source, Ex2-clone/push/pull, Ru1, Dv1, Ig1, Gv1, Tp2-distributed, Eo1, Io1)
)

Transitions:

• Prs1→Prs3: packfile format — efficient compressed storage. CRITICAL for scalability.
• Prt0→Prt2: network protocol — Git can now transfer objects between machines.
• Net0→Net2: remotes — distributed development possible.
• Bn0→Bn2: remote repositories as boundaries.
• Hs3→Hs-Full: with packfiles and network protocol, full history is efficiently storable and transferable.
• Vc2→Vc3: open-sourced, other projects start using Git.
• Tp0→Tp2: distributed topology — no central server required.

What drove these transitions: DISTRIBUTION. The single-machine content store needed to become a distributed system. Packfiles solved the efficiency problem. Network protocol solved the communication problem. These transitions moved Git from a local tool to a distributed VCS.

2.5 Epoch 4: GitHub era (2008-2012)

GitHub launched in 2008. Git gained: widespread adoption, pull request workflow, issue tracking (via GitHub), hosting as a service.

U(Git, 2010) = (
  Substrate:  (E-Full, I-Full, T2, M0, X0, P0)   — substrate UNCHANGED
  Bridge:     (Enc3, Hsh-Full, Prt2, Prs3, Sch0, Net2)  — bridge UNCHANGED
  Surface:    (D-Full, Sh2, Ac2, Mt2, Pg0, Ch2, Pc1, Pn1, Bn2, Au1, Hs-Full, Ev0) — surface UNCHANGED
  Ecosystem:  (Vc-Full, Ex3-GitHub, Ru3-forking, Dv3-many projects, Ig3-GitHub API, Gv2-GitHub norms, Tp3-GitHub central hub, Eo2, Io2-GitHub interop)
)

The remarkable finding: Git's substrate, bridge, and surface positions DID NOT CHANGE from 2006 to 2010. All the change was at the ECOSYSTEM LEVEL.

GitHub didn't change WHAT GIT IS — it changed HOW GIT PARTICIPATES IN THE ECOSYSTEM. The tool's structural capabilities were frozen since 2006. The ecosystem around it exploded.

Transitions (all ecosystem):

• Vc3→Vc-Full: Git became THE version control system for open source
• Ex2→Ex3: GitHub as platform exchange — fork, clone, pull request
• Ru1→Ru3: forking culture — massive code reuse through Git
• Dv1→Dv3: thousands of projects on GitHub
• Ig1→Ig3: GitHub API, CI/CD integration, webhook ecosystem
• Gv1→Gv2: GitHub social norms (PR workflow, code review, issues)
• Tp2→Tp3: GitHub as central hub in a distributed system (ironic — distributed VCS with centralized hosting)

2.6 Epoch 5: Maturity and universality (2012-present)

Git became universal. SHA-256 transition started. LFS for large files. Submodules improved. But fundamentally: Git didn't change.

U(Git, 2024) = (
  Substrate:  (E-Full, I-Full, T2, M0, X0, P0)   — STILL UNCHANGED since 2005
  Bridge:     (Enc3, Hsh-Full, Prt2, Prs-Full-pack v2, Sch0, Net2)  — Prs improved (partial clone, shallow clone)
  Surface:    (D-Full, Sh2, Ac2, Mt2, Pg0, Ch2, Pc1, Pn1, Bn2, Au1, Hs-Full, Ev0) — UNCHANGED
  Ecosystem:  (Vc-Full, Ex-Full, Ru-Full, Dv-Full, Ig-Full, Gv3, Tp3, Eo3, Io3)
)

Git's substrate position has been FROZEN since April 2005.

• E-Full, I-Full: from day one
• T2: from mid-2005
• M0, X0, P0: NEVER changed. Git has NO emit, NO dispatch, NO peer primitives.

The only changes over 20 years: persistence optimization (Prs3→Prs-Full — better packfiles, partial clone) and ecosystem growth. The core structural identity is INVARIANT.

3. What Git's trajectory reveals about software evolution

3.1 The seed crystal determines the trajectory

Git's seed crystal was content-addressing (I-Full from day one). Everything that followed was CONSTRAINED by this choice:

• Immutability (M0) follows from content-addressing — you can't modify content-addressed objects without changing their identity
• History-richness (Hs-Full) follows from content-addressing — every version is a distinct object, trivially stored
• No dispatch (X0) was a DESIGN CHOICE — Git chose NOT to be a computation system
• No peer (P0) was a DESIGN CHOICE — Git uses external transport, not built-in peering

The seed crystal set the attractor. Git has been at the content-addressed immutable store attractor for 20 years.

3.2 Ecosystem evolution CAN decouple from internal evolution

Git's internal structure stopped changing in ~2006. Its ecosystem exploded from 2008-2024. This is structural evidence that ECOSYSTEM POSITION and INTERNAL STRUCTURE are INDEPENDENT axes.

A system can be internally frozen and ecosystem-dominant (Git). A system can be internally sophisticated and ecosystem-marginal (many research projects).

3.3 The layering trap visible in the trajectory

Git at (M0, X0, P0) compensates through EXTERNAL SCAFFOLDING:

• M0 (no emit): compensated by polling (git fetch), webhooks (GitHub), CI/CD triggers
• X0 (no dispatch): compensated by external scripting (git hooks, GitHub Actions)
• P0 (no peer): compensated by external hosting (GitHub, GitLab, Bitbucket)

Each piece of scaffolding IS an external system compensating for a missing primitive. GitHub IS Git's scaffolding — it provides M/X/P capabilities that Git itself doesn't have.

3.4 The speed of evolution varies by level

Higher levels evolve FASTER than lower levels. The substrate is the most stable. The ecosystem is the most dynamic. This parallels biology: DNA changes slowly (mutation rate ~10⁻⁹), organism adaptation is moderate (generations), ecosystem dynamics are fast (seasons, disturbances).

4. Comparative: computing domain epochs

Now applying the same temporal analysis to the ENTIRE digital computing domain:

4.1 Epoch 1: Mechanical/Electromechanical (pre-1945)

Hardware:    (Sw0-1-relays/vacuum tubes, Ic1-point to point, St0-1, Os0-1, Pw0, Pt1)
Computing:   (Wd1-limited, Mm1-registers, In0-hardwired, Cy0-1, Ch0-1, Pr0)
Substrate:   N/A — no software in the modern sense
Surface:     N/A
Ecosystem:   N/A

The pre-stored-program era. Machines like Colossus, ENIAC (before modification). Hardwired programs. No software as we know it.

Genesis transition pending: In0→In2 (stored program) hasn't happened yet.

4.2 Epoch 2: Stored Program Computers (1945-1955)

Hardware:    (Sw1-vacuum tubes, Ic1, St1-2-delay lines/Williams tube, Os1, Pw0, Pt1)
Computing:   (Wd2-fixed width, Mm2-linear, In2-stored program, Cy1, Ch1, Pr0-1-batch)
Substrate:   Software exists but barely — machine code, single programs
Surface:     (D1, Sh0, Ac1, Mt1, Pg0, Ch0, Pc1-cards, Pn1-printout, Bn0, Au0, Hs0, Ev0)
Ecosystem:   (Vc1-military/academic, Ex0-1, Ru0, Dv0, Ig0, Gv0, Tp0, Eo0, Io0)

GENESIS: In0→In2 (stored program). The von Neumann architecture. Computers become general-purpose. Software becomes possible.

The first software: machine code for numerical computation. No operating system, no file system, no networking. One program at a time.

4.3 Epoch 3: Languages and Operating Systems (1955-1970)

Hardware:    (Sw2-transistors→ICs, Ic2-bus, St2-3-core memory→DRAM, Os1-2, Pw1, Pt2)
Computing:   (Wd2-3, Mm2-3, In2-3-macro assemblers, Cy1-2, Ch1-2, Pr1-2-batch→timeshare)
Comp→Sub bridge: (Enc1-various formats, Hsh0, Prt1-job control, Prs1-tape→disk, Sch1-batch scheduler, Net0-1)
Substrate:   (E1-2-untyped→typed records, I0, T1-file systems emerge, M0-1, X1-fixed interpreters, P0)
Surface:     (D2, Sh1-2-COBOL records, Ac1-2-file access, Mt1-2, Pg0, Ch0-1, Pc1-terminals, Pn1-printout→CRT, Bn1, Au1, Hs0-1, Ev1)
Ecosystem:   (Vc2-commercial, Ex1, Ru1-libraries, Dv1-2, Ig1, Gv1, Tp1, Eo1, Io0)

Key transitions:

• Sw1→Sw2 (transistors → ICs): hardware density revolution
• Pr0→Pr2 (timesharing): multiple users share one computer
• First programming languages: FORTRAN (1957), COBOL (1959), LISP (1958)
• First operating systems: batch processing → timesharing (CTSS 1961, Multics 1964)

Languages are the CREATION BRIDGE — they translate human intent to machine code. This epoch is when the creation bridge becomes real.

4.4 Epoch 4: Networking and Unix (1970-1985)

Hardware:    (Sw2-3-LSI/VLSI, Ic2-3, St3-DRAM standard, Os2-PLL, Pw1-2, Pt2-3)
Computing:   (Wd3-32bit, Mm3-4-virtual memory, In3, Cy2-pipelining, Ch3-4-Ethernet/ARPANET, Pr2-3-processes+threads)
Comp→Sub:    (Enc1-2, Hsh0-1, Prt2-TCP/IP, Prs2-filesystem, Sch2-preemptive, Net2-3-client-server→early internet)
Substrate:   (E2-typed records/structs, I0-1-filenames, T2-3-Unix filesystem hierarchy, M1-2-signals/pipes, X2-shell scripts/interpreters, P1-2-users/groups)
Surface:     (D2-3, Sh2-C structs, Ac2-find/grep, Mt2-file editing, Pg1-2-signals/pipes, Ch1-2, Pc2-terminal, Pn2-CRT, Bn2-3-network, Au2-Unix permissions, Hs1, Ev1-2-scripting)
Ecosystem:   (Vc3, Ex2-email/FTP, Ru2-shared source, Dv2, Ig2-TCP/IP standard, Gv1-2, Tp2-3-ARPANET, Eo2, Io1-2)

Key transitions:

• Ch3→Ch4 (networking): ARPANET → Internet. Computers can communicate.
• Mm3→Mm4 (virtual memory): process isolation at the hardware level
• T2→T3 (Unix filesystem): the hierarchical namespace becomes the organizing principle
• Prt1→Prt2 (TCP/IP): standard network protocol — THE protocol standard

Unix's contribution: T3 (everything is a file in a tree). This is structurally the same as the entity system's T (tree namespace). Unix independently discovered that hierarchical namespaces are fundamental.

4.5 Epoch 5: Personal Computing and GUI (1985-1995)

Hardware:    (Sw3-4-microprocessors, Ic3, St3-4, Os3, Pw2-battery, Pt3-keyboard/mouse/display)
Computing:   (Wd3-32bit, Mm4, In3, Cy3-superscalar, Ch3-4, Pr3-GUI threads)
Substrate:   (E2-3-objects/documents, I0-filenames, T2-3-filesystem+registries, M2-events/messages, X2-3-OOP dispatch, P1-network shares)
Surface:     (D3, Sh2-3, Ac2-3-search, Mt2-3, Pg2-3-GUI events, Ch2, Pc3-mouse+keyboard, Pn3-GUI, Bn2, Au2, Hs1-2-undo, Ev2-spreadsheets)
Ecosystem:   (Vc3-4-commercial software, Ex2-3-retail/BBS, Ru2, Dv3-many apps, Ig2, Gv2, Tp2, Eo2, Io1-2)

Key transitions:

• Pc1→Pc3 (interactive input): mouse, keyboard, direct manipulation
• Pn1→Pn3 (GUI): graphical interface. THE user-facing revolution.
• M1→M2 (event systems): GUI frameworks introduce event-driven programming
• Ev1→Ev2 (spreadsheets): VisiCalc/Lotus/Excel. The FIRST mass-market evaluation system.

The GUI era is when Pc and Pn become prominent. Before GUI: Pc1/Pn1 (terminal). After GUI: Pc3/Pn3 (interactive graphical). This is the epoch that CREATED the external-facing surface primitives.

Spreadsheets are significant: they're Ev2 — the first widely used domain-specific evaluator. Spreadsheets prove that evaluation IS a surface primitive — millions of users use it without thinking of it as "programming."

4.6 Epoch 6: Web (1995-2005)

Hardware:    (Sw4, Ic3-4, St3-4, Os3-4, Pw2-3, Pt3-4)
Computing:   (Wd3, Mm4, In3, Cy4, Ch4-broadband, Pr3-4)
Substrate:   (E2-3-HTML/XML/JSON, I0-1-URLs, T2-3-URL hierarchy, M2-HTTP request/response, X2-3-CGI→servlets→frameworks, P2-client-server)
Surface:     (D3-4, Sh3-XML/HTML schema, Ac3-search engines, Mt2-3-forms/AJAX, Pg2-3-HTTP polling→AJAX, Ch2-3, Pc3-browser, Pn3-4-web pages, Bn3-HTTP, Au2-3-cookies→OAuth, Hs1-2, Ev2-3-server-side)
Ecosystem:   (Vc4-dotcom, Ex3-web APIs, Ru3-open source, Dv3-4-explosion, Ig3-HTTP/HTML standards, Gv2-3-W3C, Tp3-web, Eo3, Io3-web links)

Key transitions:

• Bn2→Bn3 (HTTP): web as universal boundary — every app talks HTTP
• Ig2→Ig3 (web standards): HTML, CSS, HTTP, URL — shared standards enable interoperability
• Ac2→Ac3 (search engines): Google makes EVERYTHING findable
• Tp2→Tp3 (web topology): the web IS a global distributed system

The web's contribution: Bn3 and Ig3. A STANDARD BOUNDARY (HTTP) with STANDARD INTEGRATION (HTML/CSS/URLs). This created the first true digital ecosystem — applications that discover and link to each other.

4.7 Epoch 7: Cloud and Mobile (2005-2015)

Hardware:    Client: (Sw4-phone SoC, Pt-Full-touch+camera+GPS+sensors)
             Server: (Sw4, Pr-Full-VMs/containers)
Computing:   (Wd3, Mm4, In3-4, Cy4, Ch-Full, Pr-Full-cloud elastic)
Substrate:   (E3-JSON/Protobuf, I0-1-UUID/URLs, T2-3, M3-real-time updates, X3-REST/microservices, P2-3-API auth)
Surface:     (D-Full, Sh3-4, Ac3-4-search+recommendations, Mt3-4-real-time CRUD, Pg3-4-push notifications, Ch3-eventual consistency, Pc-Full-touch+sensors, Pn-Full-mobile UI, Bn-Full-microservices, Au3-OAuth, Hs2-3, Ev3-4-analytics+ML)
Ecosystem:   (Vc-Full-app economy, Ex-Full-APIs everywhere, Ru3-4-npm/pip, Dv-Full-app stores, Ig3-4-REST APIs, Gv3-platform policies, Tp-Full-cloud global, Eo3-4, Io2-3)

Key transitions:

• Pr3→Pr-Full (virtualization → containers → serverless): elastic computing
• Pc3→Pc-Full (smartphone sensors): touch, camera, GPS, accelerometer, microphone — FULL perception
• Pn3→Pn-Full (mobile UI): rich interactive graphical interfaces everywhere
• Pg2→Pg3-4 (push notifications, WebSocket): real-time propagation standard
• Ev2→Ev3-4 (ML/analytics): evaluation becomes a major software concern

Mobile is when Pc and Pn reach Full. The smartphone IS a full perception device (every sensor type) with full presentation (high-res touch display). This epoch COMPLETED the external surface.

Cloud is when Pr reaches Full. Elastic computing means infinite apparent resources. Bn reaches Full (microservices — everything is a boundary). The infrastructure becomes invisible.

4.8 Epoch 8: AI and Current (2015-present)

Hardware:    (Sw4-GPU/TPU clusters, St3-HBM, specialized for Ev)
Computing:   (In4-tensor ops, Pr-Full-distributed training)
Substrate:   (E3-4-typed APIs+ML models, I0-1, T2-3, M3-4-real-time+streaming, X3-4-microservices+serverless, P3-API gateways+service mesh)
Surface:     (D-Full, Sh4, Ac-Full-search+recommendation+RAG, Mt3-4, Pg-Full-streaming+events, Ch3-4, Pc-Full, Pn-Full, Bn-Full, Au3-4, Hs3, Ev-Full-LLM/ML everywhere)
Ecosystem:   (Vc-Full, Ex-Full, Ru-Full, Dv-Full, Ig-Full, Gv2-3-AI unregulated, Tp-Full, Eo-Full-fastest epoch, Io3)

Key transitions:

• Ev3→Ev-Full: AI/ML becomes pervasive. Evaluation IS the current frontier.
• Hardware specializes FOR Ev: GPUs, TPUs, AI accelerators. Hardware follows software's needs.
• Eo3→Eo-Full: fastest ecosystem evolution in history — framework churn measured in months

The AI epoch is Ev-dominated. The structural transition: evaluation went from ambient (just run code) to EXPLICIT and DOMINANT (design ML models, train, deploy, serve). This is the epoch that proves Ev is a real surface primitive — the entire industry is reorganizing around it.

5. The temporal pattern across epochs

5.1 Which primitives moved when

5.2 The build-up order matches the Hasse walk

The historical order of primitive advancement roughly follows the entity system's primary Hasse path:

Wd,Mm,In (1945) → Cy (1980s) → Ch,Pr (1970s-80s) → E,T (1960s-80s) → M (1980s) → X (gradual) → P (gradual) → Pc,Pn (1980s-2010s) → Ev (2015+)

This roughly corresponds to: computing first, then data, then interaction, then evaluation. The BUILD-UP SEQUENCE we derived analytically matches the HISTORICAL SEQUENCE of digital computing development.

5.3 Evolution speed by level (confirmed across the domain)

Lower levels evolve SLOWER than higher levels. The substrate is the most stable. The ecosystem is the most dynamic. This IS the same pattern as biology — DNA (substrate) changes slowly, ecology (ecosystem) changes fast.

6. What the temporal analysis reveals

6.1 Software systems have a FROZEN SUBSTRATE after initial design

Git's substrate position (E-Full, I-Full, T2, M0, X0, P0) was set in April 2005 and NEVER CHANGED. The substrate is the seed crystal — once set, it constrains everything above.

This is structurally similar to how a species' genome defines its developmental potential. E. coli's substrate position was set ~4 Gya and has been remarkably stable since. The substrate IS identity.

6.2 Evolution concentrates at the ecosystem level

Git's internal structure froze in ~2006. Its ecosystem evolved continuously from 2008-present. The MOST DYNAMIC level is the ecosystem. This holds for the entire computing domain — the ecosystem (Epoch 7-8) is changing fastest.

6.3 The build-up sequence is historical, not just analytical

The analytical build-up (computing → data → interaction → evaluation) MATCHES the actual historical sequence. The Hasse walk we derived from dependency analysis predicts the order of technological development.

6.4 Hardware specializes for the current surface frontier

In Epoch 8, hardware is specializing for Evaluation (GPUs, TPUs, AI accelerators). Hardware follows the current surface frontier. When the frontier was Pn (GUI era), hardware developed GPUs for rendering. When the frontier shifted to Ev (AI era), hardware shifted to tensor processors.

The surface pulls the hardware. The hardware enables the surface. A co-evolutionary loop.

Summary

Git's trajectory

• Seed crystal: content addressing (I-Full, April 2005)
• Substrate frozen after 2 weeks
• Surface frozen after ~1 year
• Ecosystem evolved continuously for 20 years
• GitHub = scaffolding for missing M/X/P primitives

Digital computing epochs

8 epochs from mechanical (pre-1945) to AI (present). Build-up sequence matches analytical Hasse walk. Lower levels evolve slower than higher levels. Current frontier: Evaluation (Ev → Full in Epoch 8).

Temporal dynamics

• Substrate is seed crystal — set once, rarely changes
• Ecosystem is most dynamic — changes continuously
• Evolution speed increases with level height
• Hardware co-evolves with the current surface frontier

Referenced by the model

Cited as a source by 10 model records (browse the model census):

• git — manifestation entity/sc3/git
• github — manifestation entity/sc3/github
• git-evolution — trajectory entity/sc3/git
• github-evolution — trajectory entity/sc3/github
• postgres-evolution — trajectory entity/sc3/postgres
• git-evolution-calibrated — rate entity/sc2
• git-2005-initial-to-vcs — population_context entity/sc2/git
• git-2005jul-to-2006-distributed — population_context entity/sc2/git
• git-2006-to-2010-github-tipping — population_context entity/sc2/git
• git-2010-to-2024-standardization — population_context entity/sc2/git