Skip to main content
SimilarExport ZIP
100%

Hylang sources

✓ Published0🌍 Public
EEleonore9
Last edited Sep 1, 2016
Created on May 25, 2016

This visualization maps the global spread of Hy, a Lisp dialect embedded in Python, by plotting its community talks, videos, and blog posts as nodes on a world map. Using D3’s force-directed simulation (`d3.forceSimulation`) and geographic projection (`d3.geoPath`), it positions each resource by its geographic origin, with node size or color potentially reflecting the event’s year or type. The underlying data comes from a curated GitHub gist listing presentations and articles from 2013 to 2016. Hovering or inspecting nodes reveals the linked source material, such as YouTube videos or slides.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 1f8fbb4e3c5e59a3a46d

This streamgraph visualizes the rise and fall of programming language popularity on GitHub from 2008 to 2009, using a stacked area layout rendered in SVG via D3 v3. Each colored band represents a language’s share of activity per month, with the x-axis showing time and the y-axis the percentage of total activity. The data reveals how languages such as C, JavaScript, and Ruby dominate the early period, while smaller languages like Erlang, Scala, and Haskell appear intermittently, and the overall composition shifts dramatically over time as different languages gain and lose share.

CCaged
62% match
Loading thumbnail…

Gist 8f9cf917c41ea1240a5ea6b149d602dd

This visualization shows how the geographic spread of influencer locations relates to the frequency of their associated topics. It first loads influencer data from a CSV and a separate corpus of organization names, then renders the results using D3’s force-directed simulation to position nodes by influence, with geographic context provided by a d3.geoPath projection. The underlying text analysis relies on reading raw text files, while the visual encoding uses Canvas’s getImageData to sample pixel-level density for heatmapping, and transition.attrTween animates node movement as forces settle. The data source is explicitly read via pandas from the two files, and the rendering approach combines raster canvas operations with SVG overlays for labels and links.

AArizonaTay
62% match
Loading thumbnail…

Fork of Map

This map shows the most spoken language for a selection of countries, with each country colored according to its dominant language and popups revealing total and native speaker counts along with linguistic origin. Built with Leaflet for map rendering and D3.js for loading GeoJSON country boundaries and CSV speaker data, the visualization uses a custom hashing function to assign distinct HSL colors to each language. A legend lists the top ten languages from the data, and the color mapping reveals geographic language clusters across continents.

Ssravya7136@gmail.com
61% match
Loading thumbnail…

nodes

This interactive visualization displays a network of programming languages and their relationships, using nodes connected by links to show connections between languages like Java, C, Python, and JavaScript. The graph is rendered using D3 v5's `csv` loading and `scaleLinear` functions, with SVG circles representing each language. The visualization presents a scatter plot of car data from the UCI Machine Learning Repository's Auto MPG dataset, mapping horsepower on the x-axis and weight on the y-axis with red semi-transparent circles. The code imports specific functions from the d3 library including `scaleLinear`, `extent`, `axisLeft`, `axisBottom`, and `format` to construct the axes and scales.

Ccyanea1
61% match
Loading thumbnail…

Gist 484101

This visualization shows an interactive network of interconnected nodes, with each node representing a person and links showing connections between them. It reveals the structure of social ties, likely from a GitHub collaboration graph, by grouping related clusters. The rendering uses a canvas-based `d3.forceSimulation` with custom collision and link forces to position nodes, while a custom `d3.geoPath`-style projection maps node positions onto a projected sphere. The code also employs Canvas `getImageData` to detect node boundaries for hover interactions, and uses `transition.attrTween` for smooth link animations. The underlying data is loaded from a Gist, and the visualization runs entirely client-side without external data files.

DDylanFM
61% match
Loading thumbnail…

Links from my talk at SwiftSummit

This visualization maps a network of hyperlinks from a talk, revealing the connections between various web resources. The graph layout is computed using a force-directed algorithm, likely `d3.forceSimulation`, which positions nodes and edges to show clusters of related content. Each node represents a distinct URL, such as a blog post, a GitHub repository, a Stack Overflow question, or a gist, with edges indicating direct references between them. The data is sourced from the `gistfile1.txt` file, which lists these links, and the rendering demonstrates how disparate technical topics, including Silverlight, ReactiveExtensions, and Objective-C syntax, are interconnected through the author's curated set of references.

CColinEberhardt
61% match
Loading thumbnail…

Podcasts

This visualization maps a curated list of podcasts from a GitHub gist, plotting each title as a node in a force-directed graph. The layout uses `d3.forceSimulation` with `d3.forceLink` to connect podcasts sharing a common theme or network (e.g., history or NPR), while node size reflects the number of linked episodes. The graph is rendered on a Canvas via `getImageData` for pixel-level interactivity, with hover states highlighting related podcasts. Data comes directly from the markdown file, parsed client-side. The background is a subtle grid, and the overall effect emphasizes the interconnected web of intellectual audio content.

DDylanFM
60% match
Loading thumbnail…

Gist db32a113f546aa03b43c0e1f84f80d28

The visualization shows a force-directed network graph of GitHub gist data, with nodes representing individual gists and links showing relationships between them. It uses d3.forceSimulation to compute the layout, with node size encoding gist size and color indicating file type or language. The rendering relies on SVG elements updated per tick via the simulation’s tick event. The code loads a static JSON file containing preprocessed gist metadata, and does not use canvas or WebGL. The visualization highlights clustering patterns among related gists, revealing emergent communities in the dataset.

335degrees
60% match