[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

feature incompatibilities

It occurs to me that a lot of the current landscape of programming
languages is determined by which language features don't play well
together.  I can think of several of these incompatibilities:

-- explicit pointer arithmetic and garbage collection

-- strong static typing and reflection

-- static typing and dynamic typing

-- imperative programming and implicit lazy evaluation

None of these is absolute.  For instance, there are (conservative) GCs for
C/C++, java has strong(ish) static typing but also has reflection, Dylan,
Curl and Common Lisp combine (to some extent) static and dynamic typing
(and reflection), Haskell uses monads to get the effect of imperative
programming, etc.  However, it seems like it's very hard if not impossible
to have such feature pairs together in one language without compromising
one or the other of the pair.  For instance, conservative GC is not
guaranteed to be reliable.

I think a lot of us dream of creating one language that could do everything
well, but I think the incompatibilities I listed above suggest that such a
dream is misguided.  Can anyone think of other incompatibilities of this
kind?  Any other opinions?