Algorithms in Media Platforms and Attention Systems: Ranking, Recommendation, and Platform Power

Last Updated June 22, 2026

Algorithms in media platforms and attention systems examine how computational procedures organize visibility, rank content, recommend media, route attention, moderate speech, shape feeds, allocate advertising, measure engagement, and influence public culture. These systems do not merely display information. They structure what people encounter, what becomes popular, what is amplified, what is hidden, what is monetized, and what communities come to understand as relevant or credible.

Media-platform algorithms operate at the intersection of information retrieval, recommendation systems, ranking, advertising markets, user behavior, content moderation, network effects, creator incentives, and governance. A ranking change can alter public discourse. A recommendation system can build habits, narrow attention, amplify outrage, or support discovery. A moderation classifier can reduce harm while also raising questions about context, power, language, error, appeal, and legitimacy.

This article introduces algorithms in media platforms and attention systems, feeds, ranking, recommendation, engagement optimization, creator incentives, advertising auctions, moderation, virality, network effects, attention economics, platform governance, transparency, contestability, audit trails, human review, distributional effects, and responsible media-system design. It shows why media algorithms must be judged not only by relevance or growth, but by their effects on attention, knowledge, culture, speech, trust, and democratic life.

This article explains how algorithms support media platforms through ranking, recommendation, search, feeds, engagement measurement, creator distribution, advertising auctions, moderation queues, trend detection, network analysis, personalization, safety workflows, transparency reports, audit trails, appeals, and platform governance. It emphasizes that attention systems are not neutral pipes. They are institutional infrastructures that shape visibility, incentives, public knowledge, and social power.

Why Algorithms in Media Platforms and Attention Systems Matter

Algorithms in media platforms and attention systems matter because attention is limited, valuable, and socially consequential. Platforms decide what appears in feeds, what is recommended next, what is searchable, what is promoted, what is demonetized, what is moderated, what is ranked as trending, and what is treated as relevant.

These decisions affect creators, publishers, advertisers, political actors, institutions, communities, educators, journalists, and everyday users. They shape public discourse, cultural visibility, learning pathways, entertainment habits, consumer behavior, creator income, social comparison, misinformation exposure, and civic trust.

Attention systems are governance systems because they decide what becomes visible at scale.

Back to top ↑

Media Platform Algorithms Defined

Media platform algorithms are computational procedures that organize, rank, recommend, moderate, monetize, or analyze media objects and user interactions. Media objects may include posts, videos, comments, images, articles, podcasts, ads, livestreams, search results, profiles, channels, groups, hashtags, or messages.

These algorithms may use rules, machine learning, collaborative filtering, embeddings, classifiers, ranking models, graph analysis, auctions, anomaly detection, natural-language processing, computer vision, reinforcement learning, or hybrid systems. The important point is not the method alone, but the role the method plays in directing attention.

A media algorithm is an attention-routing procedure embedded in a platform institution.

Back to top ↑

Feeds, Ranking, and Visibility

Feeds are ordered environments. Every feed-ranking system answers the same basic question: which content should appear, in what order, to whom, at what moment, and why? The answer may depend on recency, relevance, popularity, predicted engagement, relationships, authority, safety, monetization, user preferences, platform policy, or commercial priorities.

Feed ranking can create opportunities for discovery, but it also creates dependency. Creators, publishers, activists, educators, journalists, and businesses may become dependent on opaque visibility systems. A ranking change can affect income, reach, public debate, or community formation.

Visibility is not neutral distribution. It is platform power expressed through ranking.

Back to top ↑

Recommendation Systems and Discovery

Recommendation systems suggest content that users did not explicitly request. They may recommend videos, articles, posts, accounts, playlists, products, podcasts, groups, comments, hashtags, or communities. Recommendations can support learning, exploration, cultural discovery, and connection. They can also create repetition, escalation, dependency, polarization, and attention capture.

A recommendation algorithm often learns from user behavior. If the system treats past attention as the best guide to future value, it may reinforce existing habits rather than support reflection, agency, or diverse exposure.

Recommendation systems should be designed to support discovery without turning attention into automatic capture.

Back to top ↑

Engagement Optimization and Attention Economics

Many platforms measure success through engagement: clicks, likes, shares, comments, watch time, dwell time, session length, return frequency, retention, conversions, and ad revenue. Engagement metrics are useful signals, but they are incomplete measures of value.

Optimizing for engagement can change platform ecology. Content creators adapt. Users adapt. Bad actors adapt. The platform itself learns which emotional, social, or informational patterns hold attention. This can improve relevance and satisfaction, but it can also reward outrage, sensationalism, social comparison, anxiety, conflict, or addictive patterns.

When attention becomes the objective, human attention becomes the resource being optimized.

Back to top ↑

Creator Incentives and Platform Labor

Creators learn platform algorithms by watching reach, monetization, search performance, recommendation patterns, demonetization, moderation outcomes, and audience analytics. Over time, algorithmic distribution shapes creative labor. It affects titles, thumbnails, posting frequency, format, tone, topics, pacing, length, style, and community strategy.

Platform algorithms can support creators by connecting them with audiences. They can also create uncertainty, volatility, dependence, and pressure to optimize for platform metrics rather than creative purpose, public value, or long-term trust.

Attention systems shape not only what audiences see, but what creators feel pressured to make.

Back to top ↑

Advertising Auctions and Monetization

Advertising systems connect users, content, advertisers, bids, budgets, targeting criteria, predicted conversion, brand safety, and platform revenue. Algorithms decide which ads appear, how much advertisers pay, which audiences are targeted, which content is monetized, and which creators receive revenue.

Ad systems are powerful because monetization shapes platform incentives. If the platform earns more when users stay longer, react more intensely, or convert more often, attention optimization and advertising markets become deeply linked.

Monetization algorithms turn attention into market allocation, so their incentives must be visible.

Back to top ↑

Content Moderation and Safety Systems

Content moderation systems detect, label, rank, remove, downrank, age-gate, demonetize, or route content for human review. They may address harassment, abuse, spam, scams, graphic violence, hate speech, sexual content, misinformation, illegal material, copyright claims, coordinated manipulation, or platform-policy violations.

Moderation algorithms are difficult because meaning is contextual. Language, satire, quotation, reclamation, reporting, documentation, art, protest, academic discussion, and local context can complicate classification. Moderation errors can harm users, creators, communities, and public discourse.

Moderation systems require appeals, context, transparency, and human judgment because errors affect speech and belonging.

Back to top ↑

Virality, Network Effects, and Cascades

Virality occurs when content spreads rapidly through networks. Platform algorithms can accelerate or dampen cascades by ranking, recommending, trending, notifying, embedding, or suppressing content. Network effects make popular content more visible because attention attracts attention.

Virality is not inherently bad. It can spread emergency information, art, education, solidarity, journalism, and civic action. It can also spread harassment, rumors, manipulation, scams, panic, and coordinated abuse.

Virality is a systems problem, not merely a content problem.

Back to top ↑

Personalization, Filtering, and Choice Architecture

Personalization adapts media environments to individual users or groups. It may improve relevance, accessibility, and discovery. It may also create opacity: two users may inhabit very different information environments without knowing what differs or why.

Choice architecture refers to how options are presented. Autoplay, infinite scroll, default notifications, feed ordering, recommendation placement, search autocomplete, reaction buttons, and friction controls all shape behavior. Algorithms often operate together with interface design.

Personalization should help users navigate information, not quietly govern them through defaults.

Back to top ↑

News, Information, and Public Knowledge

Media platforms influence how people encounter news, science, elections, emergencies, public health information, social movements, cultural debate, and institutional communication. Ranking and recommendation systems can affect which sources are visible, which topics appear salient, and which narratives circulate.

Public knowledge depends on more than information availability. It depends on credibility, context, diversity, source quality, correction mechanisms, institutional trust, media literacy, and the ability to encounter competing perspectives without harassment or manipulation.

Attention systems can shape the conditions under which public knowledge forms.

Back to top ↑

Transparency, Contestability, and Appeals

Media-platform decisions can affect reach, speech, income, reputation, community access, and public participation. Users and creators need ways to understand and challenge important decisions. Transparency should include content rules, ranking principles, recommendation goals, moderation actions, monetization rules, enforcement records, appeal routes, and meaningful explanations.

Contestability is especially important when actions are invisible or ambiguous. Downranking, shadow suppression, recommendation exclusion, demonetization, and account restrictions may be difficult to detect. Platforms should provide enough notice and reason-giving for affected people to understand what happened and what they can do.

A platform decision that cannot be seen or challenged is difficult to govern.

Back to top ↑

Platform Governance and Accountability

Platform governance includes policies, enforcement systems, ranking objectives, recommendation guardrails, safety interventions, transparency reports, moderation teams, user controls, audits, public commitments, legal compliance, and institutional oversight. Algorithms are one part of this governance system.

Accountability requires records and authority. Platforms need to know what systems are deployed, what objectives they optimize, what harms they may create, how changes are tested, how errors are monitored, how users can appeal, how creators are affected, and who can pause or revise systems.

Platform governance is credible only when it can change incentives, not merely document them.

Back to top ↑

Human Judgment and Editorial Responsibility

Human judgment remains necessary in media-platform governance. Algorithms can rank, recommend, detect, and route at scale, but they cannot fully interpret context, cultural meaning, newsworthiness, satire, political speech, artistic expression, coordinated manipulation, or community harm.

Editorial responsibility does not mean every platform must behave like a newspaper. It means that systems shaping visibility, moderation, and monetization require accountable human decisions about objectives, policy, tradeoffs, and remedies. Human review must be meaningful, trained, resourced, documented, and empowered to override automated outputs.

Human judgment should govern the system, not merely clean up its errors.

Back to top ↑

Representation Risk

Representation risk appears when media-platform algorithms reduce people, communities, creators, topics, or content to measurable engagement signals. A person becomes a profile. A creator becomes a performance curve. A public issue becomes a trend. A community becomes a segment. A source becomes a ranking score. A complex conversation becomes a moderation label.

These representations are useful for computation, but they are incomplete. When platforms treat them as full reality, they risk distorting public life.

Attention metrics are not the same as meaning.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

A simple ranking score can combine predicted relevance, engagement, freshness, and safety:

A recommendation probability may estimate the chance that a user will engage with an item:

A viral feedback update can represent attention growth:

A moderation threshold converts a classifier score into action:

These formulas are useful only when objectives, thresholds, training data, user controls, appeal rights, and governance responsibilities are documented and reviewable.

Back to top ↑

Python Workflow: Media Platform Attention Audit

The Python workflow below creates a dependency-light audit for algorithms in media platforms and attention systems. It simulates platform systems, scores engagement pressure, transparency, contestability, moderation readiness, creator impact, public-knowledge impact, governance readiness, and overall attention-system risk, then writes reproducible CSV and JSON outputs.

# algorithms_in_media_platforms_and_attention_systems_audit.py
# Dependency-light workflow for ranking, recommendation, moderation,
# monetization, creator impact, attention risk, and platform 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 AttentionSystemConfig:
    article: str = "algorithms_in_media_platforms_and_attention_systems"
    high_attention_risk_threshold: float = 0.70
    low_governance_threshold: float = 0.65
    high_public_impact_threshold: float = 0.80


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 platform_systems() -> list[dict[str, object]]:
    return [
        {"system_id": "short_video_recommendation", "engagement_pressure": 0.92, "transparency": 0.48, "contestability": 0.42, "moderation_readiness": 0.66, "creator_impact": 0.88, "public_knowledge_impact": 0.78, "user_control": 0.44, "governance": 0.54, "monitoring": 0.60},
        {"system_id": "public_news_search_ranking", "engagement_pressure": 0.54, "transparency": 0.72, "contestability": 0.66, "moderation_readiness": 0.70, "creator_impact": 0.62, "public_knowledge_impact": 0.92, "user_control": 0.70, "governance": 0.76, "monitoring": 0.78},
        {"system_id": "creator_monetization_classifier", "engagement_pressure": 0.70, "transparency": 0.50, "contestability": 0.46, "moderation_readiness": 0.58, "creator_impact": 0.94, "public_knowledge_impact": 0.52, "user_control": 0.50, "governance": 0.56, "monitoring": 0.62},
        {"system_id": "community_safety_review_queue", "engagement_pressure": 0.38, "transparency": 0.68, "contestability": 0.74, "moderation_readiness": 0.82, "creator_impact": 0.64, "public_knowledge_impact": 0.70, "user_control": 0.68, "governance": 0.78, "monitoring": 0.82},
    ]


def score_system(row: dict[str, object], config: AttentionSystemConfig) -> dict[str, object]:
    governance_readiness = mean([
        float(row["transparency"]),
        float(row["contestability"]),
        float(row["moderation_readiness"]),
        float(row["user_control"]),
        float(row["governance"]),
        float(row["monitoring"]),
    ])
    attention_risk = mean([
        float(row["engagement_pressure"]),
        float(row["creator_impact"]),
        float(row["public_knowledge_impact"]),
        1.0 - float(row["user_control"]),
        1.0 - float(row["contestability"]),
    ])
    platform_risk = attention_risk * (1.0 - governance_readiness)

    recommendation = "governed_use_with_monitoring"
    if attention_risk >= config.high_attention_risk_threshold and governance_readiness < config.low_governance_threshold: recommendation = "redesign_before_scaling" elif float(row["public_knowledge_impact"]) >= config.high_public_impact_threshold and governance_readiness < 0.75:
        recommendation = "independent_public_interest_review_required"
    elif governance_readiness < config.low_governance_threshold: recommendation = "governance_review_required" elif attention_risk >= config.high_attention_risk_threshold:
        recommendation = "use_with_strong_attention_guardrails"

    return {
        "system_id": row["system_id"],
        "engagement_pressure": round(float(row["engagement_pressure"]), 6),
        "transparency": round(float(row["transparency"]), 6),
        "contestability": round(float(row["contestability"]), 6),
        "moderation_readiness": round(float(row["moderation_readiness"]), 6),
        "creator_impact": round(float(row["creator_impact"]), 6),
        "public_knowledge_impact": round(float(row["public_knowledge_impact"]), 6),
        "user_control": round(float(row["user_control"]), 6),
        "governance": round(float(row["governance"]), 6),
        "monitoring": round(float(row["monitoring"]), 6),
        "governance_readiness_score": round(governance_readiness, 6),
        "attention_risk_score": round(attention_risk, 6),
        "platform_risk_score": round(platform_risk, 6),
        "recommendation": recommendation,
    }


def platform_governance_register() -> list[dict[str, str]]:
    return [
        {"control": "algorithm_inventory", "review_question": "Are ranking, recommendation, moderation, and ad systems recorded with owners and purposes?", "status": "required"},
        {"control": "objective_review", "review_question": "Are engagement, revenue, safety, quality, and public-value objectives documented?", "status": "required"},
        {"control": "attention_impact_assessment", "review_question": "Are user agency, creator effects, public-knowledge impact, and vulnerable users reviewed?", "status": "required"},
        {"control": "contestability_and_appeals", "review_question": "Can users and creators understand, challenge, and repair major decisions?", "status": "required"},
        {"control": "moderation_governance", "review_question": "Are classifier thresholds, human review, policy changes, and appeals documented?", "status": "required"},
        {"control": "monetization_review", "review_question": "Are ad targeting, demonetization, creator revenue, and incentive effects reviewed?", "status": "required"},
        {"control": "monitoring_and_stop_rules", "review_question": "Can harmful ranking or recommendation behavior be detected, paused, rolled back, or redesigned?", "status": "required"},
    ]


def main() -> None:
    config = AttentionSystemConfig()
    systems = platform_systems()
    audit = [score_system(row, config) for row in systems]
    controls = platform_governance_register()

    summary = {
        "article": config.article,
        "timestamp_utc": timestamp_utc(),
        "systems_reviewed": len(audit),
        "systems_requiring_redesign": sum(1 for row in audit if row["recommendation"] == "redesign_before_scaling"),
        "systems_requiring_public_interest_review": sum(1 for row in audit if row["recommendation"] == "independent_public_interest_review_required"),
        "systems_requiring_governance_review": sum(1 for row in audit if row["recommendation"] == "governance_review_required"),
        "mean_attention_risk_score": round(mean(float(row["attention_risk_score"]) for row in audit), 6),
        "mean_governance_readiness_score": round(mean(float(row["governance_readiness_score"]) for row in audit), 6),
        "mean_platform_risk_score": round(mean(float(row["platform_risk_score"]) for row in audit), 6),
        "governance_controls": len(controls),
        "interpretation": "Media platform governance should connect engagement pressure, creator impact, public knowledge, transparency, contestability, moderation, user control, monitoring, and stop authority.",
    }

    write_csv(TABLES / "platform_systems.csv", systems)
    write_csv(TABLES / "attention_system_audit.csv", audit)
    write_csv(TABLES / "platform_governance_register.csv", controls)
    write_csv(TABLES / "attention_system_summary.csv", [summary])

    write_json(JSON_DIR / "attention_system_config.json", asdict(config))
    write_json(JSON_DIR / "attention_system_audit.json", audit)
    write_json(JSON_DIR / "platform_governance_register.json", controls)
    write_json(JSON_DIR / "attention_system_summary.json", summary)

    print("Algorithms in media platforms and attention systems audit complete.")
    print(TABLES / "attention_system_summary.csv")


if __name__ == "__main__":
    main()

This workflow turns attention-system governance into a reproducible review artifact: engagement pressure, creator impact, public-knowledge impact, transparency, contestability, moderation readiness, user control, monitoring, governance readiness, and system recommendation are documented together.

Back to top ↑

R Workflow: Attention-System Diagnostics

The R workflow reads the generated CSV outputs, summarizes attention risk and governance readiness, visualizes platform-system components, and writes an additional diagnostic table.

# algorithms_in_media_platforms_and_attention_systems_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, "attention_system_audit.csv")
summary_path <- file.path(tables_dir, "attention_system_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, "attention_system_components.png"), width = 1200, height = 850)
score_matrix <- t(as.matrix(audit[, c("engagement_pressure", "creator_impact", "public_knowledge_impact", "user_control", "governance_readiness_score")]))
barplot(score_matrix,
        beside = TRUE,
        names.arg = audit$system_id,
        las = 2,
        ylim = c(0, 1),
        ylab = "Score",
        main = "Algorithms in Media Platforms: Attention Risk and Governance")
legend("bottomright",
       legend = rownames(score_matrix),
       cex = 0.72,
       bty = "n")
grid()
dev.off()

png(file.path(figures_dir, "platform_risk_by_system.png"), width = 1000, height = 750)
barplot(audit$platform_risk_score,
        names.arg = audit$system_id,
        las = 2,
        ylab = "Platform Risk Score",
        main = "Platform Risk by Attention System")
grid()
dev.off()

r_summary <- data.frame(
  systems_reviewed = summary$systems_reviewed[1],
  systems_requiring_redesign = summary$systems_requiring_redesign[1],
  systems_requiring_public_interest_review = summary$systems_requiring_public_interest_review[1],
  systems_requiring_governance_review = summary$systems_requiring_governance_review[1],
  mean_attention_risk_score = summary$mean_attention_risk_score[1],
  mean_governance_readiness_score = summary$mean_governance_readiness_score[1],
  mean_platform_risk_score = summary$mean_platform_risk_score[1],
  governance_controls = summary$governance_controls[1],
  diagnostic_note = "Media platform governance should connect engagement pressure, creator impact, public knowledge, transparency, contestability, moderation, user control, monitoring, and stop authority."
)

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

The R layer turns engagement pressure, creator impact, public-knowledge impact, user control, governance readiness, and platform risk into visible diagnostic summaries that support platform governance, attention-system audits, creator-impact review, and responsible media design.

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 Responsible Attention-System Governance

Responsible attention-system governance should begin with objectives, effects, incentives, and agency before model optimization. The central question is not “Does this keep users engaged?” but “What kind of attention, knowledge, culture, and public life does this system encourage?”

This method treats media algorithms as attention-governance infrastructure rather than neutral recommendation machinery.

Back to top ↑

Common Pitfalls

Algorithms in media platforms and attention systems can fail when institutions confuse engagement with value, virality with importance, popularity with truth, moderation with context, or monetization with public benefit.

A platform that governs attention should also govern its own incentives.

Back to top ↑

Why Attention Systems Require Responsible Governance

Algorithms in media platforms and attention systems show how computational reasoning shapes visibility, recommendation, moderation, monetization, and public discourse. These systems can help people find information, discover culture, build communities, support creators, and navigate overwhelming media environments. They can also intensify attention capture, creator dependency, misinformation exposure, harassment, polarization, opacity, and institutional power.

Responsible attention systems require more than relevance metrics. They require transparent objectives, contestable decisions, meaningful appeals, creator protections, user agency, public-interest review, moderation governance, advertising accountability, monitoring, and stop rules.

The central question is not whether media algorithms work. It is what they work toward, who they affect, what they reward, what they hide, and whether their power can be governed. AI belongs in the toolkit, not in control.

Back to top ↑

Related Articles

• Algorithms in Public Policy and Governance
• Algorithms in Finance, Markets, and Risk
• Feedback Loops in Algorithmic Systems
• Metrics, Objectives, and Goodhart’s Law
• Algorithmic Accountability and Audit Trails

Back to top ↑

Further Reading

• Gillespie, T. (2018) Custodians of the Internet: Platforms, Content Moderation, and the Hidden Decisions That Shape Social Media. New Haven: Yale University Press.
• Tufekci, Z. (2017) Twitter and Tear Gas: The Power and Fragility of Networked Protest. New Haven: Yale University Press.
• Vaidhyanathan, S. (2018) Antisocial Media: How Facebook Disconnects Us and Undermines Democracy. Oxford: Oxford University Press.
• Pasquale, F. (2015) The Black Box Society: The Secret Algorithms That Control Money and Information. Cambridge, MA: Harvard University Press.
• Wu, T. (2016) The Attention Merchants: The Epic Scramble to Get Inside Our Heads. New York: Knopf.
• Pariser, E. (2011) The Filter Bubble: What the Internet Is Hiding from You. New York: Penguin Press.
• Rogers, R. (2023) The Propagation of Misinformation in Social Media: A Cross-Platform Analysis. Amsterdam: Amsterdam University Press.

Back to top ↑

References

• Gillespie, T. (2018) Custodians of the Internet: Platforms, Content Moderation, and the Hidden Decisions That Shape Social Media. New Haven: Yale University Press.
• Pariser, E. (2011) The Filter Bubble: What the Internet Is Hiding from You. New York: Penguin Press.
• Pasquale, F. (2015) The Black Box Society: The Secret Algorithms That Control Money and Information. Cambridge, MA: Harvard University Press.
• Rogers, R. (2023) The Propagation of Misinformation in Social Media: A Cross-Platform Analysis. Amsterdam: Amsterdam University Press.
• Tufekci, Z. (2017) Twitter and Tear Gas: The Power and Fragility of Networked Protest. New Haven: Yale University Press.
• Vaidhyanathan, S. (2018) Antisocial Media: How Facebook Disconnects Us and Undermines Democracy. Oxford: Oxford University Press.
• Wu, T. (2016) The Attention Merchants: The Epic Scramble to Get Inside Our Heads. New York: Knopf.

Back to top ↑