Algorithmic Literacy for the Modern World: How to Understand Algorithms in Everyday Life

Last Updated June 17, 2026

Algorithmic literacy is the ability to recognize, question, interpret, and responsibly use algorithmic systems in everyday life. It is not the same as becoming a professional programmer. It is a broader public capacity: understanding how procedures, data, rankings, recommendations, scores, searches, models, platforms, and automated workflows shape what people see, decide, trust, ignore, contest, and act upon.

Modern societies increasingly rely on algorithmic systems to organize information, allocate attention, recommend content, sort applicants, detect risk, schedule resources, model systems, manage logistics, personalize services, filter communication, support decisions, and automate institutional work. These systems are not magic. They are designed procedures operating on selected inputs, representations, assumptions, objectives, constraints, and feedback loops.

Algorithmic literacy helps people ask better questions. What problem is this system solving? What data does it use? What does it optimize? What does it ignore? Who benefits? Who may be harmed? How can its outputs be checked? Where should human judgment remain active? These questions are essential for living responsibly in a computational world.

This article explains algorithmic literacy as a modern civic, educational, technical, and institutional capacity. It introduces the questions people need to ask when they encounter algorithmic systems: what the system is designed to do, what inputs it uses, what outputs it produces, what assumptions it depends on, what tradeoffs it makes, how it handles uncertainty, and how its effects should be governed. The article emphasizes that algorithmic literacy is not only about code. It is about judgment in a world increasingly mediated by computational procedures.

Why Algorithmic Literacy Matters

Algorithmic literacy matters because computational systems increasingly mediate ordinary experience. People encounter algorithms when they search for information, use maps, receive recommendations, apply for services, interact with platforms, receive automated alerts, view ranked feeds, use translation tools, manage finances, encounter fraud detection, navigate healthcare portals, or rely on public systems.

Many of these systems are useful. They can sort information quickly, detect patterns, reduce repetitive work, support scientific modeling, improve logistics, and help people make sense of complexity. But usefulness does not eliminate the need for understanding. Algorithmic systems can also hide assumptions, reinforce weak categories, amplify errors, encourage overtrust, narrow attention, produce unfair outcomes, or make institutional decisions harder to contest.

Algorithmic literacy helps people move from passive exposure to active interpretation. It gives citizens, students, workers, leaders, designers, educators, journalists, researchers, and institutions a shared vocabulary for asking what computational systems are doing and whether they should be trusted.

Back to top ↑

What Is Algorithmic Literacy?

Algorithmic literacy is the ability to understand algorithms as structured procedures that transform inputs into outputs under assumptions, rules, objectives, constraints, and stopping conditions. It includes basic awareness of how computational systems represent problems, organize data, make comparisons, rank alternatives, learn from examples, automate tasks, and produce outputs that require interpretation.

It does not require everyone to become a software engineer. A literate reader does not need to become a novelist to interpret a book. A mathematically literate person does not need to become a research mathematician to understand evidence, scale, probability, or risk. Likewise, an algorithmically literate person does not need to write production code to ask informed questions about computational systems.

Algorithmic literacy includes several related capacities:

• recognizing when an algorithmic system is involved;
• identifying inputs, outputs, states, and objectives;
• understanding that data is selected, structured, and interpreted;
• distinguishing procedure from judgment;
• asking what a system optimizes or prioritizes;
• recognizing limits, uncertainty, bias, and error;
• understanding that outputs may require review, explanation, and contestability;
• knowing when automation should support, not replace, human responsibility.

Algorithmic literacy is therefore a form of modern public reasoning. It helps people evaluate procedures that increasingly shape knowledge, opportunity, attention, and institutional action.

Back to top ↑

Algorithms as Public Infrastructure

Algorithms often operate like infrastructure. They are embedded in systems that people depend on but rarely see directly. Search engines, recommendation systems, digital maps, fraud detection systems, logistics platforms, scheduling systems, ranking tools, automated forms, identity verification systems, and public-sector decision-support tools all structure access, visibility, timing, and interpretation.

Infrastructure becomes powerful partly because it becomes ordinary. People may notice a bridge only when it fails. They may notice a ranking system only when it excludes them, hides something, recommends badly, or produces an unfair result. Algorithmic literacy helps make invisible procedural infrastructure more visible before failure occurs.

Calling algorithms infrastructure does not mean every algorithm should be treated the same. A playlist recommendation system, a bridge-inspection model, a public-benefits eligibility tool, and a scientific simulation have different stakes. But all require literacy appropriate to their consequences.

Back to top ↑

Reading Procedural Systems

Algorithmic literacy begins with learning how to read procedural systems. A procedure is not only a list of instructions. It is a formalized way of moving from a starting condition to an outcome. Reading a procedural system means identifying the problem, representation, steps, conditions, outputs, and limits.

A useful reading practice asks:

• What problem is being formalized?
• What inputs does the system accept?
• What outputs does it produce?
• What state does it maintain?
• What rules, thresholds, comparisons, or rankings does it use?
• What objective does it optimize?
• What assumptions does it depend on?
• What does it exclude?
• How does it handle uncertainty, failure, and exceptions?
• Who interprets, reviews, or acts on the output?

This form of reading can be applied to a spreadsheet formula, a search ranking, a simulation, a public decision workflow, a machine-learning model, a recommender system, or a platform feed. The goal is not to reverse-engineer every line of code. The goal is to understand enough structure to evaluate meaning and consequence.

Back to top ↑

Data, Ranking, Search, and Recommendation

Search and recommendation systems are among the most common algorithmic systems people encounter. They shape what appears first, what is hidden, what is repeated, what is amplified, and what seems credible or popular. Algorithmic literacy helps people understand that a ranking is not a neutral list of reality. It is the output of a designed system.

Search systems usually depend on queries, indexes, metadata, relevance measures, freshness signals, authority signals, personalization, and ranking functions. Recommendation systems may use user history, item similarity, collaborative patterns, engagement metrics, contextual signals, and optimization objectives. Platform feeds may incorporate recency, predicted interest, social graph signals, moderation systems, paid placement, and policy rules.

Algorithmic literacy does not require rejecting search or recommendation. It requires understanding that ranked outputs are constructed. They are useful, but they should be interpreted as outputs of procedural systems rather than as transparent windows onto the world.

Back to top ↑

Automation and Human Judgment

Automation can be valuable. It can reduce repetitive work, support consistency, process large datasets, detect patterns, and help people act faster. But automation does not remove judgment. It relocates judgment into design choices, data choices, objective functions, thresholds, interfaces, policies, and review processes.

A system may automate a step, but someone still defines the problem. Someone chooses the data. Someone selects a threshold. Someone decides what counts as success. Someone interprets the output. Someone is responsible when the system fails.

Algorithmic literacy supports a balanced view. It avoids both blind trust and reflexive rejection. It asks when automation is appropriate, when it should remain advisory, when it should be constrained, and when it should not be used.

Back to top ↑

Limits, Error, Bias, and Uncertainty

Algorithmic systems have limits. Some limits come from computation: resources, complexity, approximation, scale, runtime, and data structure choices. Some come from modeling: assumptions, boundaries, variables, parameters, and uncertainty. Some come from institutions: incentives, governance, accountability, documentation, and review. Some come from society: historical patterns, unequal data, contested values, and differing interpretations.

Bias can enter through data, categories, objectives, labels, proxies, sampling, measurement, feedback loops, and deployment context. Error can enter through invalid input, weak validation, model drift, poor assumptions, unclear outputs, or inappropriate reuse. Uncertainty can be hidden when systems return crisp labels, scores, or rankings without confidence, explanation, or scope limits.

Algorithmic literacy includes the ability to ask what a system cannot know. It recognizes that a computational output may be useful and still incomplete.

Back to top ↑

Algorithmic Literacy in Everyday Life

Everyday algorithmic literacy is practical. It helps people navigate search results, recommendations, ranking systems, automated forms, pricing systems, privacy settings, content feeds, navigation routes, fraud alerts, automated messages, and decision-support tools.

A person using a search engine can ask whether results are ranked by relevance, popularity, personalization, freshness, advertising, authority, or some combination. A person using a navigation app can ask whether the route optimizes time, tolls, distance, traffic, fuel, safety, or platform assumptions. A person using a platform feed can ask why certain content repeats and why other content disappears. A person receiving an automated denial can ask what data, rule, model, or threshold produced the result.

Everyday algorithmic literacy is not paranoia. It is interpretive awareness. It helps people use computational systems without surrendering judgment to them.

Back to top ↑

Algorithmic Literacy in Institutions

Institutions need algorithmic literacy because they increasingly buy, build, configure, deploy, audit, and depend on computational systems. Leaders, analysts, educators, public officials, journalists, managers, designers, and domain experts need enough understanding to ask serious questions before systems affect people at scale.

Institutional algorithmic literacy includes procurement literacy, documentation literacy, audit literacy, governance literacy, and communication literacy. A team should understand what a system is intended to do, what evidence supports its use, what data it depends on, what risks it introduces, what oversight exists, and how affected people can respond.

Institutional algorithmic literacy prevents the common mistake of treating technical systems as external to governance. Algorithms are not only engineering artifacts. They are organizational procedures with consequences.

Back to top ↑

Teaching and Learning Algorithmic Literacy

Algorithmic literacy can be taught without beginning with complex programming. It can start with everyday procedures: recipes, checklists, sorting tasks, decision trees, maps, schedules, rules, forms, and ranking exercises. Students can learn to identify inputs, outputs, states, conditions, loops, and stopping rules before writing code.

A strong curriculum connects procedural thinking with representation, data, uncertainty, ethics, and public reasoning. It does not reduce algorithms to code snippets. It teaches students to ask how computational systems formalize problems, how they make tradeoffs, and how their outputs should be interpreted.

Teaching algorithmic literacy is not only preparation for technical careers. It is preparation for citizenship, professional judgment, research, communication, and institutional responsibility in a computational age.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

Algorithmic literacy can be modeled as a combination of procedural awareness, data awareness, interpretive awareness, and governance awareness.

A simple algorithmic system can be described as:

Algorithmic risk can be framed as a function of uncertainty, scale, opacity, stakes, and governance weakness:

This framing helps show why algorithmic literacy is not a single skill. It is a layered interpretive capacity: procedural, mathematical, institutional, ethical, and communicative.

Back to top ↑

Python Workflow: Algorithmic Literacy Audit

The Python workflow below creates a simple synthetic audit for evaluating algorithmic-literacy needs across different systems. It scores procedural transparency, data visibility, output interpretability, uncertainty communication, contestability, governance readiness, impact awareness, and human-judgment support.

# algorithmic_literacy_audit.py
# Dependency-light workflow for evaluating algorithmic literacy needs.

from __future__ import annotations

from dataclasses import asdict, dataclass
from pathlib import Path
import csv
import json
from statistics import mean

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


@dataclass(frozen=True)
class LiteracyCase:
    case_name: str
    system_context: str
    user_group: str
    procedural_transparency: float
    data_visibility: float
    output_interpretability: float
    uncertainty_communication: float
    contestability: float
    governance_readiness: float
    impact_awareness: float
    human_judgment_support: float


def clamp(value: float, low: float = 0.0, high: float = 100.0) -> float:
    return max(low, min(high, value))


def literacy_support_score(case: LiteracyCase) -> float:
    return clamp(
        100.0 * (
            0.14 * case.procedural_transparency
            + 0.12 * case.data_visibility
            + 0.14 * case.output_interpretability
            + 0.12 * case.uncertainty_communication
            + 0.12 * case.contestability
            + 0.12 * case.governance_readiness
            + 0.12 * case.impact_awareness
            + 0.12 * case.human_judgment_support
        )
    )


def literacy_gap_score(case: LiteracyCase) -> float:
    weak_points = [
        1.0 - case.procedural_transparency,
        1.0 - case.data_visibility,
        1.0 - case.output_interpretability,
        1.0 - case.uncertainty_communication,
        1.0 - case.contestability,
        1.0 - case.governance_readiness,
        1.0 - case.impact_awareness,
        1.0 - case.human_judgment_support,
    ]
    return clamp(100.0 * mean(weak_points))


def diagnose(support: float, gap: float) -> str:
    if support >= 80 and gap <= 25:
        return "strong literacy support"
    if support >= 65 and gap <= 40:
        return "moderate literacy support with review needs"
    if gap >= 55:
        return "high literacy gap; users may struggle to interpret or contest the system"
    return "partial literacy support; transparency, uncertainty, or governance should improve"


def build_cases() -> list[LiteracyCase]:
    return [
        LiteracyCase(
            case_name="Search ranking",
            system_context="Ranked information retrieval system.",
            user_group="general public",
            procedural_transparency=0.62,
            data_visibility=0.54,
            output_interpretability=0.66,
            uncertainty_communication=0.40,
            contestability=0.38,
            governance_readiness=0.52,
            impact_awareness=0.70,
            human_judgment_support=0.68,
        ),
        LiteracyCase(
            case_name="Public decision-support workflow",
            system_context="Eligibility or prioritization tool used in an institutional setting.",
            user_group="affected public and case reviewers",
            procedural_transparency=0.58,
            data_visibility=0.62,
            output_interpretability=0.56,
            uncertainty_communication=0.48,
            contestability=0.70,
            governance_readiness=0.76,
            impact_awareness=0.82,
            human_judgment_support=0.74,
        ),
        LiteracyCase(
            case_name="Scientific simulation dashboard",
            system_context="Scenario model used to compare possible system futures.",
            user_group="researchers, policy analysts, and educators",
            procedural_transparency=0.76,
            data_visibility=0.72,
            output_interpretability=0.74,
            uncertainty_communication=0.78,
            contestability=0.60,
            governance_readiness=0.68,
            impact_awareness=0.70,
            human_judgment_support=0.80,
        ),
        LiteracyCase(
            case_name="Recommendation feed",
            system_context="Personalized content ranking and recommendation system.",
            user_group="platform users",
            procedural_transparency=0.40,
            data_visibility=0.42,
            output_interpretability=0.48,
            uncertainty_communication=0.30,
            contestability=0.32,
            governance_readiness=0.46,
            impact_awareness=0.66,
            human_judgment_support=0.50,
        ),
    ]


def run_audit() -> list[dict[str, object]]:
    rows: list[dict[str, object]] = []
    for case in build_cases():
        support = literacy_support_score(case)
        gap = literacy_gap_score(case)
        rows.append({
            **asdict(case),
            "literacy_support_score": round(support, 3),
            "literacy_gap_score": round(gap, 3),
            "diagnostic": diagnose(support, gap),
        })
    return rows


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    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 write_json(path: Path, payload: object) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")


def summarize(rows: list[dict[str, object]]) -> dict[str, object]:
    return {
        "case_count": len(rows),
        "average_literacy_support_score": round(mean(float(row["literacy_support_score"]) for row in rows), 3),
        "average_literacy_gap_score": round(mean(float(row["literacy_gap_score"]) for row in rows), 3),
        "highest_support_case": max(rows, key=lambda row: float(row["literacy_support_score"]))["case_name"],
        "highest_gap_case": max(rows, key=lambda row: float(row["literacy_gap_score"]))["case_name"],
        "interpretation": "Algorithmic literacy support depends on transparency, data visibility, interpretability, uncertainty communication, contestability, governance, impact awareness, and human judgment."
    }


def main() -> None:
    rows = run_audit()
    summary = summarize(rows)

    write_csv(TABLES / "algorithmic_literacy_audit.csv", rows)
    write_csv(TABLES / "algorithmic_literacy_audit_summary.csv", [summary])
    write_json(JSON_DIR / "algorithmic_literacy_audit.json", rows)
    write_json(JSON_DIR / "algorithmic_literacy_audit_summary.json", summary)

    print("Algorithmic literacy audit complete.")
    print(TABLES / "algorithmic_literacy_audit.csv")


if __name__ == "__main__":
    main()

This workflow treats literacy as an interpretive and governance problem, not just an educational slogan. It asks whether users and institutions have enough information to understand, question, and responsibly use algorithmic outputs.

Back to top ↑

R Workflow: Literacy Summary and Visualization

The R workflow reads the Python-generated audit table and creates summary outputs and visualizations using base R. It compares algorithmic-literacy support and literacy gaps across synthetic cases.

# algorithmic_literacy_summary.R
# Base R workflow for summarizing algorithmic literacy support and gaps.

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)
}

input_path <- file.path(tables_dir, "algorithmic_literacy_audit.csv")

if (!file.exists(input_path)) {
  stop(paste("Missing", input_path, "Run the Python workflow first."))
}

data <- read.csv(input_path, stringsAsFactors = FALSE)

summary_table <- data.frame(
  case_count = nrow(data),
  average_literacy_support_score = mean(data$literacy_support_score),
  average_literacy_gap_score = mean(data$literacy_gap_score),
  highest_support_case = data$case_name[which.max(data$literacy_support_score)],
  highest_gap_case = data$case_name[which.max(data$literacy_gap_score)]
)

write.csv(
  summary_table,
  file.path(tables_dir, "r_algorithmic_literacy_summary.csv"),
  row.names = FALSE
)

comparison_matrix <- rbind(
  data$literacy_support_score,
  data$literacy_gap_score
)

colnames(comparison_matrix) <- data$case_name
rownames(comparison_matrix) <- c("Literacy support", "Literacy gap")

png(
  file.path(figures_dir, "algorithmic_literacy_support_vs_gap.png"),
  width = 1400,
  height = 800
)

barplot(
  comparison_matrix,
  beside = TRUE,
  las = 2,
  ylim = c(0, 100),
  ylab = "Score",
  main = "Algorithmic Literacy Support vs. Literacy Gap"
)

legend(
  "topleft",
  legend = rownames(comparison_matrix),
  pch = 15,
  bty = "n"
)

grid()
dev.off()

png(
  file.path(figures_dir, "algorithmic_literacy_dimensions.png"),
  width = 1400,
  height = 800
)

dimension_means <- colMeans(data[, c(
  "procedural_transparency",
  "data_visibility",
  "output_interpretability",
  "uncertainty_communication",
  "contestability",
  "governance_readiness",
  "impact_awareness",
  "human_judgment_support"
)]) * 100

barplot(
  dimension_means,
  las = 2,
  ylim = c(0, 100),
  ylab = "Average score",
  main = "Average Algorithmic Literacy Support by Dimension"
)

grid()
dev.off()

print(summary_table)

This workflow supports article development by turning a broad civic concept into a reviewable diagnostic structure. It can be adapted for education, institutional audits, public communication, or governance planning.

Back to top ↑

GitHub Repository

The companion repository for this article will provide reproducible code, synthetic datasets, workflow documentation, generated outputs, and literacy-audit diagnostics that extend the article into executable examples.

articles/algorithmic-literacy-for-the-modern-world/
├── python/
│   ├── algorithmic_literacy_audit.py
│   ├── procedural_transparency_checker.py
│   ├── output_interpretation_audit.py
│   ├── literacy_gap_model.py
│   ├── calculators/
│   │   ├── literacy_support_calculator.py
│   │   └── algorithmic_risk_context_calculator.py
│   └── tests/
├── r/
│   ├── algorithmic_literacy_summary.R
│   ├── literacy_gap_visualization.R
│   └── governance_readiness_report.R
├── julia/
│   ├── literacy_gap_simulation.jl
│   └── procedural_visibility_model.jl
├── sql/
│   ├── schema_literacy_cases.sql
│   ├── schema_algorithmic_systems.sql
│   └── literacy_queries.sql
├── haskell/
│   ├── LiteracyTypes.hs
│   ├── ProceduralContracts.hs
│   └── Main.hs
├── rust/
│   └── src/
├── go/
│   └── main.go
├── c/
│   └── algorithmic_literacy_audit.c
├── cpp/
│   └── algorithmic_literacy_audit.cpp
├── fortran/
│   └── literacy_gap_model.f90
├── java/
│   └── src/main/java/org/contentcatalyst/algorithms/
├── typescript/
│   └── src/
├── prolog/
│   └── literacy_rules.pl
├── racket/
│   └── literacy_interpreter.rkt
├── docs/
│   ├── methodology.md
│   ├── article-notes.md
│   ├── algorithmic-literacy-for-the-modern-world.md
│   ├── governance-notes.md
│   └── responsible-use.md
├── data/
│   └── synthetic_algorithmic_literacy_cases.csv
├── outputs/
│   ├── tables/
│   ├── figures/
│   ├── json/
│   ├── logs/
│   └── reports/
├── notebooks/
│   └── algorithmic_literacy_walkthrough.ipynb
├── canvas/
│   ├── canvas_manifest.json
│   ├── canvas_cards.json
│   └── canvas_index.md
└── shared/
    ├── schemas/
    ├── templates/
    ├── taxonomies/
    ├── benchmarks/
    └── governance/

Back to top ↑

A Practical Method for Algorithmic Literacy

A practical method for algorithmic literacy begins with curiosity and proceeds toward structured questioning. The point is not to demand perfect transparency from every system. The point is to ask enough of the right questions to understand whether a system should be trusted, challenged, improved, or constrained.

This method can be used by students, readers, analysts, journalists, civic organizations, managers, designers, public officials, and educators. It turns algorithmic literacy into a repeatable practice.

Back to top ↑

Common Pitfalls

A common pitfall is thinking algorithmic literacy means knowing how to code. Coding is valuable, but literacy is broader. A person may write code without understanding social consequences, institutional context, uncertainty, or governance. A person may not write code but still ask excellent questions about data, outputs, power, and accountability.

Another pitfall is treating algorithms as either perfectly objective or inherently harmful. Both views are too simple. Algorithms are designed procedures. They can be useful, flawed, narrow, powerful, risky, transparent, opaque, helpful, or harmful depending on context, design, deployment, oversight, and interpretation.

Common pitfalls include:

• code-only literacy: reducing algorithmic understanding to programming syntax;
• automation overtrust: assuming computational output is neutral or final;
• automation rejection: dismissing useful procedures without examining context or evidence;
• data realism: assuming data directly represents reality without collection and representation choices;
• metric blindness: ignoring what the system optimizes or rewards;
• output overinterpretation: treating scores, labels, and rankings as more complete than they are;
• impact neglect: focusing on technical function while ignoring affected people;
• governance absence: deploying systems without monitoring, appeals, documentation, or revision;
• black-box resignation: assuming a system cannot be questioned because it is complex;
• individualization: treating algorithmic literacy only as a personal skill rather than an institutional responsibility.

Algorithmic literacy should cultivate disciplined skepticism, not cynicism. It should improve judgment, not create paralysis.

Back to top ↑

Why Algorithmic Literacy Is Modern Public Reasoning

Algorithmic literacy is a necessary capacity for the modern world because algorithms increasingly shape how information is organized, how decisions are supported, how services are delivered, how institutions operate, and how people understand complex systems.

This does not mean everyone must become a programmer. It means more people need to understand how computational procedures formalize problems, select inputs, produce outputs, rank possibilities, manage uncertainty, hide assumptions, and influence action.

Algorithmic literacy is therefore part of public reasoning. It helps people ask better questions, interpret computational outputs, protect human judgment, identify risk, demand accountability, and participate more intelligently in decisions about technology. In a world mediated by procedures, literacy means knowing how to read the procedure.

Back to top ↑

Related Articles

• What Is Algorithms & Computational Reasoning?
• Algorithmic Thinking vs. Computational Reasoning
• Problems, Procedures, and Formalization
• Decomposition and Stepwise Reasoning
• Abstraction in Computational Reasoning
• Inputs, Outputs, States, and Stopping Conditions
• From Pseudocode to Programs
• Debugging as Computational Reasoning

Further Reading

• Abelson, H., Sussman, G.J. and Sussman, J. (1996) Structure and Interpretation of Computer Programs. 2nd edn. Cambridge, MA: MIT Press. Available at: MIT Press.
• Cormen, T.H., Leiserson, C.E., Rivest, R.L. and Stein, C. (2022) Introduction to Algorithms. 4th edn. Cambridge, MA: MIT Press. Available at: MIT Press.
• Diakopoulos, N. (2019) Automating the News: How Algorithms Are Rewriting the Media. Cambridge, MA: Harvard University Press. Available at: Harvard University Press.
• Eubanks, V. (2018) Automating Inequality: How High-Tech Tools Profile, Police, and Punish the Poor. New York: St. Martin’s Press. Publisher information available at: Macmillan.
• Friedman, B. and Nissenbaum, H. (1996) ‘Bias in computer systems’, ACM Transactions on Information Systems, 14(3), pp. 330–347. Available at: ACM Digital Library.
• Gebru, T., Morgenstern, J., Vecchione, B., Vaughan, J.W., Wallach, H., Daumé III, H. and Crawford, K. (2021) ‘Datasheets for datasets’, Communications of the ACM, 64(12), pp. 86–92. Available at: ACM Digital Library.
• Gillespie, T. (2014) ‘The relevance of algorithms’, in Gillespie, T., Boczkowski, P.J. and Foot, K.A. (eds) Media Technologies: Essays on Communication, Materiality, and Society. Cambridge, MA: MIT Press. Available at: MIT Press.
• Hargittai, E. and Micheli, M. (2019) ‘Internet skills and why they matter’, in Graham, M. and Dutton, W.H. (eds) Society and the Internet. 2nd edn. Oxford: Oxford University Press. Available at: Oxford Academic.
• Kitchin, R. (2017) Thinking Critically About and Researching Algorithms. Information, Communication & Society, 20(1), pp. 14–29. Available at: Taylor & Francis Online.
• National Academies of Sciences, Engineering, and Medicine (2010) Report of a Workshop on the Scope and Nature of Computational Thinking. Washington, DC: The National Academies Press. Available at: National Academies Press.
• National Institute of Standards and Technology (2023) Artificial Intelligence Risk Management Framework (AI RMF 1.0). Gaithersburg, MD: NIST. Available at: NIST.
• O’Neil, C. (2016) Weapons of Math Destruction: How Big Data Increases Inequality and Threatens Democracy. New York: Crown. Publisher information available at: Penguin Random House.
• Pasquale, F. (2015) The Black Box Society: The Secret Algorithms That Control Money and Information. Cambridge, MA: Harvard University Press. Available at: Harvard University Press.
• Rainie, L. and Anderson, J. (2017) Code-Dependent: Pros and Cons of the Algorithm Age. Washington, DC: Pew Research Center. Available at: Pew Research Center.
• Russell, S. and Norvig, P. (2021) Artificial Intelligence: A Modern Approach. 4th edn. Hoboken, NJ: Pearson. Companion materials available at: AIMA official site.
• Sedgewick, R. and Wayne, K. (2011) Algorithms. 4th edn. Boston, MA: Addison-Wesley. Companion materials available at: Princeton University.
• Seaver, N. (2017) ‘Algorithms as culture: Some tactics for the ethnography of algorithmic systems’, Big Data & Society, 4(2). Available at: SAGE Journals.
• Wing, J.M. (2006) ‘Computational thinking’, Communications of the ACM, 49(3), pp. 33–35. Available at: ACM Digital Library.

References

• Abelson, H., Sussman, G.J. and Sussman, J. (1996) Structure and Interpretation of Computer Programs. 2nd edn. Cambridge, MA: MIT Press. Available at: https://mitpress.mit.edu/9780262510875/structure-and-interpretation-of-computer-programs/.
• Cormen, T.H., Leiserson, C.E., Rivest, R.L. and Stein, C. (2022) Introduction to Algorithms. 4th edn. Cambridge, MA: MIT Press. Available at: https://mitpress.mit.edu/9780262046305/introduction-to-algorithms/.
• Diakopoulos, N. (2019) Automating the News: How Algorithms Are Rewriting the Media. Cambridge, MA: Harvard University Press. Available at: https://www.hup.harvard.edu/books/9780674976986.
• Eubanks, V. (2018) Automating Inequality: How High-Tech Tools Profile, Police, and Punish the Poor. New York: St. Martin’s Press. Publisher information available at: https://us.macmillan.com/books/9781250215789/automatinginequality/.
• Friedman, B. and Nissenbaum, H. (1996) ‘Bias in computer systems’, ACM Transactions on Information Systems, 14(3), pp. 330–347. doi: 10.1145/230538.230561.
• Gebru, T., Morgenstern, J., Vecchione, B., Vaughan, J.W., Wallach, H., Daumé III, H. and Crawford, K. (2021) ‘Datasheets for datasets’, Communications of the ACM, 64(12), pp. 86–92. doi: 10.1145/3458723.
• Gillespie, T. (2014) ‘The relevance of algorithms’, in Gillespie, T., Boczkowski, P.J. and Foot, K.A. (eds) Media Technologies: Essays on Communication, Materiality, and Society. Cambridge, MA: MIT Press. Available at: https://mitpress.mit.edu/9780262525374/media-technologies/.
• Hargittai, E. and Micheli, M. (2019) ‘Internet skills and why they matter’, in Graham, M. and Dutton, W.H. (eds) Society and the Internet. 2nd edn. Oxford: Oxford University Press. Available at: https://academic.oup.com/book/35088.
• Kitchin, R. (2017) ‘Thinking critically about and researching algorithms’, Information, Communication & Society, 20(1), pp. 14–29. doi: 10.1080/1369118X.2016.1154087.
• National Academies of Sciences, Engineering, and Medicine (2010) Report of a Workshop on the Scope and Nature of Computational Thinking. Washington, DC: The National Academies Press. Available at: https://nap.nationalacademies.org/catalog/12840/report-of-a-workshop-on-the-scope-and-nature-of-computational-thinking.
• National Institute of Standards and Technology (2023) Artificial Intelligence Risk Management Framework (AI RMF 1.0). Gaithersburg, MD: NIST. Available at: https://www.nist.gov/itl/ai-risk-management-framework.
• O’Neil, C. (2016) Weapons of Math Destruction: How Big Data Increases Inequality and Threatens Democracy. New York: Crown. Publisher information available at: https://www.penguinrandomhouse.com/books/241363/weapons-of-math-destruction-by-cathy-oneil/.
• Pasquale, F. (2015) The Black Box Society: The Secret Algorithms That Control Money and Information. Cambridge, MA: Harvard University Press. Available at: https://www.hup.harvard.edu/books/9780674970847.
• Rainie, L. and Anderson, J. (2017) Code-Dependent: Pros and Cons of the Algorithm Age. Washington, DC: Pew Research Center. Available at: https://www.pewresearch.org/internet/2017/02/08/code-dependent-pros-and-cons-of-the-algorithm-age/.
• Russell, S. and Norvig, P. (2021) Artificial Intelligence: A Modern Approach. 4th edn. Hoboken, NJ: Pearson. Companion materials available at: https://aima.cs.berkeley.edu/.
• Sedgewick, R. and Wayne, K. (2011) Algorithms. 4th edn. Boston, MA: Addison-Wesley. Companion materials available at: https://algs4.cs.princeton.edu/home/.
• Seaver, N. (2017) ‘Algorithms as culture: Some tactics for the ethnography of algorithmic systems’, Big Data & Society, 4(2). doi: 10.1177/2053951717738104.
• Wing, J.M. (2006) ‘Computational thinking’, Communications of the ACM, 49(3), pp. 33–35. doi: 10.1145/1118178.1118215.

Back to top ↑