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

Re: feature incompatibilities

The worst one for me is static typing vs. lists of arbitrary
objects.  Type rules that don't allow lists of arbitrary 
objects effectively make macros impossible, since in the 
general case (implicit in CL, explicit in Arc) you want to
be able to insert actual objects in macro expansions, not
merely their representations.  --pg

--Michael Vanier wrote:
> 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?
> Mike