The Idea
Recently, I was thinking about visualizing relations among different programming languages, and a thought has crossed my mind:
Methodology
- I took quite a few more-or-less popular programming languages (33 to be exact); however, I explicitly restricted myself to more-or-less general-purpose programming languages. This eliminated DSLs such as R, as well as all dialects of SQL, HTML, CSS, and MATLAB.
- For each language, I took a sum of normalized weights from three sources: [TIOBE][Stack Overflow][IEEE], and took it as a “weight” of the programming language.
- To consider programming languages as a kinda social network, a metric is needed to express their inter-relations. I decided to use Google search on (a) “<language1> vs <language2>” and “<language2> vs <language1>” (quoted!), add numbers of returned pages as reported by Google, and consider this as a metric for inter-relation between two languages (NB: any requests without quotes grabbed too much garbage – such as pages discussing Dudley C Haskell when requesting unquoted C Haskell).
- After initial data was gathered, I took R (which ironically was eliminated from the analysis as discussed above), and built a graph, with languages being vertices (with weights), and inter-relation data from Google being weights of the edges of the graph.
- Then, I used R’s igraph package to visulaize the graph, using its Fruchterman-Reingold algorightm (pretty much standard for this kind of visualisations) to draw the graph.
- NB: as with any such visualization, the result is inherently random, so different pictures are possible based on the same data. I experimented a bit and took the picture which I considered more visually appealing.
- All the raw data and programs used to visualize are available, and I am going to publish it soon too.
The result is shown on the picture above.
Sanity Check
It is interesting to note that even such a simple result (which did NOT use any a priori information about the nature of the languages), did show quite a few commonalities as we could expect based on intrinsic knowledge about the languages; in particular, the following intuitively-expected clusters can be seen:
- C-C++-Rust (low-level languages w/o GC)
- A looser cluster of Delphi-asm-Lua-C-C++-Rust (embedded)
- C#-Java (Garbage-Collected statically-typed)
- Python-JS-PHP (dynamically-typed somewhat-web-related)
- Objective-C/Swift (Apple)
- Elixir-Erlang-Haskell-Scala-Clojure-F#-OCaml (mostly-functional)
- Racket-Scheme-LISP-Clojure (LISP-like)
Overall, I’d say that in spite of original data being very generic and without any knowledge about the languages as such, results do look reasonably sane to me.
Conclusion
We considered an unorthodox way to visualize programming languages and their inter-relations; we also cross-checked that it makes sense given our intrinsic knowledge about the languages involved, and it does look ok. What can be derived from such a visualization – is yet to be seen; for now – let’s just enjoy the view…
References
[TIOBE] https://www.tiobe.com/tiobe-index/
[Stack Overflow] https://insights.stackoverflow.com/survey/2018/
[IEEE] https://spectrum.ieee.org/static/interactive-the-top-programming-languages-2018
Acknowledgement
Cartoons by Sergey Gordeev
from Gordeev Animation Graphics, Prague.P.S.
Don't like this post? Criticize↯
P.P.S.
We've tried to optimize our feed for viewing in your RSS viewer. However, our pages are quite complicated, so if you see any glitches when viewing this page in your RSS viewer, please refer to our original page.