Re: Enums vs. Algebraic Datatypes

>>>some of it has to do with development priorities
>>>      
>>>
>>We don't have a list with priorities it depends on the amount of work
>>to implement/fix something and user feedback is a big factor.
>>    
>>
>
>Maybe it would be better to have a top 5 development priorities
>  
>
We do have the roadmap page which I think fills this role.

>>What are your obstacles in using Nice? 
>>    
>>
>
>documentation, documentation, documentation ;-)
>  
>
Bryn is doing a great job with the user manual. It obviously takes time 
to come up with good examples and good way to present the existing features.

We are trying to do as much as possible in libraries rather than in the 
language. So once nicedoc is operational, there should be more 
documentation available about those features.

BTW, I think Isaac's numerous examples in the Wiki pages are a great 
complement to help people learn Nice. Surely in the process of writing 
them he is also teaching himself ;-)

>Maybe confusion about what kind of language Nice is - a Java 1.6, an
>OO/Functional hybrid, a multi method language - there are too many
>themes. 
>
I wouldn't say Java 1.6. At least 2.0 :-)
We used to speak (not too seriously) about a Java++ with my former advisor.
That is, it's not just about "let's add this one feature to Java", like 
GJ or MultiJava do (which is a fine approach, just more restrictive), 
but a deeper change, while building on the strengthes of Java (the JVMs, 
the libraries, the familiarity of many developers).

So I don't see these goals as incompatible. The big goal is to create a 
new language that is "more expressive, more modular and safer" than 
Java, while not breaking existing practices when they are fine (but 
focus on those that need to change). The functional and the multi-method 
aspects are means to this end.

>It would help to understand what position Nice takes compared
>to other languages - Java 1.5, Multi Java, Scala, Groovy.
>  
>
Java and MultiJava are I think covered above.

Scala: I still need to understand it fully, but it seems the biggest 
differences will be about Scala being class-based, and being farther 
from Java (in syntax, and less integration it seems, like their own 
collection hierarchy).

Groovy: it seems like an offset of the dynamically typed world. Allows 
cool features compared to Java while still compiling for the JVM (but 
Jython already feels that niche). I suppose most people will clearly be 
attracted towards Groovy or towards Nice depending on how they stand on 
the static/dynamic typing issue.

Daniel




-------------------------------------------------------
The SF.Net email is sponsored by EclipseCon 2004
Premiere Conference on Open Tools Development and Integration
See the breadth of Eclipse activity. February 3-5 in Anaheim, CA.
http://www.eclipsecon.org/osdn