When Algorithms Should Not Be Used: Responsible Refusal and Algorithmic Restraint

Last Updated June 22, 2026

When algorithms should not be used is one of the most important questions in computational reasoning. The ability to automate a decision does not mean the decision should be automated. The ability to model a pattern does not mean the pattern is legitimate, meaningful, fair, stable, or appropriate for institutional action. Some problems are not well-suited to algorithmic treatment because the data are unreliable, the target is ethically inappropriate, the stakes are too high, the context is too complex, the harms are difficult to repair, or the very act of automation changes the decision in unacceptable ways.

Algorithmic restraint is part of responsible computational reasoning. It asks when systems should be human-led, deliberative, participatory, qualitative, reversible, or intentionally non-automated. It also asks when institutions should avoid building, buying, deploying, scaling, or continuing algorithmic systems, even when technical performance appears impressive.

This article introduces non-use decisions, algorithmic refusal, automation boundaries, inappropriate targets, illegitimate proxies, high-stakes harms, irreversibility, contested values, measurement limits, context dependence, democratic legitimacy, dignity, human judgment, contestability, governance, and representation risk. It shows why responsible algorithmic practice requires not only better algorithms, but also the judgment to leave some decisions outside algorithmic control.

This article explains when algorithms should not be used, why technical feasibility is not enough, how non-use decisions protect people and institutions, and how algorithmic restraint can be documented as part of responsible governance. It emphasizes that some problems require judgment, dialogue, repair, rights, care, democratic legitimacy, or contextual understanding that should not be collapsed into automated procedure.

Why Non-Use Matters

Non-use matters because algorithmic systems can make institutional choices faster, larger, more opaque, and harder to contest. A decision that might otherwise require explanation, conversation, discretion, or public debate can become a score, threshold, ranking, denial, alert, classification, or automated action. When this happens in the wrong domain, automation can turn uncertainty into authority and disagreement into procedural output.

Responsible algorithmic reasoning therefore includes the capacity to refuse automation. Refusal is not anti-technology. It is a recognition that some decisions require human judgment, legal process, public legitimacy, relational care, or moral reasoning that should not be outsourced to computational procedure.

The right answer to an algorithmic proposal is sometimes no.

Back to top ↑

Algorithmic Non-Use Defined

Algorithmic non-use is the deliberate decision not to build, buy, deploy, scale, continue, or rely on an algorithmic system for a particular task or context. It can occur before development, during procurement, after testing, after deployment, after an incident, or after evidence that the system’s risks outweigh its benefits.

Non-use can be temporary or permanent. A system may be delayed until data improve, limited to low-stakes support, paused after drift, retired after repeated harm, or prohibited from use in contexts where automation is inappropriate.

Non-use should be documented as a responsible decision, not treated as a failure to innovate.

Back to top ↑

Technical Feasibility Is Not Justification

Many algorithmic harms begin with a subtle mistake: because something can be modeled, it is assumed to be appropriate to model. Technical feasibility answers one question: can a procedure generate outputs? It does not answer whether the output is meaningful, legitimate, fair, accountable, contestable, or worth using.

A model can classify, rank, predict, cluster, optimize, and generate even when the target is poorly defined, socially contested, ethically inappropriate, or institutionally dangerous.

Computational capability is a condition for automation, not a reason for it.

Back to top ↑

Inappropriate Targets

Some targets should not be algorithmically predicted, scored, ranked, or optimized because they misrepresent human beings, flatten contested values, or convert institutional judgment into technical classification. Examples include moral worth, deservingness, social value, trustworthiness as a broad personal trait, future dangerousness without strong safeguards, or complex human potential reduced to proxy labels.

Inappropriate targets often appear objective because they are translated into data. But the translation itself may be the problem.

Some things become distorted when treated as prediction targets.

Back to top ↑

Bad Data and Illegitimate Proxies

Algorithms should not be used when the data are unreliable, unrepresentative, historically biased, unlawfully obtained, coercively collected, poorly documented, impossible to correct, or disconnected from the decision being made. They should also not be used when proxies stand in for concepts they cannot legitimately measure.

A proxy can be statistically useful and ethically inappropriate at the same time. Past arrests may proxy policing patterns. Health spending may proxy access to care rather than health need. Attendance may proxy transportation insecurity or caregiving burdens. Zip codes may proxy segregation. Engagement may proxy outrage, addiction, or manipulation.

When data are wrong in ways that people cannot challenge, algorithmic use becomes especially dangerous.

Back to top ↑

High Stakes and Irreversible Harm

Algorithms should be avoided or severely constrained when decisions affect rights, safety, liberty, livelihood, housing, education, health, immigration, public benefits, financial access, family integrity, or other high-stakes domains, especially when errors are hard to detect or repair.

High stakes do not always prohibit algorithmic support. But they demand strong justification, narrow scope, meaningful human review, contestability, auditability, remediation, and stop authority. When these conditions are absent, non-use is the responsible choice.

The higher the stakes and weaker the remedy, the stronger the case for non-use.

Back to top ↑

Contested Values and Democratic Legitimacy

Some decisions involve contested public values rather than technical optimization problems. Questions about resource allocation, public safety, education, welfare, speech, policing, labor, environmental risk, or civic participation may require public deliberation, legal process, democratic legitimacy, or participatory governance. Algorithmic systems can support analysis, but they should not silently decide value conflicts.

A model can optimize a metric without resolving whether the metric is legitimate. Governance must decide whether algorithmic framing is appropriate.

Algorithms should not smuggle contested political choices into technical systems.

Back to top ↑

Context, Human Judgment, and Care

Some decisions require contextual judgment, dialogue, empathy, practical wisdom, or relational care. This does not mean humans are always better. Human institutions can be biased, inconsistent, and harmful. But replacing human judgment with algorithmic procedure can remove the very capacities needed for responsible action: listening, explanation, discretion, mercy, negotiation, and attention to particulars.

Algorithmic support may help organize information, but the decision should remain human-led when meaning depends on lived context, narrative evidence, vulnerability, or relationship.

Some decisions should remain slow because speed would remove the conditions of care.

Back to top ↑

Dignity, Rights, and Human Agency

Algorithms should not be used when they reduce people to administrative objects, deny meaningful participation, weaken rights, or undermine human agency. A system can be efficient and still disrespectful. It can be statistically accurate and still degrading. It can provide reasons and still deny meaningful voice.

Dignity concerns arise when people are scored, ranked, surveilled, profiled, excluded, or acted upon without explanation, appeal, or recognition of their full humanity.

Respect for human agency can require refusing algorithmic authority.

Back to top ↑

When Optimization Is the Wrong Frame

Optimization is powerful when objectives are legitimate, measurable, bounded, and aligned with real-world values. It is dangerous when the objective is incomplete, narrow, manipulative, or harmful. Optimizing engagement can degrade attention. Optimizing throughput can reduce care. Optimizing detection can intensify suspicion. Optimizing cost can externalize harm. Optimizing prediction can reinforce historical patterns.

When the objective is wrong, better optimization makes the system worse.

The most responsible optimization may be not optimizing at all.

Back to top ↑

When Human Review Is Not Enough

Human review is often proposed as a safeguard, but it is not always sufficient. Review can be symbolic when humans lack time, authority, evidence, training, independence, protection, or incentives to disagree. It can also be inappropriate when the underlying system should not exist.

Adding a human to an illegitimate automated process does not make the process legitimate. Meaningful review can improve responsible use, but it cannot fix every non-use problem.

Human review is a safeguard only when the process itself is worth reviewing.

Back to top ↑

Institutional Capacity and Governance Failure

Algorithms should not be used when the institution lacks the capacity to govern them. Governance capacity includes documentation, monitoring, audit trails, human review, incident response, vendor oversight, legal review, data stewardship, appeal pathways, remediation, and the authority to pause or retire systems.

A system that might be acceptable in a mature governance environment may be irresponsible in an institution that cannot detect drift, handle appeals, fix data, investigate incidents, or hold vendors accountable.

If an institution cannot govern an algorithmic system, it should not use it.

Back to top ↑

Non-Use as a Governance Decision

Non-use should be a formal governance decision with evidence, reasons, documentation, and review. Institutions should record why an algorithmic proposal was refused, delayed, limited, paused, or retired. These records help prevent the same inappropriate system from reappearing under a different name, vendor, or technical framing.

Non-use decisions can also guide better alternatives: improved human services, clearer rules, participatory policy design, better documentation, data correction, support interventions, or non-automated infrastructure.

Documented non-use is part of algorithmic accountability.

Back to top ↑

Alternatives to Algorithmic Systems

Choosing not to use an algorithm does not mean doing nothing. It may mean improving human services, clarifying policy, reducing administrative burden, funding staff, redesigning forms, creating appeal pathways, improving data correction, increasing transparency, involving affected communities, or using simpler rule-based tools with clear limits.

Sometimes the problem is not lack of prediction. It is lack of institutional capacity, resources, fairness, participation, or care.

The best solution to a decision problem is not always a decision system.

Back to top ↑

Representation Risk

Representation risk appears when algorithmic systems are presented as inevitable, neutral, modern, efficient, objective, or necessary. This framing can make refusal seem irrational or anti-innovation. It can also make human-led alternatives appear backward even when they are more accountable.

A system may be described as “decision support” while effectively determining outcomes. It may be described as “fairer than humans” while hiding flawed targets. It may be described as “risk management” while shifting risk onto affected people. It may be described as “data-driven” while relying on illegitimate proxies.

The language of innovation should not erase the right to refuse.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

A non-use risk score can combine stakes, irreversibility, governance weakness, and proxy illegitimacy:

A responsible-use readiness score can combine target legitimacy, data legitimacy, contestability, human judgment, governance capacity, and repairability:

A refusal threshold can be stated as:

A reparability score can combine detection, correction, remedy, and recurrence prevention:

These formulas are not ethical machines. They are prompts for governance review, documentation, and human judgment.

Back to top ↑

Python Workflow: Algorithmic Non-Use Review

The Python workflow below creates a dependency-light audit for deciding when algorithms should not be used. It simulates candidate use cases, scores target legitimacy, data legitimacy, contestability, human judgment, governance capacity, repairability, non-use pressure, responsible-use readiness, and recommendation, then writes reproducible CSV and JSON outputs.

# algorithmic_non_use_review.py
# Dependency-light workflow for deciding when
# algorithms should not be used.

from __future__ import annotations

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

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


@dataclass(frozen=True)
class NonUseConfig:
    article: str = "when_algorithms_should_not_be_used"
    high_non_use_pressure_threshold: float = 0.70
    low_responsible_readiness_threshold: float = 0.65
    critical_stakes_threshold: float = 0.85


def timestamp_utc() -> str:
    return datetime.now(timezone.utc).isoformat()


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        path.write_text("", encoding="utf-8")
        return
    fieldnames = sorted({key for row in rows for key in row.keys()})
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=fieldnames, extrasaction="ignore")
        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 candidate_use_cases() -> list[dict[str, object]]:
    return [
        {"use_case": "automated_benefits_denial", "target_legitimacy": 0.42, "data_legitimacy": 0.48, "contestability": 0.40, "human_judgment": 0.46, "governance_capacity": 0.44, "repairability": 0.38, "stakes": 0.94, "irreversibility": 0.78, "proxy_illegitimacy": 0.70},
        {"use_case": "routine_document_routing", "target_legitimacy": 0.86, "data_legitimacy": 0.82, "contestability": 0.78, "human_judgment": 0.72, "governance_capacity": 0.76, "repairability": 0.90, "stakes": 0.24, "irreversibility": 0.10, "proxy_illegitimacy": 0.12},
        {"use_case": "student_potential_score", "target_legitimacy": 0.30, "data_legitimacy": 0.44, "contestability": 0.42, "human_judgment": 0.48, "governance_capacity": 0.46, "repairability": 0.36, "stakes": 0.86, "irreversibility": 0.72, "proxy_illegitimacy": 0.82},
        {"use_case": "clinical_triage_support", "target_legitimacy": 0.76, "data_legitimacy": 0.72, "contestability": 0.70, "human_judgment": 0.84, "governance_capacity": 0.78, "repairability": 0.74, "stakes": 0.96, "irreversibility": 0.56, "proxy_illegitimacy": 0.30},
    ]


def score_use_case(row: dict[str, object], config: NonUseConfig) -> dict[str, object]:
    readiness = mean([
        float(row["target_legitimacy"]),
        float(row["data_legitimacy"]),
        float(row["contestability"]),
        float(row["human_judgment"]),
        float(row["governance_capacity"]),
        float(row["repairability"]),
    ])
    governance_weakness = 1.0 - float(row["governance_capacity"])
    non_use_pressure = mean([
        float(row["stakes"]),
        float(row["irreversibility"]),
        governance_weakness,
        float(row["proxy_illegitimacy"]),
    ])

    recommendation = "allow_with_governance_controls"
    if (
        non_use_pressure >= config.high_non_use_pressure_threshold
        and readiness < config.low_responsible_readiness_threshold
    ):
        recommendation = "do_not_use_algorithm"
    elif float(row["stakes"]) >= config.critical_stakes_threshold and readiness < config.low_responsible_readiness_threshold:
        recommendation = "human_led_or_refuse"
    elif float(row["stakes"]) >= config.critical_stakes_threshold:
        recommendation = "support_only_with_strong_review"
    elif readiness >= 0.75 and non_use_pressure < 0.40:
        recommendation = "limited_algorithmic_support_acceptable"

    status = "pass"
    if recommendation in {"support_only_with_strong_review", "human_led_or_refuse"}:
        status = "review"
    if recommendation == "do_not_use_algorithm":
        status = "refuse"

    return {
        "use_case": row["use_case"],
        "target_legitimacy": round(float(row["target_legitimacy"]), 6),
        "data_legitimacy": round(float(row["data_legitimacy"]), 6),
        "contestability": round(float(row["contestability"]), 6),
        "human_judgment": round(float(row["human_judgment"]), 6),
        "governance_capacity": round(float(row["governance_capacity"]), 6),
        "repairability": round(float(row["repairability"]), 6),
        "stakes": round(float(row["stakes"]), 6),
        "irreversibility": round(float(row["irreversibility"]), 6),
        "proxy_illegitimacy": round(float(row["proxy_illegitimacy"]), 6),
        "responsible_use_readiness_score": round(readiness, 6),
        "non_use_pressure_score": round(non_use_pressure, 6),
        "recommendation": recommendation,
        "status": status,
    }


def non_use_register() -> list[dict[str, str]]:
    return [
        {"criterion": "inappropriate_target", "review_question": "Is the thing being predicted or optimized legitimate?", "status": "required"},
        {"criterion": "illegitimate_proxy", "review_question": "Do available variables substitute for something they cannot responsibly measure?", "status": "required"},
        {"criterion": "high_irreparable_stakes", "review_question": "Could errors cause serious harm that cannot be repaired?", "status": "required"},
        {"criterion": "weak_contestability", "review_question": "Can affected people understand, challenge, and correct outcomes?", "status": "required"},
        {"criterion": "governance_gap", "review_question": "Can the institution monitor, audit, pause, rollback, and retire the system?", "status": "required"},
        {"criterion": "human_judgment_required", "review_question": "Does the decision require context, care, dialogue, or democratic legitimacy?", "status": "required"},
    ]


def main() -> None:
    config = NonUseConfig()
    use_cases = candidate_use_cases()
    audit = [score_use_case(row, config) for row in use_cases]
    register = non_use_register()

    summary = {
        "article": config.article,
        "timestamp_utc": timestamp_utc(),
        "use_cases_reviewed": len(audit),
        "use_cases_passed": sum(1 for row in audit if row["status"] == "pass"),
        "use_cases_requiring_review": sum(1 for row in audit if row["status"] == "review"),
        "use_cases_refused": sum(1 for row in audit if row["status"] == "refuse"),
        "mean_responsible_use_readiness_score": round(mean(float(row["responsible_use_readiness_score"]) for row in audit), 6),
        "mean_non_use_pressure_score": round(mean(float(row["non_use_pressure_score"]) for row in audit), 6),
        "non_use_criteria": len(register),
        "interpretation": "Algorithmic non-use review should connect target legitimacy, data legitimacy, contestability, human judgment, governance capacity, repairability, stakes, irreversibility, and proxy legitimacy.",
    }

    write_csv(TABLES / "candidate_use_cases.csv", use_cases)
    write_csv(TABLES / "algorithmic_non_use_audit.csv", audit)
    write_csv(TABLES / "algorithmic_non_use_register.csv", register)
    write_csv(TABLES / "algorithmic_non_use_summary.csv", [summary])

    write_json(JSON_DIR / "algorithmic_non_use_config.json", asdict(config))
    write_json(JSON_DIR / "algorithmic_non_use_audit.json", audit)
    write_json(JSON_DIR / "algorithmic_non_use_register.json", register)
    write_json(JSON_DIR / "algorithmic_non_use_summary.json", summary)

    print("Algorithmic non-use review complete.")
    print(TABLES / "algorithmic_non_use_summary.csv")


if __name__ == "__main__":
    main()

This workflow turns refusal into a reproducible governance artifact: non-use pressure, responsible-use readiness, recommendation, and status are documented together.

Back to top ↑

R Workflow: Non-Use Diagnostics

The R workflow reads the generated CSV outputs, summarizes non-use pressure and responsible-use readiness, visualizes review components, and writes an additional diagnostic table.

# algorithmic_non_use_summary.R
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")
dir.create(tables_dir, recursive = TRUE, showWarnings = FALSE)
dir.create(figures_dir, recursive = TRUE, showWarnings = FALSE)

audit_path <- file.path(tables_dir, "algorithmic_non_use_audit.csv")
summary_path <- file.path(tables_dir, "algorithmic_non_use_summary.csv")

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

audit <- read.csv(audit_path, stringsAsFactors = FALSE)
summary <- read.csv(summary_path, stringsAsFactors = FALSE)

png(file.path(figures_dir, "non_use_review_components.png"), width = 1200, height = 850)
score_matrix <- t(as.matrix(audit[, c("target_legitimacy", "data_legitimacy", "contestability", "human_judgment", "governance_capacity", "repairability", "non_use_pressure_score")]))
barplot(score_matrix,
        beside = TRUE,
        names.arg = audit$use_case,
        las = 2,
        ylim = c(0, 1),
        ylab = "Score",
        main = "Algorithmic Non-Use Review Components")
legend("bottomright",
       legend = rownames(score_matrix),
       cex = 0.66,
       bty = "n")
grid()
dev.off()

png(file.path(figures_dir, "non_use_pressure_by_case.png"), width = 1000, height = 750)
barplot(audit$non_use_pressure_score,
        names.arg = audit$use_case,
        las = 2,
        ylim = c(0, 1),
        ylab = "Non-Use Pressure Score",
        main = "Non-Use Pressure by Use Case")
grid()
dev.off()

r_summary <- data.frame(
  use_cases_reviewed = summary$use_cases_reviewed[1],
  use_cases_passed = summary$use_cases_passed[1],
  use_cases_requiring_review = summary$use_cases_requiring_review[1],
  use_cases_refused = summary$use_cases_refused[1],
  mean_responsible_use_readiness_score = summary$mean_responsible_use_readiness_score[1],
  mean_non_use_pressure_score = summary$mean_non_use_pressure_score[1],
  non_use_criteria = summary$non_use_criteria[1],
  diagnostic_note = "Algorithmic non-use review should connect target legitimacy, data legitimacy, contestability, human judgment, governance capacity, repairability, stakes, irreversibility, and proxy legitimacy."
)

write.csv(r_summary, file.path(tables_dir, "r_algorithmic_non_use_diagnostic_summary.csv"), row.names = FALSE)
print(r_summary)

The R layer turns non-use pressure and responsible-use readiness into visible diagnostic summaries that support refusal, restraint, redesign, or limited deployment decisions.

Back to top ↑

GitHub Repository

The companion repository contains reproducible workflows, synthetic data, audit outputs, calculators, documentation, and multilingual examples for this article.

Back to top ↑

A Practical Method for Algorithmic Non-Use Decisions

Algorithmic non-use should be considered explicitly before development, procurement, deployment, expansion, and continued operation.

This method makes refusal part of responsible design rather than an afterthought.

Back to top ↑

Common Pitfalls

Non-use decisions can fail when institutions treat automation as inevitable, compare algorithms only to the flawed status quo, or ignore alternatives that do not require prediction.

Responsible governance must protect the option not to automate.

Back to top ↑

Why Responsible Reasoning Includes Refusal

When algorithms should not be used brings the Algorithms & Computational Reasoning series back to its central theme: algorithms are formal procedures for solving problems, but not every human problem should be turned into a procedure. Some decisions require rights, judgment, care, public legitimacy, contestability, discretion, or refusal. Some targets should not be predicted. Some proxies should not be used. Some harms cannot be repaired. Some institutions cannot yet govern the systems they want to deploy.

Responsible computational reasoning therefore includes restraint. It includes the courage to say no to automation, no to inappropriate targets, no to illegitimate proxies, no to opaque gatekeeping, no to unreviewable decisions, and no to systems that shift risk onto people without remedy.

The goal is not less intelligence, but better judgment. AI belongs in the toolkit, not in control.

Back to top ↑

Related Articles

• Documentation, Model Cards, and Datasheets for Algorithms
• Responsible Automation and Decision Delegation
• Human-in-the-Loop and Human Judgment
• Algorithmic Risk Management and AI Governance
• Algorithmic Harm, Error, and Institutional Responsibility

Back to top ↑

Further Reading

• Selbst, A.D. et al. (2019) ‘Fairness and abstraction in sociotechnical systems’, Proceedings of the Conference on Fairness, Accountability, and Transparency, pp. 59–68.
• Barocas, S., Hardt, M. and Narayanan, A. (2023) Fairness and Machine Learning: Limitations and Opportunities. Cambridge, MA: MIT Press.
• Eubanks, V. (2018) Automating Inequality: How High-Tech Tools Profile, Police, and Punish the Poor. New York: St. Martin’s Press.
• Noble, S.U. (2018) Algorithms of Oppression: How Search Engines Reinforce Racism. New York: NYU Press.
• O’Neil, C. (2016) Weapons of Math Destruction: How Big Data Increases Inequality and Threatens Democracy. New York: Crown.
• Benjamin, R. (2019) Race After Technology: Abolitionist Tools for the New Jim Code. Cambridge: Polity.
• National Institute of Standards and Technology (2023) Artificial Intelligence Risk Management Framework (AI RMF 1.0). Gaithersburg, MD: NIST.

Back to top ↑

References

• Barocas, S., Hardt, M. and Narayanan, A. (2023) Fairness and Machine Learning: Limitations and Opportunities. Cambridge, MA: MIT Press. Available at: https://fairmlbook.org/.
• Benjamin, R. (2019) Race After Technology: Abolitionist Tools for the New Jim Code. Cambridge: Polity. Available at: https://www.politybooks.com/bookdetail?book_slug=race-after-technology-abolutionist-tools-for-the-new-jim-code–9781509526406.
• Eubanks, V. (2018) Automating Inequality: How High-Tech Tools Profile, Police, and Punish the Poor. New York: St. Martin’s Press. Available at: https://us.macmillan.com/books/9781250074317/automatinginequality.
• 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.
• Noble, S.U. (2018) Algorithms of Oppression: How Search Engines Reinforce Racism. New York: NYU Press. Available at: https://nyupress.org/9781479837243/algorithms-of-oppression/.
• O’Neil, C. (2016) Weapons of Math Destruction: How Big Data Increases Inequality and Threatens Democracy. New York: Crown. Available at: https://www.penguinrandomhouse.com/books/241363/weapons-of-math-destruction-by-cathy-oneil/.
• Selbst, A.D., Boyd, D., Friedler, S.A., Venkatasubramanian, S. and Vertesi, J. (2019) ‘Fairness and abstraction in sociotechnical systems’, Proceedings of the Conference on Fairness, Accountability, and Transparency, pp. 59–68. Available at: https://doi.org/10.1145/3287560.3287598.

Back to top ↑