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.