Skip to main content
Public

Share visualization

Loading preview…

Data Analysis

vizhub.com

Shared links may look like this on X, LinkedIn, Slack, and Discord.

Choose how to deliver this visualization

LinkedIn caption

LinkedIn may not keep text supplied by the share sheet. Copy the caption and paste it into the post if needed. You can tag the VizHub company page when posting.

More options

Embed on a websiteCopy iframe embed code
Download & exportHTML, source ZIP

Viewing a saved revision (read-only)

w9T4uNxqTZAmSWSuLR6L3

Data Analysis

0 stars18Public
CCurran Kelleher
Last edited Nov 9, 2026
Created on Nov 9, 2026

Created from react-d3-starter template

Language Influence Edges — Force-Directed Graph

An interactive, responsive force-directed network visualization of a directed "influenced by" graph between programming/formal languages, built with React + D3.


1. Datasets

data/influence_edges.csv

Property Value
Path (runtime) /data/influence_edges.csv
Size (bytes) 78,242
Rows (records, excluding header) 1,000
Format CSV, header is the first record; some cells may be quoted and contain embedded newlines, so the header must be parsed with a real CSV parser (D3 csv() is used).
Apparent subject Directed edges of the form language ← influenced_by, i.e. "language was influenced by influenced_by".

Columns

Column Parsed type (observed) Missing Distinct Tentative meaning Munzner class
language string 0 358 Display name of the influenced (target) language. Nominal (identifier / label)
language_id string 0 360 Canonical identifier for the language entity. Looks like a URL slug (/en/cplusplus) or a legacy key (/wikipedia/fr_id/1711). Nominal (identifier)
influenced_by string 0 233 Display name of the influencing (source) language. Nominal (identifier / label)
influenced_by_id string 0 234 Canonical identifier for the influenced_by entity. Same shape as language_id. Nominal (identifier)

Grain. One row = one directed influence edge: influenced_by → language (i.e. language depends on / was influenced by influenced_by). A single language appears in many rows (one per incoming influence). The pair (language_id, influenced_by_id) is the edge key; it is unique in the sample inspected.

Cardinality observations (from the supplied profiles).

  • language names: 358 distinct, but language_id: 360 distinct.
  • influenced_by names: 233 distinct, but influenced_by_id: 234 distinct.

These two mismatches mean that name and id are not 1:1:

  • A single name can map to two ids (e.g. two language variants share a display name but have different canonical keys), and/or
  • A single id can map to more than one name (aliasing / redirects).

Because of this, the visualization treats *_id as the entity key and * (name) as the display label, resolving the label from the id by picking the most frequent name observed for that id. This is a documented, deterministic assumption — not a claim that name and id are equivalent keys.

Parsing assumptions.

  • No numeric or temporal fields exist; every column is a string.
  • No missing values were reported (missing count 0 for all four columns).
  • Empty strings, if any, would be dropped as invalid nodes.
  • No date/time, geographic coordinates, or geographic identifiers are present.
  • Ordinal and quantitative encodings are therefore not applicable.

Relationships and join keys (verified vs. assumed)

  • Self-relationship (intra-dataset). The dataset encodes a directed graph whose node set is the union of language_id values and influenced_by_id values. An edge (language_id, influenced_by_id) connects the two nodes; direction is influenced_by → language (source influences target).
  • Join key candidate (verified shape, unverified semantics). language_id and influenced_by_id share the same string shape (/en/<slug> or /wikipedia/<locale>_id/<number>). They can be used as node keys within this single dataset because they union into one node namespace. This is an assumption within this dataset only. No other dataset is present, so no cross-dataset joins are attempted or claimed.
  • Caveat. language/language_id and influenced_by/influenced_by_id are not independent columns to be joined blindly; they are the two halves of one edge. Joining them to each other would produce garbage. They are only combined after reducing each id to the node namespace of the graph.

2. Visualization

Chosen visualization type

A force-directed directed graph (node-link diagram) rendered on a single SVG, with an interactive hover highlight that isolates a node's in-neighbors and out-neighbors.

Why this type

  • The data is a directed relation between two nominal entities; a node-link layout is the canonical, defensible encoding for relational nominal data.
  • A force layout surfaces hubs (languages that influenced many others) and bridges without hand-tuned coordinates.
  • Hover isolation gives immediate, unambiguous reading of an individual node's neighborhood — the single most useful interaction for a 300+ node graph.

Mappings

Data field Role Encoding
node id (from language_id ∪ influenced_by_id) entity force-simulation node identity; stable across renders
node label (most-common observed name for that id) label text node, faded until hover
edge (influenced_by_id → language_id) relation SVG line from source to target
in-degree (count of incoming influence edges) quantitative attribute node radius via scaleSqrt; node color via sequential scale
hovered node's incident edges interaction state opacity 1 while others fade to 0.06

Interactions

  • Hover a node — dims all unrelated edges/nodes; highlights the hovered node, its direct neighbors, and the connecting edges. A small label appears under the hovered node showing its display name and edge count.
  • Hover away — restores the full graph.
  • Resize — the ResizeObserver hook re-runs the layout in the new viewport so the graph re-centers and re-scales without distortion.

Rationale for decisions

  • scaleSqrt on radius is used so area, not radius, is proportional to in-degree — the standard perceptual correction.
  • Node opacity is kept low by default so dense regions remain readable; hover is the primary reading mechanism rather than tooltips stacked on a busy plot.
  • Direction is encoded geometrically, not with arrowheads, because arrowheads clutter a graph with thousands of crossings; the direction convention (influenced_by → language) is documented here and in a caption.

3. Files

  • index.html — page shell and import map (React + D3 from CDN). Unchanged.
  • index.jsx — mounts <App />. Unchanged.
  • App.jsx — loads the CSV, builds the graph, drives the viz.
  • viz.js — D3 render entry point (force simulation + hover).
  • useContainerDimensions.js — tracks container size. Unchanged.
  • styles.css — page and graph styles.
  • README.md — this file.

Removed: renderCircles.js and data.csv (starter-placeholder files no longer used; the visualization loads /data/influence_edges.csv at runtime).


Visualization Ideas

No project brief was supplied, so the framing below comes from the dataset and the current force-directed graph. The audience is anyone exploring how programming languages influenced one another. The questions are: which languages are hubs, how influence flows, and where the lineages are. All ideas use only language, language_id, influenced_by and influenced_by_id. Every metric (in-degree, out-degree, components, depth) is derived from those columns, and there are no dates, categories or weights.

  1. Top Influencers Bar Chart

    • Question: Which languages influenced the most others?
    • Data: influenced_by_id, influenced_by (count of rows per id = out-degree).
    • Encoding: Horizontal bars sorted descending, top 20, length = out-degree.
    • Interaction: Hovering a bar highlights the node in the graph.
    • Implementation: Use d3.rollup on deduplicated edges, then scaleBand and scaleLinear. Share hoveredId state with viz.js.
  2. Most Influenced Languages Bar Chart

    • Question: Which languages drew on the most predecessors?
    • Data: language_id, language, count of incoming edges.
    • Encoding: Bars sorted by in-degree, using the same viridis color as the graph.
    • Interaction: Click to pin the language's neighborhood.
    • Implementation: Reuse inDegree from buildGraph.
  3. In- vs Out-Degree Scatterplot

    • Question: Which languages are pure sources, pure sinks or both?
    • Data: inDegree and outDegree per node id.
    • Encoding: x = in-degree, y = out-degree, points with jitter, labels on extremes.
    • Interaction: Brush a region to highlight those nodes in the graph.
    • Implementation: Use d3.brush and a shared selection set. Jitter is needed because the values are integers.
  4. Degree Distribution Histogram

    • Question: Is influence concentrated in a few hubs?
    • Data: Total degree per node.
    • Encoding: Histogram on a log y axis, with a toggle between in-, out- and total degree.
    • Interaction: Hovering a bin lists its languages.
    • Implementation: d3.bin over the degrees, plus a symlog scale.
  5. Ego Network Radial Layout

    • Question: Who directly shaped a chosen language, and whom did it shape?
    • Data: Edges incident to a selected language_id.
    • Encoding: The focal node at the center, influencers on the left arc and influenced languages on the right arc. Edges are curved links.
    • Interaction: Choose a language from a search box, and click a neighbor to re-center.
    • Implementation: Filter edges by id and place nodes with d3.lineRadial or manual angles.
  6. Adjacency Matrix

    • Question: What are the dense clusters of influence, without edge clutter?
    • Data: Pairs (influenced_by_id, language_id).
    • Encoding: Rows = influencers, columns = influenced, filled cell = edge. Order by degree or by cluster.
    • Interaction: Hovering a cell shows "A → B" and cross-highlights its row and column.
    • Implementation: Build a sparse cell list and use scaleBand. Offer an ordering toggle.
  7. Arc Diagram

    • Question: Do influence links span long distances in a linear ordering?
    • Data: All edges with a node order derived from degree.
    • Encoding: Nodes on a line, arcs above for edges, arc color by direction.
    • Interaction: Hovering a node thickens its arcs.
    • Implementation: Draw SVG arc paths with radius = |x1−x2|/2. Sort nodes with d3.sort.
  8. Chord Diagram of Top Hubs

    • Question: How do the biggest hub languages influence each other?
    • Data: Edges restricted to the top N nodes by degree.
    • Encoding: Ribbons between arcs of the top 25 nodes.
    • Interaction: Hovering an arc isolates its ribbons.
    • Implementation: Build a matrix and use d3.chordDirected with d3.ribbonArrow.
  9. Sankey of Influence Flow

    • Question: How does influence flow from top sources to top targets?
    • Data: Edges among the top influencers and top influenced languages.
    • Encoding: Left column = sources, right column = targets, link width = 1 per edge.
    • Interaction: Hovering a link names the pair.
    • Implementation: Use d3-sankey, which needs an extra import-map entry. Split nodes by role to avoid cycles.
  10. Influence Lineage Tree

    • Question: What is the ancestry of a language, going back through influencers?
    • Data: Recursive influenced_by_id → language_id traversal.
    • Encoding: A tidy tree where a node's parents become its children, with shared ancestors duplicated.
    • Interaction: Collapse and expand nodes, with a depth limiter.
    • Implementation: Build a tree to depth 4 with a visited set to break cycles, then use d3.tree.
  11. Descendant Icicle or Sunburst

    • Question: How far does a root language's influence cascade?
    • Data: Out-edges, traversed breadth-first from a chosen root.
    • Encoding: Concentric rings by generation, with arc size by descendant count.
    • Interaction: Click to zoom into a subtree.
    • Implementation: Build a BFS spanning tree, then use d3.partition.
  12. Generation Depth Histogram

    • Question: How many hops from the earliest sources do languages sit?
    • Data: Graph structure only, not dates. Depth is the longest or shortest path from nodes with in-degree 0.
    • Encoding: Bar chart of the count of languages per depth level.
    • Interaction: Clicking a bar highlights those nodes in the graph.
    • Implementation: Run BFS from source nodes. Note that cycles, if any, need handling, and that depth is topological rather than chronological.
  13. Graph Colored by Connected Component

    • Question: Is the network one family or several isolated clusters?
    • Data: Undirected connectivity of the edges.
    • Encoding: Existing force layout, with a categorical hue per component and gray for tiny ones.
    • Interaction: A legend lists component sizes, and clicking one zooms to it.
    • Implementation: Run union-find over the ids. Add component to the node objects.
  14. Role Quadrant Coloring

    • Question: Which languages are originators, hybrids or end-points?
    • Data: inDegree and outDegree.
    • Encoding: Categorical color on the graph nodes: source-only, sink-only or both.
    • Interaction: Legend toggles filter by role.
    • Implementation: Derive role in buildGraph and swap the color scale in viz.js.
  15. Degree Filter Slider

    • Question: What is the backbone of the network once minor languages are removed?
    • Data: degree.
    • Encoding: The same graph, with nodes below the threshold removed.
    • Interaction: A slider for minimum degree, with live node and edge counts.
    • Implementation: Filter nodes and edges in App state before calling viz. Keep positions stable by caching them by id.
  16. Search and Path Finder

    • Question: How is language A connected to language B through influence?
    • Data: Directed edges, with endpoints chosen by language.
    • Encoding: The shortest path drawn in a bright color over a dimmed graph, with labels on path nodes.
    • Interaction: Two autocomplete inputs, and a note when no path exists.
    • Implementation: BFS over an adjacency map. Resolve names to ids by label.
  17. Mutual and Shared Influences Diagram

    • Question: Which languages share the most common ancestors?
    • Data: Sets of influenced_by_id per language_id.
    • Encoding: A heatmap of Jaccard similarity for the top 30 languages, hierarchically ordered.
    • Interaction: Hovering a cell lists the shared influencers.
    • Implementation: Compute set intersections and order rows with a simple clustering or by degree.
  18. Bundled Edge Hierarchy

    • Question: Do hub-centered bundles reveal the main routes of influence?
    • Data: All edges, plus a hierarchy derived from the connected component, then from the dominant influencer.
    • Encoding: Nodes on a circle with bundled curves, colored by direction (outgoing vs incoming) on hover.
    • Interaction: Hovering a node colors its edges with the amber/blue convention from the graph.
    • Implementation: d3.cluster, d3.lineRadial and curveBundle.beta(0.85).
  19. Name/ID Ambiguity Audit Table

    • Question: Where do names and ids disagree, and could this affect the graph?
    • Data: language/language_id and influenced_by/influenced_by_id. The profile shows 358 vs 360 and 233 vs 234 distinct values.
    • Encoding: A table listing ids with multiple names, or names with multiple ids, with small count bars.
    • Interaction: Clicking a row highlights the affected nodes in the graph.
    • Implementation: Use d3.group on id → names and name → ids, and keep only groups of size above 1.
  20. Small Multiples of Top-Hub Neighborhoods

    • Question: How do the neighborhoods of the top hubs compare in shape and size?
    • Data: Incident edges of the top 12 nodes by degree.
    • Encoding: A grid of mini radial or force ego graphs, with in-neighbors in blue and out-neighbors in amber, sharing the scales.
    • Interaction: Clicking a panel expands it to full size.
    • Implementation: Run a small simulation per panel with a fixed tick count, and render into nested <g> groups on one SVG.