First impressions

[BrickCaster]

in the endless search for the ultimate programming language, i finally have found newLISP.



i want to congratulate the author of newLISP, because after installing newLISP i have removed:  



* Galapagos

* SIOD

* MzScheme+Swindle

* SCM

* PocketScheme

* Rebol



from my HD, thus making my programmer practice and documentation much clearer.



only CAML has survived my newLISP installation.



yes, newLISP is that good.



as a functional language newLISP is perfect, i can't find anything i regret.



but you know people ever want more.

and want i want is the ultimate functional/OOP mix.



and regarding this criteria newLISP is also really elegant, actually better than many OOP language.



when i try to caraterize the newLISP OOP concept, the word that comes in my mind is "concatenation".

i mean it's a rather marginal approach, even more marginal than prototypes, wich are already really marginal compared to classes.



the main problem i have is the approach is so exotic that it can't be compared or even evaluated.



newLISP OOP approach is certainly elegant, however it will require investigation for me to evaluate its effectiveness.

the documentation does not help in this regard, concatenation is really different than inheritance and delegation, yet you ignore there is a difference, and speak like if the user is familiar with the concept.

because it's OOP does not mean it's familiar, in my opinion.



concatenation ressembles inheritance, yet there are no classes.

contexts ressemble prototypes, yet there is no delegation.

i mean isn't that somewhat schizophrenic?



i believe concatenation has been experimented in Kevo and a few other languages, then the approach has been abandoned.

do you feel concerned by these experiments?

or do you think newLISP is not concerned because it's primarily a functional language?



- damien

[nigelbrown]

Hello damien,



Could you explain why the newLisp OOP is concatenation? I'm not familiar with the term but looking at http://www.pasteur.fr/~letondal/object-based.html">http://www.pasteur.fr/~letondal/object-based.html

it defines it as:

_concatenation_: unrestricted composition of object interfaces.



Looking at http://www.dekorte.com/Proto/Chart.html">http://www.dekorte.com/Proto/Chart.html which says:

Prototype-based languages are object oriented langauges where a new object instance is "cloned" from existing live object(a prototype) instead of being constructed by a class.



I can see prototype-ing fits newLisp but the http://www.dekorte.com/Proto/Chart.html">http://www.dekorte.com/Proto/Chart.html description of kevo as having

"concatenation(unrestricted composition of object interfaces)" doesn't seem how newLisp does it?



Regards and welcome



Nigel

[BrickCaster]

Hello nigelbrown,



seems you are right, i am more familiar with delegation, protos and parents, so i misbelieved when it's not delegation then it's concatenation.



also seems the newLISP approach is not so marginal, the popular Rebol language has the same actually.



i think the correct term is "embedded object language".



another thing that i realize is newLISP allows a multiple-inheritance effect by repeating "new" :



(context 'Counter)

  (define value 0)

  (define (plus n) (inc 'value n))

(context 'MAIN)



(context 'DeCounter)

  (define value 0)

  (define (minus n) (dec 'value n))

(context 'MAIN)



(new Counter 'BiCounter)

(new DeCounter 'BiCounter)





great :)

i start to enjoy the system.



a great feature that Kevo has is methods are logically embedded, but the implementation actually share them as mush as possible, thus you have both the simplicity of a prototype language and the memory efficency of a class language.



regards,



- damien