Framework Drift and Conceptual Decay: Why Knowledge Systems Lose Meaning Over Time

Last Updated June 9, 2026

Frameworks can decay. A framework may begin as a clear structure for organizing knowledge, but over time its categories can blur, its terms can shift, its assumptions can become hidden, its examples can grow stale, and its original purpose can be forgotten. When that happens, the framework may still look organized while no longer helping people think clearly.

Framework Drift and Conceptual Decay examines what happens when frameworks lose precision, coherence, context, and governance over time. It explains how concepts drift through reuse, copying, simplification, audience expansion, AI-assisted production, institutional habit, weak metadata, stale sources, and missing review cycles. The article argues that frameworks must be maintained as living knowledge structures, not treated as permanent templates.

This article explains why frameworks can weaken even when they remain visually intact. It examines semantic drift, category creep, stale evidence, template overuse, broken context, governance neglect, AI-amplified repetition, institutional inertia, and maintenance failure. It also includes computational workflows for auditing drift risk, conceptual clarity, evidence currency, metadata consistency, link health, reuse pressure, and review priority.

Why Framework Drift Matters

Framework drift matters because frameworks shape how people think. They define categories, relationships, sequences, evidence expectations, audience pathways, and decision logic. When a framework drifts, the knowledge system may continue to look structured while its meaning becomes weaker, broader, vaguer, or misaligned with its original purpose.

Drift is especially risky in large content systems. A definition may be copied across many articles. A template may be reused in contexts where it no longer fits. A taxonomy may grow through additions without pruning. A framework may become popular enough that people stop asking what it was designed to do. As reuse increases, small conceptual changes can spread widely.

Framework drift is not always obvious. It often appears as mild inconsistency: slightly different definitions, overlapping categories, weak examples, generic wording, unclear metadata, stale sources, or article-map paths that no longer match the topic. Over time, those small inconsistencies create conceptual decay.

Framework drift matters because meaning can decay while structure remains visible.

Back to top ↑

What Framework Drift Is

Framework drift is the gradual movement of a framework away from its original purpose, boundaries, definitions, evidence base, audience use, or governance logic. Drift can happen through repeated reuse, adaptation, simplification, copying, platform migration, AI-assisted drafting, changing terminology, or the addition of new content without review.

Drift is not always bad. Some frameworks must evolve as knowledge changes. The problem is unmanaged drift: change without awareness, record, review, or correction. A framework can adapt responsibly when changes are documented. It decays when changes accumulate invisibly.

The goal is not to freeze frameworks. The goal is to make change visible enough to govern.

Back to top ↑

What Conceptual Decay Means

Conceptual decay occurs when a framework’s meaning weakens over time. A concept may become too vague, too broad, too fashionable, too detached from evidence, or too overloaded with unrelated uses. The result is a structure that still has familiar language but no longer supports precise reasoning.

Decay often begins when a concept becomes successful. A useful framework is copied, shortened, simplified, adapted, and applied to new contexts. As it travels, its original assumptions may disappear. Its limits may be removed. Its evidence may be generalized. Its categories may become slogans. Its use may become ritual.

Conceptual decay is not a formatting problem. It is a meaning problem.

Back to top ↑

How Frameworks Drift

Frameworks drift through many small changes. A title changes but the slug does not. A definition is rewritten for a new audience. A planned article becomes a published article without updating the map. A source is reused for a slightly different claim. A framework is applied to a new domain without context notes. A template is copied without asking whether it fits.

Drift also happens through omission. Editors may update a paragraph but not the metadata. They may add a link but not revise the article map. They may change a framework’s scope but not its examples. They may publish a repository but not run tests later. The knowledge system becomes misaligned because its parts no longer update together.

Framework drift usually begins as coordination failure.

Back to top ↑

Semantic Drift and Term Weakening

Semantic drift occurs when the meaning of a term changes through repeated use. A term may begin with a precise meaning and gradually become a general label. “Framework,” “strategy,” “systems,” “governance,” “resilience,” “evidence,” “architecture,” and “AI-ready” can all weaken if they are used without definition, scope, or examples.

Term weakening is especially risky in knowledge systems because readers rely on repeated terms to build understanding. If the same term means different things across articles, the system becomes harder to navigate. A glossary, definition table, and article-specific scope note can reduce this risk.

Conceptual maintenance begins with language maintenance.

Back to top ↑

Category Creep and Boundary Loss

Category creep occurs when a framework’s categories expand beyond their intended boundaries. A category that once described a specific kind of content begins to include loosely related topics. A tag becomes a catch-all. A section heading begins to hold unrelated ideas. A framework that was designed for one level of analysis is applied to another.

Boundary loss weakens a framework because categories stop helping users decide what belongs where. The framework becomes more inclusive but less useful. In a content system, category creep can make article maps harder to scan, tags harder to interpret, and related links less meaningful.

A category that includes everything eventually explains very little.

Back to top ↑

Context Collapse and Reuse Failure

Context collapse occurs when a framework is reused without the conditions that made it meaningful. A model created for education may be applied to public reasoning. A marketing framework may be used for civic communication. A governance checklist may be copied across technical, ethical, and policy topics without adaptation.

Reusable frameworks need context preservation. They should carry information about origin, purpose, intended audience, evidence base, domain assumptions, limits, and adaptation rules. Without that context, reuse can become distortion.

Reusable frameworks need portable context, not only portable structure.

Back to top ↑

Evidence Decay and Source Weakening

Evidence decay occurs when a framework’s claims remain in place after the supporting evidence weakens, ages, changes, or becomes disconnected from the article’s argument. Evidence decay can happen when a source link breaks, a source becomes outdated, a claim is expanded beyond the source, or a citation is copied into a new context without checking whether it still applies.

Frameworks can hide evidence decay because structure can make claims feel more stable than they are. A table, model, score, or taxonomy may look authoritative even when the sources behind it are weak. That is why evidence review is part of framework maintenance.

A framework remains trustworthy only when its evidence remains inspectable.

Back to top ↑

Template Fatigue and Mechanical Repetition

Template fatigue occurs when repeated structure stops helping users and starts making content feel mechanical. Templates are useful for consistency, but they can also encourage surface completion. A page may contain the expected sections, tables, examples, code, repository link, and references while still failing to clarify the topic.

Mechanical repetition is a form of conceptual decay. It weakens the relationship between structure and meaning. The framework appears stable, but the thinking inside the structure becomes generic. Editorial maintenance should check whether the template still fits the article’s purpose or whether the article needs a different shape.

Templates should support meaning, not replace it.

Back to top ↑

AI-Amplified Drift

AI-assisted content systems can amplify framework drift. When models generate or revise content using existing patterns, they may reproduce inconsistent definitions, stale assumptions, generic sections, weak evidence habits, or outdated taxonomies. If the underlying framework has drifted, AI can scale that drift quickly.

This does not mean AI-assisted workflows should be avoided. It means they need stronger structure. AI-assisted framework work should use controlled definitions, article maps, metadata schemas, evidence requirements, validation checks, review queues, and human editorial judgment. AI can help maintain frameworks, but it can also multiply decay when governance is weak.

AI-assisted framework design needs drift controls before scale becomes a liability.

Back to top ↑

Institutional Inertia and Framework Lock-In

Institutional inertia occurs when a framework remains in use because it is familiar, embedded, or convenient, not because it still fits the problem. A taxonomy may remain because many pages depend on it. A template may remain because authors know it. A model may remain because it appears in dashboards, training materials, or old strategy documents.

Framework lock-in can make decay difficult to repair. The more a framework is embedded in content, repositories, links, metadata, and workflows, the harder it becomes to change. That is why governance should include retirement rules, versioning, and decision records before drift becomes severe.

Frameworks should be stable enough to guide knowledge, but flexible enough to remain true to it.

Back to top ↑

Signals That a Framework Is Decaying

Framework decay often leaves visible signals. These signals should be treated as review triggers. They do not always mean the framework should be removed, but they do mean the framework needs attention.

Drift signals are maintenance invitations.

Back to top ↑

Preventing Framework Drift

Framework drift can be reduced through deliberate design. A framework should include purpose, scope, definition, assumptions, evidence status, review date, owner, related articles, repository path, version, and retirement rules. These governance elements help the framework carry its meaning as it is reused.

Prevention is easier than repair. Once drift spreads across many articles, it becomes harder to correct. A content system should therefore treat maintenance metadata as part of the framework, not as optional administrative detail.

Framework drift prevention depends on making meaning portable and reviewable.

Back to top ↑

Repairing Conceptual Decay

Repairing conceptual decay means restoring clarity, boundaries, evidence, context, and governance. The repair process may involve rewriting definitions, splitting categories, updating examples, replacing sources, revising templates, rebuilding article maps, repairing links, updating repositories, or retiring weak pages.

Repair should not be limited to the visible article. If a framework has drifted, the repair must follow the dependencies: related articles, metadata, tags, internal links, repository outputs, source lists, image metadata, and article-map sequence. Otherwise, the article may be corrected while the wider system remains misaligned.

Conceptual repair should restore both meaning and maintenance.

Back to top ↑

Governance for Drift and Decay

Framework drift needs governance because decay is rarely fixed by one edit. Governance defines how drift is detected, who reviews it, what evidence is checked, what dependencies are updated, what changes are recorded, and when a framework should be retired.

A drift governance system should include review cycles, drift indicators, concept owners, evidence status, taxonomy maintenance, link audits, repository checks, and decision records. It should also include a way to prioritize repairs. A framework used across many articles has higher maintenance priority than a minor local model.

Governance keeps conceptual change from becoming conceptual decay.

Back to top ↑

Relationship to Framework Governance, Limits, Scaling Knowledge, and AI-Assisted Design

Framework drift connects several late-series articles in the Content Frameworks map. Framework governance explains how maintenance should happen. The limits of framework thinking explains why frameworks should not be treated as reality. Scaling knowledge explains why reuse increases maintenance responsibility. AI-assisted framework design explains why assisted production can accelerate both structure and drift.

Framework drift is the failure mode that governance, limits thinking, and maintenance are designed to prevent.

Back to top ↑

How Drift Awareness Supports Content Frameworks

Drift awareness supports content frameworks by making maintenance part of the design. A content framework should not only define how articles are structured; it should define how their meaning will remain stable enough to be useful and flexible enough to evolve responsibly.

For a Content Catalyst-style knowledge system, drift awareness can be embedded in metadata, repository outputs, article maps, editorial review checklists, source-review fields, glossary records, internal-link audits, and Canvas-ready governance queues. Drift-aware systems make it easier to know when a framework should be updated, merged, split, archived, or retired.

A drift-aware content framework expects change and designs for it.

Back to top ↑

Ethics, Memory, and Editorial Responsibility

Framework drift is an ethical issue because decayed concepts can mislead readers. A vague framework may create false clarity. A stale framework may preserve outdated assumptions. A drifting taxonomy may make some topics harder to find. An AI-amplified framework may repeat weak claims at scale. A neglected article map may send readers through outdated pathways.

Editorial responsibility means caring for meaning after publication. It means preserving context, recording changes, acknowledging uncertainty, correcting drift, and retiring frameworks that no longer help. It also means recognizing that knowledge systems influence what readers see, trust, and reuse.

• Conceptual integrity: Terms should remain clear enough to support reasoning.
• Context preservation: Reuse should not strip away purpose, evidence, audience, or limits.
• Evidence accountability: Claims should remain connected to sources and review status.
• Taxonomy responsibility: Categories should be reviewed for exclusion, overload, and distortion.
• Correction paths: Readers and editors should have ways to flag drift or decay.
• Retirement ethics: Weak frameworks should not remain active merely because they are familiar.
• AI governance: Assisted production should not scale stale assumptions or weak definitions.
• Institutional memory: Decision records should explain why frameworks changed.

Maintaining frameworks is part of maintaining trust.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

Framework drift can be audited computationally. Scores cannot determine meaning by themselves, but they can help identify where review is needed. A drift audit might evaluate conceptual clarity, definition consistency, evidence currency, boundary clarity, metadata consistency, link health, reuse pressure, repository alignment, and governance maturity.

A conceptual integrity score can average several clarity and maintenance dimensions:

A drift risk score can combine low conceptual integrity, high reuse pressure, stale evidence, high dependency complexity, and weak repository alignment:

A repair priority score can combine drift risk and audience impact:

Computation can make drift visible. Editorial judgment decides how drift should be repaired.

Back to top ↑

Python Workflow: Framework Drift Audit

The Python workflow below evaluates framework drift by definition consistency, boundary clarity, evidence currency, metadata consistency, link health, governance maturity, reuse pressure, stale evidence risk, dependency complexity, platform alignment, audience impact, and status. The companion repository version extends this into a Catalyst Canvas-ready module with schemas, package-style Python, tests, JSON exports, Canvas cards, shared contracts, and governance queues.

# framework_drift_audit.py
# Dependency-light workflow for auditing framework drift and conceptual decay.

from __future__ import annotations

from dataclasses import dataclass
from pathlib import Path
import csv
from statistics import mean

ARTICLE_ROOT = Path(__file__).resolve().parents[1]
TABLES = ARTICLE_ROOT / "outputs" / "tables"


@dataclass
class FrameworkDriftItem:
    item: str
    item_type: str
    description: str
    definition_consistency: float
    boundary_clarity: float
    evidence_currency: float
    metadata_consistency: float
    link_health: float
    governance_maturity: float
    reuse_pressure: float
    stale_evidence_risk: float
    dependency_complexity: float
    platform_alignment: float
    audience_impact: float
    owner: str
    status: str

    def conceptual_integrity(self) -> float:
        return mean([
            self.definition_consistency,
            self.boundary_clarity,
            self.evidence_currency,
            self.metadata_consistency,
            self.link_health,
            self.governance_maturity,
        ])

    def drift_risk(self) -> float:
        return min(
            1.0,
            (1 - self.conceptual_integrity()) * 0.32
            + self.reuse_pressure * 0.20
            + self.stale_evidence_risk * 0.18
            + self.dependency_complexity * 0.16
            + (1 - self.platform_alignment) * 0.14,
        )

    def repair_priority_score(self) -> float:
        return min(
            1.0,
            self.drift_risk() * 0.70
            + self.audience_impact * 0.30,
        )

    def repair_priority(self) -> str:
        if self.status == "revise" or self.repair_priority_score() >= 0.55:
            return "high"
        if self.status == "review" or self.repair_priority_score() >= 0.40:
            return "medium"
        return "standard"


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        raise ValueError(f"No rows to write: {path}")
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0].keys()))
        writer.writeheader()
        writer.writerows(rows)


def main() -> None:
    items = [
        FrameworkDriftItem("Framework definition", "definition", "Core definition of framework across the Content Frameworks series.", 0.78, 0.74, 0.72, 0.80, 0.76, 0.74, 0.62, 0.28, 0.42, 0.72, 0.84, "editorial", "active"),
        FrameworkDriftItem("Content governance taxonomy", "taxonomy", "Tags categories and article types used for governance and discovery.", 0.70, 0.68, 0.66, 0.72, 0.74, 0.70, 0.58, 0.32, 0.50, 0.68, 0.78, "governance", "review"),
        FrameworkDriftItem("Legacy message framework", "framework", "Older message model reused across multiple pages without current scope notes.", 0.46, 0.42, 0.38, 0.44, 0.48, 0.36, 0.82, 0.70, 0.68, 0.40, 0.66, "editorial", "revise"),
        FrameworkDriftItem("Canvas-ready repository pattern", "repository", "Reusable repository structure with schemas tests outputs and governance queues.", 0.80, 0.78, 0.74, 0.84, 0.76, 0.78, 0.64, 0.24, 0.52, 0.86, 0.72, "platform", "active"),
        FrameworkDriftItem("Article map footer sequence", "navigation", "Series footer path and article map sequence across late-series governance pages.", 0.76, 0.78, 0.70, 0.80, 0.88, 0.76, 0.56, 0.22, 0.46, 0.74, 0.80, "editorial", "active"),
    ]

    rows = []

    for item in items:
        rows.append({
            "item": item.item,
            "item_type": item.item_type,
            "description": item.description,
            "definition_consistency": item.definition_consistency,
            "boundary_clarity": item.boundary_clarity,
            "evidence_currency": item.evidence_currency,
            "metadata_consistency": item.metadata_consistency,
            "link_health": item.link_health,
            "governance_maturity": item.governance_maturity,
            "reuse_pressure": item.reuse_pressure,
            "stale_evidence_risk": item.stale_evidence_risk,
            "dependency_complexity": item.dependency_complexity,
            "platform_alignment": item.platform_alignment,
            "audience_impact": item.audience_impact,
            "conceptual_integrity": round(item.conceptual_integrity(), 3),
            "drift_risk": round(item.drift_risk(), 3),
            "repair_priority_score": round(item.repair_priority_score(), 3),
            "owner": item.owner,
            "status": item.status,
            "repair_priority": item.repair_priority(),
        })

    rows = sorted(rows, key=lambda row: row["repair_priority_score"], reverse=True)
    write_csv(TABLES / "framework_drift_audit.csv", rows)

    repair_queue = [
        row for row in rows
        if row["repair_priority"] != "standard"
    ]

    write_csv(TABLES / "framework_drift_repair_queue.csv", repair_queue)

    print("Framework drift audit complete.")


if __name__ == "__main__":
    main()

This workflow helps identify where a framework’s meaning is weakening, where reuse is increasing drift pressure, and where repair should be prioritized.

Back to top ↑

R Workflow: Framework Drift Diagnostics

The R workflow below creates a framework drift dataset, calculates conceptual integrity, drift risk, repair priority score, and repair status, then exports summary tables and base R plots. It is intentionally portable and uses only base R.

# framework_drift_report.R
# Base R workflow for framework drift and conceptual decay diagnostics.

args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE)

if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- getwd()
}

setwd(article_root)

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")

if (!dir.exists(tables_dir)) {
  dir.create(tables_dir, recursive = TRUE)
}

if (!dir.exists(figures_dir)) {
  dir.create(figures_dir, recursive = TRUE)
}

items <- data.frame(
  item = c(
    "Framework definition",
    "Content governance taxonomy",
    "Legacy message framework",
    "Canvas-ready repository pattern",
    "Article map footer sequence"
  ),
  item_type = c(
    "definition",
    "taxonomy",
    "framework",
    "repository",
    "navigation"
  ),
  definition_consistency = c(0.78, 0.70, 0.46, 0.80, 0.76),
  boundary_clarity = c(0.74, 0.68, 0.42, 0.78, 0.78),
  evidence_currency = c(0.72, 0.66, 0.38, 0.74, 0.70),
  metadata_consistency = c(0.80, 0.72, 0.44, 0.84, 0.80),
  link_health = c(0.76, 0.74, 0.48, 0.76, 0.88),
  governance_maturity = c(0.74, 0.70, 0.36, 0.78, 0.76),
  reuse_pressure = c(0.62, 0.58, 0.82, 0.64, 0.56),
  stale_evidence_risk = c(0.28, 0.32, 0.70, 0.24, 0.22),
  dependency_complexity = c(0.42, 0.50, 0.68, 0.52, 0.46),
  platform_alignment = c(0.72, 0.68, 0.40, 0.86, 0.74),
  audience_impact = c(0.84, 0.78, 0.66, 0.72, 0.80),
  owner = c("editorial", "governance", "editorial", "platform", "editorial"),
  status = c("active", "review", "revise", "active", "active"),
  stringsAsFactors = FALSE
)

items$conceptual_integrity <- rowMeans(items[, c(
  "definition_consistency",
  "boundary_clarity",
  "evidence_currency",
  "metadata_consistency",
  "link_health",
  "governance_maturity"
)])

items$drift_risk <- pmin(
  1,
  (1 - items$conceptual_integrity) * 0.32 +
    items$reuse_pressure * 0.20 +
    items$stale_evidence_risk * 0.18 +
    items$dependency_complexity * 0.16 +
    (1 - items$platform_alignment) * 0.14
)

items$repair_priority_score <- pmin(
  1,
  items$drift_risk * 0.70 +
    items$audience_impact * 0.30
)

items$repair_priority <- ifelse(
  items$status == "revise" | items$repair_priority_score >= 0.55,
  "high",
  ifelse(
    items$status == "review" | items$repair_priority_score >= 0.40,
    "medium",
    "standard"
  )
)

items <- items[order(items$repair_priority_score, decreasing = TRUE), ]

write.csv(
  items,
  file.path(tables_dir, "framework_drift_summary.csv"),
  row.names = FALSE
)

repair_queue <- items[items$repair_priority != "standard", ]

write.csv(
  repair_queue,
  file.path(tables_dir, "framework_drift_repair_queue.csv"),
  row.names = FALSE
)

png(file.path(figures_dir, "framework_drift_risk.png"), width = 1200, height = 700)
barplot(
  items$drift_risk,
  names.arg = items$item,
  las = 2,
  ylab = "Drift risk",
  main = "Framework Drift Risk"
)
grid()
dev.off()

png(file.path(figures_dir, "framework_conceptual_integrity.png"), width = 1000, height = 700)
barplot(
  items$conceptual_integrity,
  names.arg = items$item,
  las = 2,
  ylab = "Conceptual integrity",
  main = "Framework Conceptual Integrity"
)
grid()
dev.off()

print(items[, c("item", "item_type", "conceptual_integrity", "drift_risk", "repair_priority_score", "repair_priority")])

This workflow turns framework drift into an auditable maintenance artifact. It helps identify weak definitions, boundary loss, stale evidence, metadata inconsistency, link problems, governance gaps, reuse pressure, and high-priority repair needs.

Back to top ↑

GitHub Repository

The companion repository for this article supports framework drift and conceptual decay as a Catalyst Canvas-ready content-framework module. It includes definition consistency, boundary clarity, evidence currency, metadata consistency, link health, governance maturity, reuse pressure, stale evidence risk, dependency complexity, platform alignment, audience impact, conceptual-integrity scoring, drift-risk scoring, JSON schemas, package-style Python, tests, Canvas card outputs, markdown repair queues, synthetic datasets, SQL views, documentation, and multi-language scaffolds for responsible conceptual maintenance.

articles/framework-drift-and-conceptual-decay/
├── canvas/
│   ├── canvas_manifest.json
│   ├── input_schema.json
│   ├── output_schema.json
│   ├── canvas_cards.json
│   └── governance_queue.json
├── html/
├── css/
├── php/
├── java/
├── python/
│   ├── framework_drift_canvas/
│   │   ├── __init__.py
│   │   ├── __main__.py
│   │   ├── cli.py
│   │   ├── models.py
│   │   ├── scoring.py
│   │   ├── validation.py
│   │   ├── governance.py
│   │   └── exporters.py
│   ├── tests/
│   │   └── test_framework_drift_canvas.py
│   └── run_framework_drift_canvas_audit.py
├── r/
│   ├── framework_drift_report.R
│   └── run_all_framework_drift_workflows.R
├── sql/
│   ├── canvas_schema.sql
│   └── canvas_queries.sql
├── docs/
├── data/
├── outputs/
│   ├── figures/
│   ├── json/
│   ├── markdown/
│   └── tables/
├── notebooks/
├── shared/
└── README.md

Back to top ↑

Back to top ↑

Back to top ↑

Why Frameworks Need Maintenance to Keep Meaning

Frameworks need maintenance because meaning changes. Terms shift. Categories expand. Sources age. Examples become stale. Links break. Repositories drift. Audiences change. AI-assisted systems repeat patterns. Institutions preserve old structures because they are familiar. Without review, frameworks can lose the precision that made them useful.

Framework drift is not a reason to abandon frameworks. It is a reason to govern them. A framework that can be reviewed, revised, repaired, merged, archived, or retired is stronger than one that appears stable but cannot be questioned. Conceptual maintenance keeps structure connected to meaning.

The most durable content frameworks are not static. They are maintained. They preserve definitions, boundaries, evidence, context, links, repositories, and decision records. They evolve without losing their purpose. They scale without losing their meaning.

Back to top ↑

Related Articles

• Framework Governance and Editorial Maintenance
• The Limits of Framework Thinking
• Scaling Knowledge Through Frameworks
• Content Audits and Framework Governance
• Editorial Metadata and Content Systems
• AI-Assisted Framework Design

Further Reading

• OECD (2000) Knowledge Management in the Learning Society. Paris: OECD Publishing. Available at: https://www.oecd.org/en/publications/2000/02/knowledge-management-in-the-learning-society_g1gh266b.html
• OECD (n.d.) Knowledge Management. Paris: OECD Publishing. Available at: https://www.oecd.org/en/publications/serials/knowledge-management_g1gha303.html
• World Bank (2016) Becoming a Knowledge-Sharing Organization: A Handbook for Scaling Up Solutions through Knowledge Capturing and Sharing. Washington, DC: World Bank. Available at: https://openknowledge.worldbank.org/entities/publication/1b0767df-8894-58f2-a1ed-e2c744c27ef3
• World Bank (2016) Capturing Solutions for Learning and Scaling Up. Washington, DC: World Bank. Available at: https://openknowledge.worldbank.org/entities/publication/cdbc261c-24ca-52c2-bb15-41e9d67dc3a4
• National Academies of Sciences, Engineering, and Medicine (2017) Communicating Science Effectively: A Research Agenda. Washington, DC: The National Academies Press. Available at: https://www.nationalacademies.org/publications/23674
• UNESCO (2019) Recommendation on Open Educational Resources (OER). Paris: UNESCO. Available at: https://www.unesco.org/en/legal-affairs/recommendation-open-educational-resources-oer
• Nonaka, I. and Takeuchi, H. (1995) The Knowledge-Creating Company: How Japanese Companies Create the Dynamics of Innovation. New York: Oxford University Press.
• Davenport, T.H. and Prusak, L. (1998) Working Knowledge: How Organizations Manage What They Know. Boston, MA: Harvard Business School Press.
• Wenger, E. (1998) Communities of Practice: Learning, Meaning, and Identity. Cambridge: Cambridge University Press.
• Brown, J.S. and Duguid, P. (2000) The Social Life of Information. Boston, MA: Harvard Business School Press.
• Bowker, G.C. and Star, S.L. (1999) Sorting Things Out: Classification and Its Consequences. Cambridge, MA: MIT Press.
• Morville, P. and Rosenfeld, L. (2006) Information Architecture for the World Wide Web. 3rd edn. Sebastopol, CA: O’Reilly Media.
• Rosenfeld, L., Morville, P. and Arango, J. (2015) Information Architecture: For the Web and Beyond. 4th edn. Sebastopol, CA: O’Reilly Media.
• Krippendorff, K. (2013) Content Analysis: An Introduction to Its Methodology. 3rd edn. Thousand Oaks, CA: SAGE.

References

• OECD (2000) Knowledge Management in the Learning Society. Paris: OECD Publishing. Available at: https://www.oecd.org/en/publications/2000/02/knowledge-management-in-the-learning-society_g1gh266b.html
• OECD (n.d.) Knowledge Management. Paris: OECD Publishing. Available at: https://www.oecd.org/en/publications/serials/knowledge-management_g1gha303.html
• World Bank (2016) Becoming a Knowledge-Sharing Organization: A Handbook for Scaling Up Solutions through Knowledge Capturing and Sharing. Washington, DC: World Bank. Available at: https://openknowledge.worldbank.org/entities/publication/1b0767df-8894-58f2-a1ed-e2c744c27ef3
• World Bank (2016) Capturing Solutions for Learning and Scaling Up. Washington, DC: World Bank. Available at: https://openknowledge.worldbank.org/entities/publication/cdbc261c-24ca-52c2-bb15-41e9d67dc3a4
• National Academies of Sciences, Engineering, and Medicine (2017) Communicating Science Effectively: A Research Agenda. Washington, DC: The National Academies Press. Available at: https://www.nationalacademies.org/publications/23674
• UNESCO (2019) Recommendation on Open Educational Resources (OER). Paris: UNESCO. Available at: https://www.unesco.org/en/legal-affairs/recommendation-open-educational-resources-oer
• Nonaka, I. and Takeuchi, H. (1995) The Knowledge-Creating Company: How Japanese Companies Create the Dynamics of Innovation. New York: Oxford University Press.
• Davenport, T.H. and Prusak, L. (1998) Working Knowledge: How Organizations Manage What They Know. Boston, MA: Harvard Business School Press.
• Wenger, E. (1998) Communities of Practice: Learning, Meaning, and Identity. Cambridge: Cambridge University Press.
• Brown, J.S. and Duguid, P. (2000) The Social Life of Information. Boston, MA: Harvard Business School Press.
• Bowker, G.C. and Star, S.L. (1999) Sorting Things Out: Classification and Its Consequences. Cambridge, MA: MIT Press.
• Morville, P. and Rosenfeld, L. (2006) Information Architecture for the World Wide Web. 3rd edn. Sebastopol, CA: O’Reilly Media.
• Rosenfeld, L., Morville, P. and Arango, J. (2015) Information Architecture: For the Web and Beyond. 4th edn. Sebastopol, CA: O’Reilly Media.
• Krippendorff, K. (2013) Content Analysis: An Introduction to Its Methodology. 3rd edn. Thousand Oaks, CA: SAGE.

Back to top ↑