Lambda (was: Refactoring in Tunes)

[Laurent Martelli]

>>>>> "billy" == btanksley  <btanksley@hifn.com> writes:

  >> My point is that those annotations are not needed to run the
  >> code, so a code evaluator should not be required to understand
  >> them. If annotations are included in the code, it's hard to
  >> commnicate your code to someone whose system does not understand
  >> annotations, or understands another type of anotations.

  billy> How many types of annotations do we need?  I'm only
  billy> suggesting one -- type annotations.  Very simple.  Easy to
  billy> write.  

Things are always simple at the beginning. But they don't usually
remain simple very long. We start requiring very small things which
may have no importance at the time we start requiring them, and a few
years later, we realize we've just another bloatware. It may be useful
not to understand annotations in minimalist embeded system where
resources are scarce and expensive.

  billy> If your system doesn't understand them it's BROKEN.  If your
  billy> system requires an annotation where I don't have one it's
  billy> also broken.

In oher words, your system is correct, and mine is broken just because
if different from yours ? :-)

  >> Annotations are like a style sheet, it just allow *some* kind of
  >> reader to *better* manipulate some objects. There can be many
  >> different annotations : params type, params names ... That's what
  >> I'm trying to say in my paper on separation of concerns : if it's
  >> not needed, don't require it.

  billy> But it's _not_ required unless it _is_ needed.  

I can't see where it could be neeeded. Do you have an example ?

  billy> Have you ever used ML?  

No.

  billy> There, type annotations are often needed.  Yet it's always
  billy> legal to use a type annotation -- unless, of course, your
  billy> function cannot possibly produce that type.  In that case,
  billy> you get an error, because you certainly made a mistake.

  >> Anyway, all this does not prevent anyone to build a frontend that
  >> integrates annotations with the code itself.

  billy> But that makes everyone's life SO much harder.  

I think that it remains to be seen. Make a frontend is not very
difficult, and once it's done, it's done.

  billy> I don't understand why you're suggesting it.

I think that separation of concerns is a very good principle. Proving
that some code has some properties should not be mixed with
interpreting that code. 

-- 
Laurent Martelli
martelli@iie.cnam.fr