Framework Governance and Editorial Maintenance

Last Updated June 9, 2026

Frameworks do not maintain themselves. A content framework may begin as a strong structure for organizing knowledge, but without governance it can drift, decay, duplicate itself, lose evidence discipline, develop broken links, confuse audiences, and preserve outdated assumptions. Editorial maintenance is what keeps a framework useful after publication.

Framework Governance and Editorial Maintenance examines how content frameworks should be reviewed, updated, corrected, consolidated, retired, and improved over time. It focuses on ownership, review cycles, metadata quality, source review, evidence status, internal-link health, taxonomy maintenance, repository upkeep, version control, governance queues, editorial decision records, and accountability. The article treats governance not as bureaucracy, but as the infrastructure that keeps knowledge systems trustworthy, coherent, reusable, and alive.

This article explains how to maintain content frameworks as living systems. It shows how editorial teams can track framework ownership, review cycles, source quality, claim freshness, link health, metadata completeness, taxonomy drift, article-map coherence, repository alignment, and retirement decisions. It also includes computational workflows for auditing governance maturity, maintenance risk, evidence status, review priority, and editorial accountability.

Why Framework Governance Matters

Framework governance matters because knowledge systems change after publication. Evidence changes. Terms shift. Links break. Article maps expand. New articles overlap with old ones. Repository outputs fall behind article logic. Metadata becomes inconsistent. Audiences encounter outdated pathways. A framework that once clarified a topic can eventually make the system harder to maintain.

Governance is the practice of keeping a framework aligned with its purpose, evidence, audience, structure, and ethical responsibilities. It gives editors a way to decide what should be updated, what should be reviewed, what should be merged, what should be retired, and who is responsible for the decision.

Without governance, scale becomes a risk. The more a framework is reused, the more damage it can do if its assumptions become stale or its evidence weakens. A single outdated definition can spread across dozens of pages. A broken article map can misdirect readers. A neglected repository can make reproducible workflows unreliable.

Governance keeps frameworks from becoming abandoned structures.

Back to top ↑

What Framework Governance Means

Framework governance means defining the rules, responsibilities, review practices, and decision records that keep a framework reliable over time. It includes editorial review, evidence review, metadata review, link review, taxonomy review, repository review, accessibility review, and ethical review.

Governance does not mean every article must be constantly rewritten. It means every framework has a maintenance path. Some content may need frequent updates because the topic changes quickly. Other content may remain stable but still need periodic checks for clarity, links, references, and relationship to the wider knowledge system.

Framework governance turns maintenance from a vague responsibility into a repeatable practice.

Back to top ↑

Editorial Maintenance as Knowledge Infrastructure

Editorial maintenance is often treated as cleanup work, but in a knowledge system it is infrastructure. Maintenance determines whether published knowledge remains usable. It protects the integrity of article maps, evidence structures, learning pathways, public explanations, and repository companions.

A serious knowledge platform should treat maintenance as part of publication, not as a later emergency. Every framework should have enough structure to be reviewed. Every article should have enough metadata to be found. Every source-heavy claim should have enough context to be checked. Every repository companion should have enough tests to detect obvious breakage.

Editorial maintenance is how a knowledge system keeps its promises after publication.

Back to top ↑

Ownership and Accountability

Every governed framework needs an owner. Ownership does not mean one person controls the framework forever. It means someone is responsible for ensuring that review happens, problems are triaged, decisions are recorded, and updates are made or assigned. Without ownership, maintenance depends on memory and goodwill.

Ownership can be editorial, research, platform, governance, education, or domain-specific. A framework may also have multiple responsible roles. For example, an editor may own the article, a researcher may own evidence review, and a platform owner may own repository outputs.

Accountability begins when a framework has a named maintenance path.

Back to top ↑

Review Cycles and Update Triggers

Review cycles keep frameworks from becoming stale by default. Some reviews should happen on a schedule. Others should be triggered by change: new evidence, broken links, changed terminology, new article-map structure, platform migration, repository errors, policy changes, audience feedback, or a major revision to a related framework.

Not all content needs the same review frequency. Foundational concepts may need slower review. Current data, policy, regulation, technology, standards, or AI-related topics may need more frequent review. The review cycle should match the volatility and importance of the framework.

Review cycles make maintenance predictable. Update triggers make it responsive.

Back to top ↑

Metadata Maintenance

Metadata is one of the first places where content systems decay. Titles change, slugs drift, tags multiply, image metadata becomes inconsistent, article types become vague, repository paths become stale, and status fields stop matching reality. Metadata maintenance protects discovery, reuse, governance, and platform readiness.

Good metadata should describe what the article is, where it belongs, what it connects to, how it can be reused, who maintains it, and whether it is current. It should not be filled mechanically. Weak metadata creates weak governance because the system cannot easily identify what needs attention.

Metadata maintenance is not cosmetic. It is how a knowledge system knows what it contains.

Back to top ↑

Evidence and Source Review

Evidence review keeps framework claims connected to support. It asks whether the article’s sources still exist, still say what the article says they say, still represent current knowledge, and still fit the claims being made. It also asks whether the article has overstated evidence, omitted uncertainty, or reused claims beyond their original context.

Source review is especially important for articles involving current policy, law, technology, standards, science, markets, public health, sustainability, or AI. In those areas, evidence can change quickly. But even stable conceptual articles need evidence review because source links can break and interpretations can drift.

Evidence review protects a framework from becoming a well-structured unsupported argument.

Back to top ↑

Internal-Link Health

Internal links are knowledge infrastructure. They connect articles, series, prerequisites, related concepts, applications, governance pages, and repository outputs. When links break or become stale, the knowledge system loses coherence. Readers may be sent to outdated pages, missing pages, wrong anchors, or unrelated concepts.

Internal-link maintenance should check whether links still work, whether they still point to the right article, whether anchor links still exist, whether footer navigation follows the article map, and whether related articles are still relevant. Link maintenance should also watch for link clutter: too many links can confuse readers as much as too few links.

Link health is a governance issue because navigation shapes what knowledge remains visible.

Back to top ↑

Taxonomy and Article Map Governance

Taxonomies and article maps organize content into meaningful structures. They help readers understand what belongs together, what comes first, what is related, and what remains missing. But taxonomies and article maps also drift. Categories become too broad, too narrow, outdated, duplicated, or biased toward early decisions.

Article-map governance reviews whether the series still has a coherent sequence. It checks whether new articles have changed the logic of the map, whether planned articles should be renamed, whether some articles should be merged, and whether later governance articles need to revise earlier assumptions.

Taxonomy governance protects the shape of the knowledge system.

Back to top ↑

Repository and Output Maintenance

Companion repositories extend content frameworks into reproducible workflows. They can include data, code, schemas, tests, outputs, notebooks, HTML assets, CSS, PHP helpers, Java validators, SQL views, documentation, and Canvas-ready exports. But repositories also require maintenance. A repository that no longer runs can weaken the credibility of the article it supports.

Repository maintenance should check whether scripts run, tests pass, sample data matches the article, generated outputs exist, schemas remain valid, documentation is current, and commits reflect meaningful changes. It should also check whether repository folders still match the article’s slug and whether generated outputs are useful rather than decorative.

Repository maintenance keeps the article’s computational claims aligned with working artifacts.

Back to top ↑

Version Control and Editorial Decision Records

Framework governance needs memory. Version control records what changed. Editorial decision records explain why it changed. Both matter. A commit may show that a file was updated, but it may not explain the reasoning behind a taxonomy change, a merged article, a retired framework, or a revised evidence claim.

Decision records are especially useful for complex knowledge systems because later editors may need to understand why a framework was structured a certain way. They can also reduce repeated debate by documenting earlier judgments, assumptions, and tradeoffs.

Version control shows the history of changes. Decision records preserve the history of judgment.

Back to top ↑

Governance Queues and Review Priority

A governance queue turns maintenance into a workflow. It lists items that need review, revision, consolidation, source updates, link repair, metadata cleanup, repository maintenance, or retirement decisions. The queue helps editors prioritize work instead of relying on memory or scattered notes.

Governance queues can be simple or computational. A simple queue may list article, issue, owner, priority, and due date. A computational queue may score risk based on evidence status, review age, link health, metadata completeness, repository status, audience impact, and dependency complexity.

A governance queue makes maintenance visible enough to act on.

Back to top ↑

Consolidation, Retirement, and Archiving

Governance is not only about updating content. Sometimes the right decision is to merge, retire, redirect, or archive. Content systems can become weaker when every article remains active forever. Duplicate pages fragment authority. Outdated frameworks create confusion. Weak pages dilute the article map. Unmaintained repositories create trust problems.

Retirement does not always mean deletion. Some content should be archived for historical context. Some should be redirected to a stronger current article. Some should be merged into a better framework. Some should remain visible with a clear status note. The governance decision should match the article’s value, risk, and relationship to the wider knowledge system.

A governed knowledge system needs a way to end, not only a way to publish.

Back to top ↑

Practical Uses of Framework Governance

Framework governance can support research libraries, editorial calendars, article maps, public knowledge systems, education platforms, policy explainers, sustainability communication, technical documentation, AI-assisted publishing workflows, and repository-based learning environments.

Framework governance is useful wherever content has to remain reliable after the first publication cycle.

Back to top ↑

The Limits of Governance

Governance can improve maintenance, but it can also become excessive. Too many fields, checklists, approvals, and queues can slow useful work. Governance can become performative when records are created but not used. It can also become rigid if review rules prevent authors from adapting to new knowledge or audience needs.

The goal is not maximum governance. The goal is appropriate governance. A small article may need a simple owner, review date, and source check. A major framework that supports many pages and repositories may need deeper evidence review, repository tests, link audits, metadata checks, and decision records.

Good governance reduces risk without smothering judgment.

Back to top ↑

Relationship to Framework Drift, Content Audits, Metadata, Scaling Knowledge, and AI-Assisted Design

Framework governance connects several articles in the Content Frameworks series. Content audits identify what exists. Editorial metadata makes content searchable and governable. Scaling knowledge shows why maintenance becomes more important as a knowledge system grows. Framework drift explains what happens when meanings decay. AI-assisted framework design adds new governance pressure because production can accelerate faster than review.

Framework governance is the maintenance layer that connects the rest of the content framework system.

Back to top ↑

How Governance Supports Content Frameworks

Content frameworks depend on governance because their value is cumulative. A single template can be useful. A governed template can become a reusable system. A single article map can be helpful. A governed article map can guide a growing library. A single repository can demonstrate a concept. A governed repository can support reproducible learning.

Governance supports content frameworks by keeping structure aligned with purpose. It ensures that article maps still make sense, metadata still supports discovery, evidence still supports claims, links still guide readers, repositories still run, and frameworks still fit their use cases.

Governance is what allows content frameworks to remain useful as the knowledge system changes.

Back to top ↑

Ethics, Power, and Editorial Accountability

Framework governance is ethical work because editorial systems decide what remains visible, current, authoritative, and discoverable. A neglected article can mislead readers. A stale framework can preserve outdated assumptions. A taxonomy can hide some topics and elevate others. A missing review path can make accountability impossible.

Ethical maintenance requires more than technical accuracy. It requires attention to representation, evidence quality, uncertainty, public impact, accessibility, source transparency, and correction paths. A knowledge system should make it clear how errors can be found, who reviews them, and how changes are made.

• Transparency: Readers should be able to see when content is current, limited, contested, or under review.
• Accountability: Governance records should identify owners, decisions, and maintenance actions.
• Evidence discipline: Claims should remain connected to sources, methods, confidence, and limits.
• Representation: Taxonomies and examples should be reviewed for exclusion, bias, and blind spots.
• Correction: Errors should have a visible path to review and repair.
• Retirement: Outdated frameworks should be revised, archived, redirected, or removed.
• Accessibility: Maintenance should preserve clarity, navigation, and usability for different audiences.
• Humility: Governance should keep frameworks open to challenge and revision.

Editorial accountability means taking responsibility for what a framework continues to do after it is published.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

Framework governance can be supported by computational audits. These audits do not decide editorial truth. They identify where review is needed by scoring metadata completeness, evidence currency, link health, repository status, review age, ownership clarity, dependency complexity, and audience impact.

A governance maturity score can average core maintenance dimensions:

A maintenance risk score can combine weak governance, stale evidence, broken links, repository gaps, and high dependency complexity:

A review priority score can combine maintenance risk with audience impact:

Computation should make maintenance risks visible while leaving final editorial decisions to accountable reviewers.

Back to top ↑

Python Workflow: Framework Governance Audit

The Python workflow below evaluates framework governance by ownership clarity, review-cycle strength, metadata completeness, evidence status, link health, taxonomy alignment, platform readiness, stale evidence risk, dependency complexity, 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_governance_audit.py
# Dependency-light workflow for framework governance and editorial maintenance.

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 FrameworkGovernanceItem:
    item: str
    item_type: str
    description: str
    ownership_clarity: float
    review_cycle_strength: float
    metadata_completeness: float
    evidence_status: float
    link_health: float
    taxonomy_alignment: float
    platform_readiness: float
    stale_evidence_risk: float
    dependency_complexity: float
    audience_impact: float
    owner: str
    status: str

    def governance_maturity(self) -> float:
        return mean([
            self.ownership_clarity,
            self.review_cycle_strength,
            self.metadata_completeness,
            self.evidence_status,
            self.link_health,
            self.taxonomy_alignment,
            self.platform_readiness,
        ])

    def maintenance_risk(self) -> float:
        return min(
            1.0,
            (1 - self.governance_maturity()) * 0.34
            + self.stale_evidence_risk * 0.22
            + (1 - self.link_health) * 0.16
            + (1 - self.platform_readiness) * 0.12
            + self.dependency_complexity * 0.16,
        )

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

    def review_priority(self) -> str:
        if self.status == "revise" or self.review_priority_score() >= 0.55:
            return "high"
        if self.status == "review" or self.review_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 = [
        FrameworkGovernanceItem("Content Frameworks article map", "article map", "Series map requiring sequence link and planned-article maintenance.", 0.82, 0.76, 0.80, 0.74, 0.82, 0.84, 0.72, 0.24, 0.42, 0.82, "editorial", "active"),
        FrameworkGovernanceItem("Evidence architecture references", "evidence system", "Claim-source structure requiring source review and status tracking.", 0.76, 0.78, 0.74, 0.84, 0.72, 0.70, 0.68, 0.34, 0.46, 0.78, "research", "review"),
        FrameworkGovernanceItem("Canvas-ready repository scaffold", "repository", "Code data schema tests outputs docs and governance queue requiring smoke tests.", 0.80, 0.72, 0.78, 0.70, 0.68, 0.72, 0.86, 0.28, 0.52, 0.70, "platform", "active"),
        FrameworkGovernanceItem("Legacy framework template", "template", "Older template has weak review cycle inconsistent metadata and unclear retirement status.", 0.44, 0.36, 0.42, 0.48, 0.40, 0.38, 0.34, 0.66, 0.72, 0.62, "governance", "revise"),
        FrameworkGovernanceItem("Related article footer navigation", "navigation", "Footer sequence connects previous article map and next article paths.", 0.78, 0.70, 0.76, 0.72, 0.88, 0.82, 0.70, 0.20, 0.38, 0.76, "editorial", "active"),
    ]

    rows = []

    for item in items:
        rows.append({
            "item": item.item,
            "item_type": item.item_type,
            "description": item.description,
            "ownership_clarity": item.ownership_clarity,
            "review_cycle_strength": item.review_cycle_strength,
            "metadata_completeness": item.metadata_completeness,
            "evidence_status": item.evidence_status,
            "link_health": item.link_health,
            "taxonomy_alignment": item.taxonomy_alignment,
            "platform_readiness": item.platform_readiness,
            "stale_evidence_risk": item.stale_evidence_risk,
            "dependency_complexity": item.dependency_complexity,
            "audience_impact": item.audience_impact,
            "governance_maturity": round(item.governance_maturity(), 3),
            "maintenance_risk": round(item.maintenance_risk(), 3),
            "review_priority_score": round(item.review_priority_score(), 3),
            "owner": item.owner,
            "status": item.status,
            "review_priority": item.review_priority(),
        })

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

    governance_queue = [
        row for row in rows
        if row["review_priority"] != "standard"
    ]

    write_csv(TABLES / "framework_governance_queue.csv", governance_queue)

    print("Framework governance audit complete.")


if __name__ == "__main__":
    main()

This workflow helps identify which framework assets need review, which governance layers are weak, and where editorial maintenance should be prioritized.

Back to top ↑

R Workflow: Framework Governance Diagnostics

The R workflow below creates a framework governance dataset, calculates governance maturity, maintenance risk, review priority score, and review status, then exports summary tables and base R plots. It is intentionally portable and uses only base R.

# framework_governance_report.R
# Base R workflow for framework governance and editorial maintenance.

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(
    "Content Frameworks article map",
    "Evidence architecture references",
    "Canvas-ready repository scaffold",
    "Legacy framework template",
    "Related article footer navigation"
  ),
  item_type = c(
    "article map",
    "evidence system",
    "repository",
    "template",
    "navigation"
  ),
  ownership_clarity = c(0.82, 0.76, 0.80, 0.44, 0.78),
  review_cycle_strength = c(0.76, 0.78, 0.72, 0.36, 0.70),
  metadata_completeness = c(0.80, 0.74, 0.78, 0.42, 0.76),
  evidence_status = c(0.74, 0.84, 0.70, 0.48, 0.72),
  link_health = c(0.82, 0.72, 0.68, 0.40, 0.88),
  taxonomy_alignment = c(0.84, 0.70, 0.72, 0.38, 0.82),
  platform_readiness = c(0.72, 0.68, 0.86, 0.34, 0.70),
  stale_evidence_risk = c(0.24, 0.34, 0.28, 0.66, 0.20),
  dependency_complexity = c(0.42, 0.46, 0.52, 0.72, 0.38),
  audience_impact = c(0.82, 0.78, 0.70, 0.62, 0.76),
  owner = c("editorial", "research", "platform", "governance", "editorial"),
  status = c("active", "review", "active", "revise", "active"),
  stringsAsFactors = FALSE
)

items$governance_maturity <- rowMeans(items[, c(
  "ownership_clarity",
  "review_cycle_strength",
  "metadata_completeness",
  "evidence_status",
  "link_health",
  "taxonomy_alignment",
  "platform_readiness"
)])

items$maintenance_risk <- pmin(
  1,
  (1 - items$governance_maturity) * 0.34 +
    items$stale_evidence_risk * 0.22 +
    (1 - items$link_health) * 0.16 +
    (1 - items$platform_readiness) * 0.12 +
    items$dependency_complexity * 0.16
)

items$review_priority_score <- pmin(
  1,
  items$maintenance_risk * 0.70 +
    items$audience_impact * 0.30
)

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

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

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

governance_queue <- items[items$review_priority != "standard", ]

write.csv(
  governance_queue,
  file.path(tables_dir, "framework_governance_queue.csv"),
  row.names = FALSE
)

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

png(file.path(figures_dir, "framework_governance_maturity.png"), width = 1000, height = 700)
barplot(
  items$governance_maturity,
  names.arg = items$item,
  las = 2,
  ylab = "Governance maturity",
  main = "Framework Governance Maturity"
)
grid()
dev.off()

print(items[, c("item", "item_type", "governance_maturity", "maintenance_risk", "review_priority_score", "review_priority")])

This workflow turns editorial maintenance into an auditable governance artifact. It helps identify weak ownership, stale sources, link problems, metadata gaps, platform issues, dependency complexity, and high-priority review items.

Back to top ↑

GitHub Repository

The companion repository for this article supports framework governance and editorial maintenance as a Catalyst Canvas-ready content-framework module. It includes ownership audits, review-cycle scoring, metadata completeness, evidence status, link health, taxonomy alignment, repository readiness, stale-evidence risk, dependency complexity, audience impact, governance maturity, maintenance-risk scoring, JSON schemas, package-style Python, tests, Canvas card outputs, markdown governance queues, synthetic datasets, SQL views, documentation, and multi-language scaffolds for responsible editorial maintenance.

articles/framework-governance-and-editorial-maintenance/
├── canvas/
│   ├── canvas_manifest.json
│   ├── input_schema.json
│   ├── output_schema.json
│   ├── canvas_cards.json
│   └── governance_queue.json
├── html/
├── css/
├── php/
├── java/
├── python/
│   ├── framework_governance_canvas/
│   │   ├── __init__.py
│   │   ├── __main__.py
│   │   ├── cli.py
│   │   ├── models.py
│   │   ├── scoring.py
│   │   ├── validation.py
│   │   ├── governance.py
│   │   └── exporters.py
│   ├── tests/
│   │   └── test_framework_governance_canvas.py
│   └── run_framework_governance_canvas_audit.py
├── r/
│   ├── framework_governance_report.R
│   └── run_all_framework_governance_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 Editorial Maintenance Makes Frameworks Durable

Frameworks become durable when they are maintained. A strong framework can clarify knowledge, guide readers, support evidence, organize learning, and scale reusable structures. But without governance, the same framework can drift, decay, duplicate, overclaim, break links, lose context, and mislead audiences.

Editorial maintenance keeps frameworks alive. It protects article maps, metadata, evidence, internal links, repositories, taxonomies, governance queues, and decision records. It gives knowledge systems a way to correct themselves. It also gives readers a reason to trust that the content is not merely published, but cared for.

Framework governance is not a separate administrative layer. It is part of the framework itself. A framework that cannot be reviewed, revised, or retired is not a durable knowledge system. It is a temporary structure waiting to decay.

Back to top ↑

Related Articles

• Why Content Frameworks Matter Today
• Content Audits and Framework Governance
• Editorial Metadata and Content Systems
• Scaling Knowledge Through Frameworks
• Framework Drift and Conceptual Decay
• 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.
• 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.
• Simon, H.A. (1996) The Sciences of the Artificial. 3rd edn. Cambridge, MA: MIT Press.

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.
• 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.
• Simon, H.A. (1996) The Sciences of the Artificial. 3rd edn. Cambridge, MA: MIT Press.

Back to top ↑