The resulting lists are quite similar but not identical, so i've analyzed them to find sets of languages that always or almost always appear at the top. I also made the corresponding 'most disliked' lists to find the most disliked languages.
On every 'most liked' list out of the above with some sort of control for wellknown-ness[1], the two most liked languages are C and Python. On every corresponding 'most disliked' list, the most disliked five languages are coldfusion, cobol, visual basic, actionscript, php.
Looking at various lists, the next most after C and Python liked usually tend to be lisp, scheme, lua, haskell. Then clojure, rust, erlang, go. Then sql. Then assembly, C#. Then ocaml, F#.
And after {coldfusion, cobol, visual basic, actionscript, php}, the next most disliked usually tend to be groovy or java.
In other words, the partial ordering seems to be approximately[2]:
{c, python} >
{lisp, scheme, lua, haskell} >~ {clojure} >~ {rust, erlang, go} >~ {sql} >~ {assembly, C#} >~ {ocaml, F#}
> ... >~
{groovy, java} >
{coldfusion, cobol, visual basic, actionscript, php}
It's interesting to contrast this 'most liked (controlling for wellknown)' ordering with the most (like+dislike)d counts, whose top 9 items are javascript, python, java, php, c, ruby, c++, sql, c#:
* Python is both extremely liked and extremely well-known
* Javascript is extremely well-known and is both liked and disliked.
* Java is extremely well-known and very disliked, and PHP is extremely well-known and extremely disliked.
* C is very well-known and extremely liked.
* Ruby and C++ are very well-known and both liked and disliked. SQL and C# are very well-known and more liked than disliked. Haskell and Go are moderately well-known and very liked.
* Lisp, Scheme, and Lua are not well-known but are very liked, and, to a lesser extent, Clojure, Rust, and Erlang.
[1] by which i mean, the six lists (like/dislike), ( (likeDirichlet/(likeDirichlet+dislikeDirichlet)), lower bound of confidence interval at 95% level ), (like/dislike)log(like) ), ( (like/(like+dislike))log(like) ), and ( (likeDirichlet/(likeDirichlet+dislikeDirichlet))*log(likeDirichlet).
[2] where >~ means a relation that holds for many of the lists under consideration, and > means a relation that holds for all of them.