[Python] Classi (Was: Walks like Python. Runs like C.)

[Manlio Perillo]

2015-01-14 14:25 GMT+01:00 enrico franchi <enrico.franchi a gmail.com>:

>
> 2015-01-14 11:06 GMT+00:00 Manlio Perillo <manlio.perillo a gmail.com>:
>
>> Il multiple dispatching è il mio preferito, perchè è una generalizzazione
>> dei singolo dispatch +- overloading.  Però è disponibile in pochissimi
>> linguaggi, magari c'è la fregatura...
>
>
> Io vedo due problemi principali nel MD. In primo luogo, che dal punto di
> vista dell'implementatore (e qui me ne frego abbastanza) e' una cosa
> parecchio piu' complessa, se si vuole farla efficientemente. Vedi per
> esempio la discussione di Alexandrescu su come farla in C++...
>

Non conosco i dettagli in Julia, però se l'hanno implementata significa che
non era troppo complessa da farlo (alcuni degli autori non mi sembrano
esperti di teoria dei compilatori).


> per farla efficiente e' veramente un dolore (e ci sono limitazioni). Se
> poi invece che una feature "un po' complicata da aggiungere" (vedri come
> fanno in C++ o come puoi fare in Python) e' pronta nel linguaggio e il
> programmatore tipo non e' il classico hacker lisp ... io vedo una ricetta
> per il disastro dal punto di vista della piattaforma.
>
>
Julia allora è un buon banco di prova.
I tipici utenti non sono programmatori esperti (nel senso di ingegneria del
software), anche se però non sono dei semplici utenti occasionali.

Poi sono d'accordo con te che e' la cosa migliore possibile. Pero' gia'
> fino a qui puo' andare male in due punti (efficienza e pragmatica).
>
> Poi c'e' il classico problema che se non metti altri limiti (vedi per
> esempio un qualche tipo di restrizione semi-artificiosa tipo essere nello
> stesso package)
>

Quello riguarda i metodi in Go, non il MD.


> rischi di avere problemi su come md di metodi "estesi" da persone
> differenti, senza contesto possano spaccare cose random.
>

Julia permette di aggiungere metodi senza restrizioni, perchè è una cosa
essenziale, quando, ad esempio, un modulo esterno definisce un nuovo tipo
di AbstractArray e deve cooperare con il resto del sistema.

Però la documentazione garantisce che i potenziali conflitti dovrebbero
essere tutti
rilevati.  Tra l'altro in Julia non c'è la promozione automatica dei tipi,
quindi le cose si semplificano (mentre in C++ lo vedo come un incubo).

In un certo senso il problema e' che potenzialmente hai l'equivalente di
> poter aprire classi per modificarle (e abbiamo visto come funziona bene in
> Ruby... ewk), ma su cose per definizione fuor di namespace.
>
>
Non ho mai studiato Ruby.  Cosa intendi con "aprire le classi"?
Tra l'altro ho notato che in Julia non sembra ci sia modo di proteggere
lo stato interno di un oggetto, sia tramite convensioni che tramite
supporto del linguaggio.


> Cioe', ci sono probabilmente modi di fare il tutto bene e tranquillo... ma
> ci vuole disciplina sia dall'implementatore (e va bene) sia soprattutto dal
> programmatore. Vanno trovati quali sono le limitazioni che rendono la
> feature sana, ma che al contempo non sono eccessivamente restrittive.
>
>
Come detto, non abbiamo abbastanza dati per capire se MD vada bene.
Del resto molte delle cose che sembravano buone si sono rilevate cattive
non appena i sistemi hanno cominciato a scalare sia in termine di linee di
codice che di programmatori.


Ciao  Manlio
-------------- parte successiva --------------
Un allegato HTML è stato rimosso...
URL: <http://lists.python.it/pipermail/python/attachments/20150114/f4ed5de2/attachment.html>