I think Edward Hall's research on high and low context cultures apply exactly to computing. Computing cultures I revile are low context cultures
-Windows lusers
-Apple fans
-Web designers (php)
-Web designers (javascript)
-Web designers (proprietary languages)
A low context culture is a group with relatively little shared context. If you are like me, you have been subject to the unfortunate conversation - "Did you know the most ingenius programmers program in Microsoft Notepad [using Microsoft UTF-32 encoding] ?" That's not true, and is very silly. The most ingenius programmers use something like sam, ed, or ex. But the speaker, lacking context was trying to form the idea of a low level editor and sophisticated approach. Due to the missing context, they mashed together Microsoft Notepad and some vague notion of psychic smartness energy as a control. sam, ed and ex provide very powerful control as line editors, and are hopefully being operated in a UTF-8 environment. But knowing what any is like, or that they have resemblences as a herd of powerful line editors is a cultural context.
XML is an example of horrible low context communication. <this "was"="not">meant to be</this>. I won't retell its second hand origin story. Instead, consider the teary apologies on Matlab's website that even though they are a proprietary science computer program, they have the terrible embarrassment that they use C structs rather than XML for most data representation. A C struct is just a description of the layout of some memory, so that it can be read as intended when it was written, whereas XML is a collection of user defined particles, angle brackets, equals signs, quotes and other strings as a string. But I'm primarily a lisp hacker so let's move to another example.
Javascript json:
var dict = {foo:"bar",0:"buzz"}
dict.frob=[0,1,2]
dict.frob
dict["frob"]
dict[0]
dict.foo
dict["foo"]

And some lisp:
(defvar *dict* '((foo . "bar") (0 . "buzz")))
(push '(frob . #(0 1 2)) *dict*)
(cdr (assoc 'frob *dict*))

I guess that dict's json is formed as a hash table, giving dict a mixture of .accessors ["name"] [#], but sometimes only one or the other, sometimes names are strings and sometimes not. This is not high context (oh, in that context a name is written, which generates a dot accessor, which allows array access as a string of the namestring) but sloppy. Since the web designer it not a computer person, and has a smattering of blog posts that turned up on their web search, many sloppy low context functionalities are built in. It is like treating 5 different broken English pidgins as being one language. Low context.
In contrast in lisp I defvar a name to be an unevaluated list of conses, knowing the basics of LISt Processing. I can access them with #'assoc, though it returns the '(key . value) cons, so I have to take the cdr. I know that the default for #'assoc is :test 'eq, so names are compared (which is fast). If I wanted to just use strings, I could use :test 'string=. Common lisp doesn't really have a way to treat names as though they were strings, you would have to write your own lambda to do the comparisons. (Lisp has very many kinds of equality which are useful in different contexts, but none of them stringify arguments).
The high context nature of common lisp is surprising, since it is a second edition of an ANSI standard. I guess its parent lisps (which evolved into different common lisp compiler traditions) were higher context, but the committee also formed new contributions as a whole such as the common lisp object system. Implicitly, every compiler includes a MOP implementation that wasn't included in the CLOS standard.

tl;dr I am building a waterslide to bring people out of corporate web design and into common lisp by promoting my implementation of
the processing DSL (javascript P5js), 
the processing DSL (java Processing), 
the processing DSL (java Processing but running on Google Android on linux), 
the processing DSL (my implementation running on... abcl)