Algorithmic Fairness and Computational Justice: Metrics, Measurement, and Accountable Repair

Last Updated June 22, 2026

Algorithmic fairness and computational justice examine how algorithmic systems distribute benefits, burdens, visibility, risk, error, opportunity, attention, and institutional power. Fairness asks whether computational systems treat people appropriately across groups, individuals, contexts, and consequences. Computational justice asks a broader question: whether the system, institution, data, objective, workflow, appeal process, and social context support legitimate, accountable, and repairable decisions.

Algorithmic fairness is not one metric. A model can satisfy one fairness criterion while violating another. Equal false-positive rates, equal false-negative rates, demographic parity, calibration, individual fairness, counterfactual fairness, and procedural fairness capture different moral and statistical commitments. Computational justice therefore requires more than choosing a fairness score. It requires understanding what is being measured, whose interests are represented, which harms matter, who can contest outcomes, and who is responsible for repair.

This article introduces algorithmic fairness, computational justice, group fairness, individual fairness, calibration, disparate impact, equalized odds, equality of opportunity, counterfactual fairness, measurement justice, representational harm, procedural fairness, contestability, remediation, and governance. It shows why fairness analysis must connect mathematical definitions to institutional responsibility and human judgment.

This article explains fairness metrics, justice concepts, measurement choices, subgroup analysis, individual fairness, calibration, disparate impact, equalized odds, counterfactual reasoning, procedural fairness, representational harm, contestability, remediation, governance, and representation risk. It emphasizes that fairness is not only a property of a model; it is a property of a sociotechnical system that includes data, objectives, deployment, human review, affected people, and institutional accountability.

Why Algorithmic Fairness and Computational Justice Matter

Algorithmic fairness and computational justice matter because algorithmic systems often help decide who is seen, ranked, flagged, approved, denied, recommended, surveilled, investigated, assisted, ignored, or excluded. These systems can distribute opportunity, risk, attention, resources, suspicion, and credibility. When such systems operate at scale, small differences in measurement, model behavior, or workflow design can become large differences in lived consequence.

Fairness analysis asks whether algorithmic outputs and errors are distributed appropriately. Computational justice asks whether the whole system is legitimate: who defined the problem, what data were used, what harms were considered, whether people can contest decisions, whether errors can be repaired, and whether institutions remain accountable.

Fairness is not only a mathematical property. It is a question about how computation organizes social consequence.

Back to top ↑

Algorithmic Fairness Defined

Algorithmic fairness is the study and practice of evaluating whether algorithmic systems treat people or groups appropriately according to defined criteria. These criteria may concern outcomes, error rates, rankings, predictions, calibration, similarity, causal pathways, procedural protections, or downstream harms.

Different fairness definitions encode different values. A system can satisfy demographic parity while violating calibration. It can satisfy calibration while producing unequal false-positive rates. It can equalize one error rate while worsening another. This does not make fairness analysis useless; it means fairness analysis requires explicit choices and justification.

Algorithmic fairness begins with metrics, but it cannot end there.

Back to top ↑

Computational Justice Defined

Computational justice is a broader frame for asking whether computational systems support legitimate, accountable, repairable, and human-centered decision-making. It includes fairness metrics, but also asks about social context, measurement, power, institutional authority, contestability, harm, and remedy.

A system may appear fair by one metric while still being unjust because the data are extractive, the categories are harmful, the objective is inappropriate, the appeal process is inaccessible, or the system is deployed in a domain where automation deepens institutional power imbalances.

Computational justice treats algorithmic systems as institutional systems, not merely predictive tools.

Back to top ↑

Fairness Is Not One Thing

Fairness is plural. It can mean equal treatment, equal outcomes, equal opportunity, equal error rates, equal predictive meaning, respect for individual similarity, removal of impermissible causal pathways, or meaningful procedural protection. These meanings can conflict.

This is why fairness work requires judgment. The appropriate definition depends on the domain, stakes, harms, legal context, institutional purpose, data quality, affected groups, and available remedies.

A fairness audit should state which fairness concept is being used, why it fits the context, and what it does not capture.

Back to top ↑

Group Fairness

Group fairness evaluates whether outcomes, errors, or scores differ across groups. Groups may be defined by protected characteristics, legally relevant categories, institutional roles, geography, language, disability, age, socioeconomic status, or other context-specific dimensions. Group fairness is important because algorithmic systems can reproduce or amplify structural inequalities even when individual decisions appear neutral.

Group fairness is often measured using selection rates, false-positive rates, false-negative rates, true-positive rates, calibration curves, ranking exposure, or benefit allocation.

Group fairness makes aggregate patterns visible, but it must be paired with context, measurement review, and contestability.

Back to top ↑

Individual Fairness

Individual fairness is often summarized as the idea that similar individuals should be treated similarly. This sounds intuitive, but it raises a difficult question: similar according to what measure? A similarity metric can encode values, assumptions, institutional priorities, historical bias, or proxy variables.

Individual fairness is useful because group averages can hide unfair treatment of specific people. But individual fairness can be misleading if similarity is defined by flawed data or unjust categories.

Individual fairness is strongest when it is tied to domain reasoning, valid measurement, and meaningful appeal.

Back to top ↑

Calibration and Error Rates

Calibration means that a predicted score corresponds to observed frequency. If a model assigns a 0.70 risk score, then roughly 70 percent of comparable cases should experience the outcome. Calibration by group asks whether the score means the same thing across groups.

Error-rate fairness asks whether false positives, false negatives, true positives, and true negatives are distributed appropriately. These measures matter because different errors impose different burdens. A false positive may wrongly penalize someone. A false negative may deny help or miss need.

Fairness review should ask which errors matter most and who bears them.

Back to top ↑

Counterfactual and Causal Fairness

Counterfactual and causal fairness ask whether a decision would change if a protected attribute or sensitive pathway were different, while other relevant conditions were appropriately held fixed. This requires causal reasoning rather than only statistical comparison.

Causal fairness is difficult because protected attributes are connected to social histories, institutions, and life conditions. Removing a variable from the model does not remove its influence if other features act as proxies. A causal approach asks which pathways are legitimate, which are unjust, and how interventions would change outcomes.

Causal fairness connects fairness metrics with the deeper question of how inequality enters data and decisions.

Back to top ↑

Measurement Justice

Measurement justice asks whether the constructs used in an algorithmic system are valid, appropriate, and accountable. Many algorithmic systems measure proxies rather than the thing they claim to evaluate: risk, merit, quality, need, productivity, credibility, engagement, safety, or value.

A fairness audit can fail if it treats flawed measurements as neutral facts. If the target label is biased, if the proxy is weak, if records are uneven, or if categories misrepresent people, then fairness metrics may only compare errors within an unjust measurement system.

Fairness cannot be stronger than the measurement system on which it depends.

Back to top ↑

Representational and Procedural Harm

Algorithmic systems can cause harm even when resource allocation is not directly at stake. Representational harm occurs when a system stereotypes, erases, mislabels, ranks, excludes, or mischaracterizes people or groups. Procedural harm occurs when people cannot understand, contest, correct, or appeal decisions.

Computational justice therefore requires more than equal numerical treatment. It requires respecting people as participants in systems that affect them.

Justice includes how people are represented, heard, and repaired, not only how outcomes are counted.

Back to top ↑

Tradeoffs and Impossibility Results

Fairness criteria can conflict. In many settings with different base rates across groups, it may be mathematically impossible to satisfy calibration, equal false-positive rates, and equal false-negative rates at the same time unless the model is perfect or base rates are equal. This means fairness cannot be reduced to a purely technical optimization problem.

Tradeoffs do not mean fairness is arbitrary. They mean institutions must choose, justify, document, monitor, and revisit fairness commitments.

Fairness tradeoffs make human judgment unavoidable. They should be documented rather than hidden inside model tuning.

Back to top ↑

Governance and Accountability

Fairness governance requires more than computing a metric once. Institutions should define fairness commitments, document measurement choices, test disaggregated performance, monitor deployment, track appeals and incidents, evaluate drift, assign ownership, and create remediation pathways.

A fairness audit should ask what happens when unfairness is found. If the answer is unclear, the system is not accountable.

Fairness governance should connect measurement, decision-making, accountability, and repair.

Back to top ↑

Representation Risk

Representation risk appears when organizations claim a system is fair because it passes a limited metric, while other harms remain unexamined. A fairness score can become a legitimacy device if it hides measurement problems, incompatible fairness definitions, subgroup failures, procedural barriers, or lack of remediation.

Fairness language can also obscure institutional responsibility. “The model is fair” may distract from questions about whether the use case is appropriate, whether data collection was legitimate, or whether affected people can challenge outcomes.

Fairness claims should be treated as hypotheses requiring evidence, not as final assurances.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

Demographic parity compares selection rates across groups:

Equalized odds compares error behavior across groups:

Equality of opportunity focuses on true-positive rates:

Calibration by group asks whether scores have the same meaning:

A simplified computational-justice review score can combine fairness, measurement validity, contestability, and remediation:

These formulas are starting points. They do not decide what fairness means in context. They support structured judgment.

Back to top ↑

Python Workflow: Fairness and Justice Audit

The Python workflow below creates a dependency-light audit for algorithmic fairness and computational justice. It simulates group outcomes, computes selection rates, error rates, calibration gaps, fairness gaps, justice-capacity scores, and governance status, then writes reproducible CSV and JSON outputs.

# algorithmic_fairness_computational_justice_audit.py
# Dependency-light workflow for fairness metrics, justice capacity,
# measurement review, contestability, remediation, and governance.

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 FairnessJusticeConfig:
    article: str = "algorithmic_fairness_and_computational_justice"
    selection_gap_threshold: float = 0.10
    error_gap_threshold: float = 0.10
    calibration_gap_threshold: float = 0.08
    low_justice_capacity_threshold: float = 0.65


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 group_records() -> list[dict[str, object]]:
    return [
        {"group": "A", "n": 1000, "selected": 420, "true_positive": 260, "false_positive": 160, "false_negative": 140, "true_negative": 440, "mean_score": 0.62, "observed_rate": 0.58, "measurement_validity": 0.72, "contestability": 0.66, "remediation": 0.60},
        {"group": "B", "n": 1000, "selected": 310, "true_positive": 210, "false_positive": 100, "false_negative": 210, "true_negative": 480, "mean_score": 0.61, "observed_rate": 0.49, "measurement_validity": 0.58, "contestability": 0.44, "remediation": 0.42},
        {"group": "C", "n": 1000, "selected": 360, "true_positive": 230, "false_positive": 130, "false_negative": 170, "true_negative": 470, "mean_score": 0.59, "observed_rate": 0.54, "measurement_validity": 0.64, "contestability": 0.52, "remediation": 0.50},
    ]


def safe_rate(numerator: float, denominator: float) -> float:
    return 0.0 if denominator == 0 else numerator / denominator


def compute_group_metrics(row: dict[str, object]) -> dict[str, object]:
    tp = float(row["true_positive"])
    fp = float(row["false_positive"])
    fn = float(row["false_negative"])
    tn = float(row["true_negative"])
    n = float(row["n"])
    selected = float(row["selected"])
    mean_score = float(row["mean_score"])
    observed_rate = float(row["observed_rate"])

    actual_positive = tp + fn
    actual_negative = fp + tn

    selection_rate = safe_rate(selected, n)
    false_positive_rate = safe_rate(fp, actual_negative)
    false_negative_rate = safe_rate(fn, actual_positive)
    true_positive_rate = safe_rate(tp, actual_positive)
    calibration_gap = abs(mean_score - observed_rate)
    fairness_evidence = 1.0 - mean([false_positive_rate, false_negative_rate, calibration_gap])
    justice_capacity = mean([
        max(0.0, fairness_evidence),
        float(row["measurement_validity"]),
        float(row["contestability"]),
        float(row["remediation"]),
    ])

    return {
        "group": row["group"],
        "n": int(n),
        "selected": int(selected),
        "selection_rate": round(selection_rate, 6),
        "false_positive_rate": round(false_positive_rate, 6),
        "false_negative_rate": round(false_negative_rate, 6),
        "true_positive_rate": round(true_positive_rate, 6),
        "mean_score": round(mean_score, 6),
        "observed_rate": round(observed_rate, 6),
        "calibration_gap": round(calibration_gap, 6),
        "measurement_validity": round(float(row["measurement_validity"]), 6),
        "contestability": round(float(row["contestability"]), 6),
        "remediation": round(float(row["remediation"]), 6),
        "fairness_evidence_score": round(max(0.0, fairness_evidence), 6),
        "justice_capacity_score": round(justice_capacity, 6),
    }


def audit_fairness(metrics: list[dict[str, object]], config: FairnessJusticeConfig) -> dict[str, object]:
    selection_rates = [float(row["selection_rate"]) for row in metrics]
    fpr = [float(row["false_positive_rate"]) for row in metrics]
    fnr = [float(row["false_negative_rate"]) for row in metrics]
    tpr = [float(row["true_positive_rate"]) for row in metrics]
    calibration = [float(row["calibration_gap"]) for row in metrics]
    justice = [float(row["justice_capacity_score"]) for row in metrics]

    selection_gap = max(selection_rates) - min(selection_rates)
    false_positive_gap = max(fpr) - min(fpr)
    false_negative_gap = max(fnr) - min(fnr)
    true_positive_gap = max(tpr) - min(tpr)
    max_calibration_gap = max(calibration)
    mean_justice_capacity = mean(justice)

    status = "pass"
    if (
        selection_gap >= config.selection_gap_threshold
        or false_positive_gap >= config.error_gap_threshold
        or false_negative_gap >= config.error_gap_threshold
        or max_calibration_gap >= config.calibration_gap_threshold
        or mean_justice_capacity < config.low_justice_capacity_threshold
    ):
        status = "review"
    if (
        (false_negative_gap >= config.error_gap_threshold and mean_justice_capacity < config.low_justice_capacity_threshold)
        or (selection_gap >= config.selection_gap_threshold and max_calibration_gap >= config.calibration_gap_threshold)
    ):
        status = "escalate"

    return {
        "selection_gap": round(selection_gap, 6),
        "false_positive_gap": round(false_positive_gap, 6),
        "false_negative_gap": round(false_negative_gap, 6),
        "true_positive_gap": round(true_positive_gap, 6),
        "max_calibration_gap": round(max_calibration_gap, 6),
        "mean_justice_capacity_score": round(mean_justice_capacity, 6),
        "status": status,
        "interpretation": "Fairness review should compare selection, error, calibration, measurement validity, contestability, remediation, and governance together.",
    }


def governance_register() -> list[dict[str, str]]:
    return [
        {"item": "metric_choice", "review_question": "Which fairness definitions are used and why?", "status": "required"},
        {"item": "measurement_validity", "review_question": "Do labels and proxies validly represent the construct?", "status": "required"},
        {"item": "subgroup_analysis", "review_question": "Are outcomes and errors reviewed across relevant groups?", "status": "required"},
        {"item": "contestability", "review_question": "Can affected people understand and challenge outcomes?", "status": "required"},
        {"item": "remediation", "review_question": "Can errors and harms be corrected and repaired?", "status": "required"},
        {"item": "accountability", "review_question": "Who owns fairness monitoring and system change?", "status": "required"},
    ]


def main() -> None:
    config = FairnessJusticeConfig()
    records = group_records()
    metrics = [compute_group_metrics(row) for row in records]
    audit = audit_fairness(metrics, config)
    governance = governance_register()
    summary = {
        "article": config.article,
        "timestamp_utc": timestamp_utc(),
        "groups_reviewed": len(metrics),
        "status": audit["status"],
        "selection_gap": audit["selection_gap"],
        "false_positive_gap": audit["false_positive_gap"],
        "false_negative_gap": audit["false_negative_gap"],
        "max_calibration_gap": audit["max_calibration_gap"],
        "mean_justice_capacity_score": audit["mean_justice_capacity_score"],
        "governance_items": len(governance),
        "interpretation": audit["interpretation"],
    }

    write_csv(TABLES / "fairness_group_records.csv", records)
    write_csv(TABLES / "fairness_group_metrics.csv", metrics)
    write_csv(TABLES / "fairness_audit_summary.csv", [summary])
    write_csv(TABLES / "fairness_governance_register.csv", governance)

    write_json(JSON_DIR / "fairness_justice_config.json", asdict(config))
    write_json(JSON_DIR / "fairness_group_metrics.json", metrics)
    write_json(JSON_DIR / "fairness_audit_summary.json", summary)
    write_json(JSON_DIR / "fairness_governance_register.json", governance)

    print("Algorithmic fairness and computational justice audit complete.")
    print(TABLES / "fairness_audit_summary.csv")


if __name__ == "__main__":
    main()

This workflow turns fairness and justice review into a reproducible artifact: selection rates, error rates, calibration, measurement validity, contestability, remediation, and governance are documented together.

Back to top ↑

R Workflow: Fairness Diagnostics

The R workflow reads the generated CSV outputs, summarizes fairness gaps and justice capacity, visualizes group metrics, and writes an additional diagnostic table.

# algorithmic_fairness_computational_justice_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)

metrics_path <- file.path(tables_dir, "fairness_group_metrics.csv")
summary_path <- file.path(tables_dir, "fairness_audit_summary.csv")

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

metrics <- read.csv(metrics_path, stringsAsFactors = FALSE)
summary <- read.csv(summary_path, stringsAsFactors = FALSE)

png(file.path(figures_dir, "fairness_group_metric_components.png"), width = 1200, height = 850)
score_matrix <- t(as.matrix(metrics[, c("selection_rate", "false_positive_rate", "false_negative_rate", "true_positive_rate", "calibration_gap", "justice_capacity_score")]))
barplot(score_matrix,
        beside = TRUE,
        names.arg = metrics$group,
        ylim = c(0, 1),
        ylab = "Score",
        main = "Algorithmic Fairness and Computational Justice Group Metrics")
legend("topright",
       legend = rownames(score_matrix),
       cex = 0.72,
       bty = "n")
grid()
dev.off()

png(file.path(figures_dir, "justice_capacity_by_group.png"), width = 1000, height = 750)
barplot(metrics$justice_capacity_score,
        names.arg = metrics$group,
        ylim = c(0, 1),
        ylab = "Justice Capacity Score",
        main = "Justice Capacity by Group")
grid()
dev.off()

r_summary <- data.frame(
  groups_reviewed = summary$groups_reviewed[1],
  status = summary$status[1],
  selection_gap = summary$selection_gap[1],
  false_positive_gap = summary$false_positive_gap[1],
  false_negative_gap = summary$false_negative_gap[1],
  max_calibration_gap = summary$max_calibration_gap[1],
  mean_justice_capacity_score = summary$mean_justice_capacity_score[1],
  governance_items = summary$governance_items[1],
  diagnostic_note = "Fairness review should connect selection, error rates, calibration, measurement validity, contestability, remediation, and governance."
)

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

The R layer turns fairness and justice metrics into visible diagnostic summaries that support fairness review, governance, and remediation planning.

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 Fairness and Justice Review

Fairness and justice review should be conducted as part of system design, deployment, monitoring, and remediation.

This method treats fairness as a lifecycle responsibility rather than a one-time score.

Back to top ↑

Common Pitfalls

Fairness work can fail when it becomes too narrow, too metric-driven, too detached from affected people, or too optimistic about what technical fixes can accomplish. Fairness metrics matter, but they do not replace institutional responsibility.

Fairness review should make systems more accountable, not merely more defensible.

Back to top ↑

Why Fairness Requires Judgment

Algorithmic fairness and computational justice show why responsible algorithmic systems cannot be evaluated by accuracy alone. Fairness requires asking who benefits, who is burdened, who is mismeasured, who is misrepresented, who can contest outcomes, and who receives repair when the system is wrong.

Mathematical fairness metrics are essential tools, but they encode choices. They cannot decide by themselves which errors matter, which groups should be compared, which proxies are legitimate, which causal pathways are acceptable, or which harms require remedy. Those decisions require institutional judgment, ethical reasoning, stakeholder review, and accountable governance.

Computational justice expands the frame. It asks whether the system deserves authority, whether people have voice, whether harm is repairable, and whether institutions remain responsible. AI belongs in the toolkit, not in control.

Back to top ↑

Related Articles

• Failure Modes in Algorithmic Systems
• Algorithmic Harm, Error, and Institutional Responsibility
• Contestability, Appeals, and Algorithmic Due Process
• Proxy Variables and Measurement Error

Back to top ↑

Further Reading

• Barocas, S., Hardt, M. and Narayanan, A. (2019) Fairness and Machine Learning: Limitations and Opportunities.
• Benjamin, R. (2019) Race After Technology: Abolitionist Tools for the New Jim Code. Cambridge: Polity.
• Buolamwini, J. and Gebru, T. (2018) ‘Gender shades: intersectional accuracy disparities in commercial gender classification’, Proceedings of Machine Learning Research, 81, pp. 77–91.
• Dwork, C. et al. (2012) ‘Fairness through awareness’, Proceedings of the 3rd Innovations in Theoretical Computer Science Conference, pp. 214–226.
• Hardt, M., Price, E. and Srebro, N. (2016) ‘Equality of opportunity in supervised learning’. arXiv.
• Noble, S.U. (2018) Algorithms of Oppression: How Search Engines Reinforce Racism. New York: NYU Press.
• Selbst, A.D. et al. (2019) ‘Fairness and abstraction in sociotechnical systems’, Proceedings of the Conference on Fairness, Accountability, and Transparency, pp. 59–68.

Back to top ↑

References

• Barocas, S., Hardt, M. and Narayanan, A. (2019) Fairness and Machine Learning: Limitations and Opportunities. 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-abolitionist-tools-for-the-new-jim-code–9781509526406.
• Buolamwini, J. and Gebru, T. (2018) ‘Gender shades: intersectional accuracy disparities in commercial gender classification’, Proceedings of Machine Learning Research, 81, pp. 77–91. Available at: https://proceedings.mlr.press/v81/buolamwini18a.html.
• Dwork, C., Hardt, M., Pitassi, T., Reingold, O. and Zemel, R. (2012) ‘Fairness through awareness’, Proceedings of the 3rd Innovations in Theoretical Computer Science Conference, pp. 214–226. Available at: https://doi.org/10.1145/2090236.2090255.
• Hardt, M., Price, E. and Srebro, N. (2016) ‘Equality of opportunity in supervised learning’. arXiv. Available at: https://arxiv.org/abs/1610.02413.
• 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/.
• 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 ↑