

Programming Language Classification Table - r11t
http://techdistrict.kirkk.com/2009/03/30/programming-language-classification/

======
tetha
Meh, this is not useful.

The first thing: static typing is not static typing (yes, twice) dynamic
typing is not weak typing is not strong typing. C is borderline static typing.
Certainly, you have to say 'yes, this foo is an integer, this bar is a char
__' and the compiler will complain if you do foo = bar... but on the other
hand, something like _((char_ )(void _)( &foo)) will probably work (untested).
I am not aware of these such possibilities in Haskell.

Furthermore, Haskell (for example) is statically typed, but I don't have to
annotate everything with types, compared to, say, C, C# (even though this
comparision is unfair, as Type inference in OOP-Languages requires exponential
time). This is also a pretty big difference in 'static languages'. (In fact,
Haskell and Python programs appear to converge to a certain common structure,
which is very interesting).

The second thing: dynamic typing vs dynamic typing. What about weak typing vs
strong typing? Python is dynamically typed, by Python is strongly typed, so an
Integer is an Integer and remains an Integer unless told otherwise. In weakly
typed languages, this is not the case. So just 'dynamic' is not useful either.

And then, the paradigms. Argh. Those hurt my eyes by now. OCaml is functional,
and Haskell is functional. Haskell is _pure _, Ocaml is not. This is a
gigantic major difference, let alone the_ functional subsets* of other
languages. OOP? Hah. Just consider Icons inheritance vs Javas inheritance.
Javas inheritance goes most specific towards least specific, overriding
methods. Icon goes least specific towards most specific, giving the subclass
implementor extension points where he can add further functionality. And don't
even start to think about Common Lisps object orientation, or dylans, which is
entirely different. Those terms, in my opinion, are far far too broad in order
to describe a language well. Certainly, you might get a feeling what ML is, if
I say "ML is functional", but overall, you know nothing about the code. (And
don't even think about multi-paradigm languages).

So, overall: The table does not really tell anything, especially if you
consider that major languages are missing. Even some toy example like faculty
or fibonacci in each of these languages would tell everyone more than this.

~~~
dkersten
Strong and weak typing isn't a very useful designation. most people take
string typing as _what my favorite languages have_ and weak typing as
everything else. By the most common definition, strong typing seems to mean
that you can never have implicit type casts, while with weak typing you can.

Again, by common definitions, static typing is when the compiler always knows
the types (either through type declarations or type inference) and dynamic
typing the types are not known until runtime.

Going by these definitions, C uses weak static typing. OCaml uses strong
static typing. Python uses weak dynamic typing.

By these definitions, haskell _IS_ statically typed because it uses type
inference, but the compiler still knows the type at compile time.

Paradigms is messy because there are more paradigms that listed in the table
and many more hybrids.. I guess its useful as a quick guideline, but I
certainly wouldn't base.. well, anything, on this.

So, in the end, I have to agree. The table is interesting and fun, but not
useful.

------
gdp
This basically seems like a table to compare attributes of languages that are
much less different from each other than they are from everything else. I
don't think it usefully captures any attributes that people actually care
about.

------
jrockway
Most of my Perl code is OO or functional, but neither are listed under Perl's
definition.

How is Smalltalk "unmanaged"?

Haskell is missing.

Common Lisp is missing.

Scheme is missing.

This chart is meaningless.

~~~
cracki
I'd like to see some functional perl code.

~~~
papaf
<http://hop.perl.plover.com/>

------
loup-vaillant
No Haskell, no concatenative language, no distinction between explicit typing
and implicit typing (one of the key differences between F# and C#)… That could
use some improvement.

------
DrJokepu
One correction: C# (beginning version 3) is a multiparadigm language; it
supports functional programming (lambda expressions) just as much it supports
imperative programming. Anything you can do in C# in an imperative style, you
can do it the functional way as well.

------
mhansen
Javascript not functional?!?

~~~
dkersten
I'd say its a prototype based imperative OO language with _some_ functional
features.

<http://en.wikipedia.org/wiki/Functional_programming>

------
mahmud
defined "Managed" || die "don't shoot, I am only an MCSE!";

------
ilyak
WTF is "Declarative" and how XSLT is declarative?

XSLT is functional!

XSLT/XPath can also be statically typed: XSLT compilers happily infer types of
all expressions in their XPath.

~~~
spectre
Functional is a type of declarative language.

<http://en.wikipedia.org/wiki/Declarative_programming>

~~~
ilyak
In computer science, declarative programming is a programming paradigm that
expresses the logic of a computation without describing its control flow.

XSLT does describe control flow pretty explicitly; most functional languages I
know, too. In other hand, languages like Java allow the VM to shuffle their
control flow considerably.

I vote for dropping "declarative". Call query languages query languages,
functional functional.

~~~
wlievens
Isn't Prolog declarative?

~~~
OliverM
Prolog has a logic core but also some imperative features. Programmes can be
specified in a purely declarative manner.

~~~
wlievens
Yes, I was discarding the imperative features.

It always struck me as odd how purists adore Prolog for its conceptual
clarity, but then as soon as you want to write anything nontrivial in it, they
come and tell you to place "cuts" everywhere, exposing the imperative
execution order throughout the program. IMHO this is evidence of Prolog being
a failure.

------
rick2047
isnt groovy just java on steroids?and with no haskell or any of the Lisps this
list is truely meaningless.

~~~
jurjenh
Clojure is a LISP-1

