Poll: What are your liked and disliked programming languages?

As a disclaimer, I'm not much of a Perl programmer, though I intend on sharpening my skills with it after I'm done with a few other projects.

It appears that it's been trendy to hate Perl for a while now, with the often repeated argument that it looks like line noise.

Yet I've seen plenty of people praise APL for its obscure design, even though it is the definitive unreadable language. To the uninitiated at least, but that's the point. I haven't used it, but I don't hate it, and I think it deserves praise for being a non-Von Neumann language.

The thing is, Perl is pretty much the hacker's language. TMTOWTDI, although allowing for inconsistency, also makes it a highly flexible tool and allows for people to hack together code, be it prototyping or for real use, fairly quickly and to their own preferences. With first-class regexes it's also invaluable for text processing and sysadmin tasks for which a shell script becomes tedious.

The CPAN is also exhaustive and has solutions for so many tasks, making Perl a very tempting language for scripting and general problem solving.

Ultimately, Perl is a tool and it serves a very good purpose. It has the potential for abuse and its philosophy is based on individuality and being able to take several approaches, but that's what makes it beautiful.

Letting go of the line noise mentality and getting to know the language better helps.

Python code looks like Python code. Its structure is rigid enough to let you take on new Python code and (unless it's been too heavily inspired by Ruby code or similarly makes injudicious use of certain powerful Python features) you'll just "get it". Python's strict structure and syntax enhance this.

Ruby? Ruby is a language, but it's sort of more like a meta-language, with the popularity of the concept of using DSLs. Its studied lack of syntax makes it look to me like you often need to know the codebase to know what to do with the code.

(I speak this as one extensively familiar with Python but who has only a passing acquaintance with Ruby at present.)

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}

* 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.

It certainly has a hell of a lot more error checking going on than something like JavaScript by the virtue of being a statically typed language first with dynamic stuff second.

That's not to say that obscure bugs don't exist in the runtime as with every other runtime ever, but don't misrepresent something you don't seem to be well versed in.