[generico]Costruttori con molti parametri

[RaouL_BennetH]

Ciao a tutti :)

La mia più che altro è una curiosità..

Vi capita mai di avere a che fare con costruttori che abbiano molti parametri ?

per es.:



public DatiAnagrafici(cognome, nome, dataDiNascita, comuneDiNascita, provincia, blablabla



E' una cosa normale, o c'è un modo più 'elegante' in presenza di un oggetto
con molti campi ?

Grazie :)

RaouL.

[banryu79]

Se stiamo parlando di semplificare un metodo (costruttore o altro) e in particolare di ridurre la sua lista dei parametri, penso la cosa vada vista caso per caso.

Ad esempio, eaminando quello che hai postato, mi vengono in mente due scenari diversi e due possibilità:

1) la classe DatiAnagrafici è un "value object" che mappa la tabella di un db relazionale: in questo caso non mi pare si possa fare molto, visto che si e' costretti a rispettare la struttura della tabella che giustifica l'esistenza della classe stessa.

2) la classe DatiAnagrafici non è un value object e quindi posso rifattorizzarla come mi pare.
In questo caso vale la pena di osservare che potrei dividere i parametri in due gruppi: uno relativo al concetto di "Persona" (cognome, nome, dataNascita) e l'altro relativo al concetto di "Indirizzo" o "Luogo" cha a dir si voglia (comune, provincia, ecc...).

In questo caso potrei vedere il costruttore di DatiAnagrafici così:

DatiAnagrafici(Persona p, Indirizzo luogoDiNascita) {...}

oppure, più semplicemente, potrei eliminare DatiAnagrafici e stabilire che Persona ha un Indirizzo di nascita (così come ha una Data di nascita): tutte le info che aveva DatiAnagrafici sono ora contenute in Persona mediante le info che possiede direttamente e quelle che referenzia indirettamente grazie alle relazioni che ha con altre classi (Indirizzo, Data, ecc...)

class Persona
{
private String nome;
private String cognome;
private final Indirizzo luogoDiNascita;
private final Data dataDiNascita;
private Indirizzo residenza;
...

public Persona(String nome, String cognome, Data dNascita,
Indirizzo iNascita) {...}
...
public void getLuogoDiNascita(Indirizzo ind) {luogoDiNascita=ind;}
public void setResidenza(Indirizzo res) {residenza=res;}
...
}


Alla fine tutto dipende dal modello che si deve rappresentare...



Se più in generale ti interessanto le tecniche di refactoring del codice qui (http://sourcemaking.com/refactoring) trovi un buon punto di partenza.

[cdimauro]

Dipende anche dal linguaggio. Esempio:

>>> class c:
... def __init__(self, *Args, **Keys):
... self.Arguments = Args
... self.Keywords = Keys
... def __str__(self):
... return 'Mi hai passato gli argomenti %s e le keyword %s' % (self.Arguments, self.Keywords)
...
>>> a = c(1, 2, 3, a = 'Qui', b = 'Quo', c = 'Qua')
>>> print a
Mi hai passato gli argomenti (1, 2, 3) e le keyword {'a': 'Qui', 'c': 'Qua', 'b': 'Quo'}

[vhost87]

Nooooo che brutta sintassi cdimauro :D :D :D :D

prrrr :p
PS. ottimo esempio! Grande il pitone! ;)

[banryu79]

Dipende anche dal linguaggio. Esempio:
...snip...


Equivalente tradotto in Java;


public class Prova
{
Integer[] args;
Map<String,String> keys;

public Prova(Integer[] args, Map<String,String> keys) {
this.args = args;
this.keys = keys;
}

@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("Mi hai passato gli argomenti");
for (Integer i : args) {
sb.append(" ").append(i).append(" ");
}
sb.append("e le keyword");
for (Map.Entry<String,String> keyword : keys.entrySet()) {
sb.append(" ")
.append(keyword.getKey()).append(" = ").append(keyword.getValue())
.append(" ");
}
return sb.toString();
}

public static void main(String... argv) {
Integer[] args = {1,2,3};
Map keys = new HashMap<String,String>();
keys.put("a", "Qui");
keys.put("b", "Quo");
keys.put("c", "Qua");

Prova a = new Prova(args, keys);
System.out.println(a);
}
}

// output:
// Mi hai passato gli argomenti 1 2 3 e le keyword b = Quo c = Qua a = Qui


Al di la della maggiore verbosità del codice Java non mi pare che il numero di argomenti passati ad un metodo, in questo caso il costruttore, sia maggiore.
Immagino in C# sia lo stesso, e in genere ovunque uno possa passare come argomento ad un metodo un tipo-collezione, per così dire.

[RaouL_BennetH]

Ciao a tutti ! :)

allora, in ordine :

@Banryu79:

Anche io avevo pensato a semplificare il costruttore più o meno nel modo da te indicato ma, se è vero che semplifico il costruttore, vado poi a fare le stesse cose all'interno del metodo, per esempio:



void AggiungiNominativo(Persona p)
{
//necessariamente dovrò creare o qui o altrove
//un oggetto Persona e:
p.Cognome = valore;
p.Nome = valore;
etc..
}



Nella mia domanda, non c'era riferimento ai legami con i db in quanto
come correttamente sottolineato da te, li per forza di cosa bisogna
semplicemente rappresentare la tabella e amen.


@cdimauro

In effetti ho visto che sia in java che in c# esiste una
tecnica particolare per passare molti parametri (indicata però
solo nei casi in cui non se ne conosca a monte il numero)


//Java
public double getQualcheEuro(double... euri);

//C#
public double GetQualcheEuro(params[] double);

//o anche ma non è CLS; dalla documentazione ufficiale

[assembly: CLSCompliant(true)]
namespace UsageLibrary
{
public class UseParams
{
// This method violates the rule.
[CLSCompliant(false)]
public void VariableArguments(__arglist)
{
ArgIterator argumentIterator = new ArgIterator(__arglist);
for(int i = 0; i < argumentIterator.GetRemainingCount(); i++)
{
Console.WriteLine(
__refvalue(argumentIterator.GetNextArg(), string));
}
}

// This method satisfies the rule.
public void VariableArguments(params string[] wordList)
{
for(int i = 0; i < wordList.Length; i++)
{
Console.WriteLine(wordList[i]);
}
}
}
}

[banryu79]

In effetti ho visto che sia in java che in c# esiste una
tecnica particolare per passare molti parametri (indicata però
solo nei casi in cui non se ne conosca a monte il numero)

Infatti, se è sufficiente passare tipi di dato-collezione monodimensionali esistono i varargs.

[cdimauro]

Le soluzioni Java e C# possono sembrare simili, ma sono molto diverse: state semplicemente utilizzando classi di tipo lista o mappa/dizionario per cercare di mascherare il passaggio di una quantità variabile di parametri.

Anche in Python esistono da tempo le liste e le mappe/dizionari, per cui si poteva applicare la stessa soluzione.

Ma qui stiamo parlando di parametri in quantità variabile, cioè una funzione/metodo cambia la sua arietà (http://it.wikipedia.org/wiki/Arietà) dinamicamente in base al chiamante.

Può sembrare sottile, ma col seguente esempio si capisce perché la differenza è, invece, notevole:
>>> class c:
... def __init__(self, a, b, c, x = 1, y = 2, z = 3, *Args, **Keys):
... Args = (a, b, c) + Args
... Keys.update({'x' : x, 'y' : y, 'z' : z})
... self.Arguments = Args
... self.Keywords = Keys
... def __str__(self):
... return 'Mi hai passato gli argomenti %s e le keyword %s' % (self.Arguments, self.Keywords)
...
>>> a = c(1, 2, 3, 4, 5, Emi = 'Qui', Eli = 'Quo', Evy = 'Qua')
>>> print a
Mi hai passato gli argomenti (1, 2, 3) e le keyword {'Evy': 'Qua', 'Eli': 'Quo', 'y': 5, 'x': 4, 'z': 3, 'Emi': 'Qui'}
>>> a = c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, Emi = 'Qui', Eli = 'Quo', Evy = 'Qua')
>>> print a
Mi hai passato gli argomenti (1, 2, 3, 7, 8, 9, 10) e le keyword {'Evy': 'Qua', 'Eli': 'Quo', 'y': 5, 'x': 4, 'z': 6, 'Emi': 'Qui'}

[banryu79]

Ma qui stiamo parlando di parametri in quantità variabile, cioè una funzione/metodo cambia la sua arietà (http://it.wikipedia.org/wiki/Arietà) dinamicamente in base al chiamante.

Può sembrare sottile, ma col seguente esempio si capisce perché la differenza è, invece, notevole:

Se quando hai tempo puoi spiegarmi più esplicitamente la cosa, perchè ho letto con calma la definizione di arietà al link postato, e ho provato a leggere con calma il codice Python postato, ma per mia ignoranza del linguaggio non riesco intanto a capire di preciso i singoli passi che compie anche a fronte di due esempi forniti di input e relativi output, e poi (di conseguenza probabilmente) non riesco a cogliere la sottile differenza da te citata.

[cdimauro]

Certamente. Con arietà intanto definiamo il numero di argomenti accettati (o che si aspetta) una determinata funzione (o metodo).

Nel caso in oggetto, abbiamo un costruttore (quindi una funzione) della classe c che accetta almeno 6 parametri, di cui i primi 3 fissi / obbligatori, e i seguenti 3 opzionali.

Inoltre può accettare un qualunque altro numero di parametri, siano essi con o senza nome, i quali, se presenti, vengono inseriti nella tupla (è una lista non modificabile) Args oppure nel dizionario (mappa) Keys rispettivamente.

Tutti i parametri definiti si possono referenziare col nome. Esempio:
>>> a = c(a = 0, b = -1, c = -2)
>>> print a
Mi hai passato gli argomenti (0, -1, -2) e le keyword {'y': 2, 'x': 1, 'z': 3}
Quando viene creata una nuova istanza di c, viene invocato il suo costruttore e gli vengono passati tutti i parametri, procedendo nel seguente modo:
- se ci sono parametri obbligatori, questi devono essere necessariamente presenti (e lo si può fare senza specificare il nome, visto che sono sempre i primi, oppure col nome, come ho mostrato poco sopra);
- se sono presenti altri parametri senza che venga specificato il loro nome, questi vengono assegnati agli eventuali parametri con valore di default (x, y e z, nello specifico caso);
- se sono presenti ulteriori parametri senza nome, vengono tutti inseriti in *Args (il nome ovviamente si può cambiare);
- se sono presenti parametri con nome che non coincidono coi parametri con valori predefiniti, questi vengono tutti inseriti in **Keys (anche qui si può cambiare il nome).

Le istruzioni:
Args = (a, b, c) + Args
Keys.update({'x' : x, 'y' : y, 'z' : z})
servono rispettivamente a creare una tupla che abbia come primi 3 elementi a, b, e c, e a seguire tutti i parametri senza nome che sono stati "raccolti" dalla funzione, e ad aggiornare il dizionario contenente i parametri con nome col valore dei 3 parametri con nome previsti dalla funzione.

Se ci sono dubbi, fammi/temi sapere.

[vhost87]

cdimauro docet!

[banryu79]

Se ci sono dubbi, fammi/temi sapere.

Ok, mi ero "perso" a causa dei parametri con valore di default, che in Java non ci sono (e la mia memoria storica del C++ ormai è stata relegata chissà dove...), mea culpa. Ora ho capito, grazie alla tua spiegazione, ma la cosa (probabilmente perchè non ne sono abituato) mi pare un poco error-prone.

Più che altro, mi domando in quali situazioni/scenari possa tornare molto comoda questa funzionalità?

[Kralizek]

Data questa classe:


public class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }
public string City { get; set; }
public DateTime DateOfBirth { get; set; }
public Person.Sex Sex { get; set; }

public enum Sex {
Male = 0, Female = 1
}
}


in C#, si puó usare:


Person p = new Person
{
FirstName = "Salvatore",
LastName = "Esposito",
City = "Napoli",
DateOfBirth = new DateTime( 1970, 12, 1),
Sex = Person.Sex.Male
};


o anche solo un sottoinsieme delle proprietá.

[cdimauro]

Ok, mi ero "perso" a causa dei parametri con valore di default, che in Java non ci sono (e la mia memoria storica del C++ ormai è stata relegata chissà dove...), mea culpa. Ora ho capito, grazie alla tua spiegazione, ma la cosa (probabilmente perchè non ne sono abituato) mi pare un poco error-prone.
Mumble. Perché? Hai in mente qualche caso d'uso che potrebbe esserlo?
Più che altro, mi domando in quali situazioni/scenari possa tornare molto comoda questa funzionalità?
Non hai idea in quante. :D E anche la possibilità di poter richiamare una funzione passandole più argomenti, con o senza nome, che vengono poi raccolti nelle rispettive Args e Keys, è estremamente utile.
Data questa classe:


public class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }
public string City { get; set; }
public DateTime DateOfBirth { get; set; }
public Person.Sex Sex { get; set; }

public enum Sex {
Male = 0, Female = 1
}
}


in C#, si puó usare:


Person p = new Person
{
FirstName = "Salvatore",
LastName = "Esposito",
City = "Napoli",
DateOfBirth = new DateTime( 1970, 12, 1),
Sex = Person.Sex.Male
};


o anche solo un sottoinsieme delle proprietá.
Però puoi soltanto (pre)assegnare valori ad alcune proprietà definite: non puoi fare altro, come ad esempio ho fatto io prima in cui ho già "giocato" un po' con tutti i parametri che erano stati passati. ;)

x michele.broggi: esagerato! :D

[vhost87]

Sono serio cdimauro, tu sei da curare!
Ciò che hai scritto è sensazionale per gli occhi di un programmatore :D , quasi come alcune parti del kernel di Linus ahahah :D

[U235]

Ma qui stiamo parlando di parametri in quantità variabile, cioè una funzione/metodo cambia la sua arietà dinamicamente in base al chiamante.


ciao,

mi scusa in anticipo per la mia ignoranza, ma con params in c# non ottieni il risultato di cambiare dinamicamente il numero di parametri passati? ma forse non mi è ancora molto chiaro il significato di questa discussione :cry: :muro:

edit
capisco che sia comodo con i parametri con valore di default, ma se in un linguaggio non ci sono è chiaro che sia diverso, e il metodo piu' elegante sarà diverso. Ma forse non ho afferrato la domanda iniziale.

[RaouL_BennetH]

Per fugare un pò ogni dubbio:

Usare in C# i params, equivale a non sapere quanti parametri possano essere passati in anticipo, ma, per la mia domanda iniziale, non era questo il caso che mi incuriosiva.

La mia domanda era rivolta invece quando in presenza di un numero elevato e fisso di parametri, ci fosse un modo migliore per non passarli tutti nel costruttore o in un metodo.

Giustamente Banryu79 ha fatto una degna osservazione sull'ambito:

1) devi rappresentare tabelle di un db ? <= ciccia :D

2) devi rappresentare altro ? <= probabilmente il design è sbagliato a monte
e c'è bisogno di refactor.

Però... per la (1) forse forse con un ORM si potrebbe ottenere un design migliore .

Questo, ovviamente, non toglie nulla a quanto mostrato da cdimauro con python, anche perchè il titolo è appunto [generico] e non mi riferivo in particolare ad un linguaggio :p

chissà che un domani non riesca a farci qualcosina pure io col pitone oltre a mangiarmene di crudi per colazione :sofico:

[U235]

Per fugare un pò ogni dubbio:

Usare in C# i params, equivale a non sapere quanti parametri possano essere passati in anticipo, ma, per la mia domanda iniziale, non era questo il caso che mi incuriosiva.


ok


La mia domanda era rivolta invece quando in presenza di un numero elevato e fisso di parametri, ci fosse un modo migliore per non passarli tutti nel costruttore o in un metodo.


ok, mi era chiara allora :)

secondo me dipende dai linguaggi, da come devi utilizzarli ecc.


Questo, ovviamente, non toglie nulla a quanto mostrato da cdimauro con python, anche perchè il titolo è appunto [generico] e non mi riferivo in particolare ad un linguaggio :p


che abbia fatto un ottima dimostrazione di come si possono fare le cose con python credo non ci siano dubbi :) per quanto posso capirne io. (era python :stordita: )


chissà che un domani non riesca a farci qualcosina pure io col pitone oltre a mangiarmene di crudi per colazione :sofico:

:eek: :cry:

[cdimauro]

Sono serio cdimauro, tu sei da curare!
Eh, no: adesso non ci siamo proprio.
Ciò che hai scritto è sensazionale per gli occhi di un programmatore :D , quasi come alcune parti del kernel di Linus ahahah :D
Che per me non è affatto un complimento.
ciao,

mi scusa in anticipo per la mia ignoranza, ma con params in c# non ottieni il risultato di cambiare dinamicamente il numero di parametri passati? ma forse non mi è ancora molto chiaro il significato di questa discussione :cry: :muro:

edit
capisco che sia comodo con i parametri con valore di default, ma se in un linguaggio non ci sono è chiaro che sia diverso, e il metodo piu' elegante sarà diverso. Ma forse non ho afferrato la domanda iniziale.
Sì, *Args è equivalente a params di C#. Sul resto vedo che ha già risposto Raoul.
Per fugare un pò ogni dubbio:

Usare in C# i params, equivale a non sapere quanti parametri possano essere passati in anticipo, ma, per la mia domanda iniziale, non era questo il caso che mi incuriosiva.

La mia domanda era rivolta invece quando in presenza di un numero elevato e fisso di parametri, ci fosse un modo migliore per non passarli tutti nel costruttore o in un metodo.

Giustamente Banryu79 ha fatto una degna osservazione sull'ambito:

1) devi rappresentare tabelle di un db ? <= ciccia :D

2) devi rappresentare altro ? <= probabilmente il design è sbagliato a monte
e c'è bisogno di refactor.

Però... per la (1) forse forse con un ORM si potrebbe ottenere un design migliore .

Questo, ovviamente, non toglie nulla a quanto mostrato da cdimauro con python, anche perchè il titolo è appunto [generico] e non mi riferivo in particolare ad un linguaggio :p

chissà che un domani non riesca a farci qualcosina pure io col pitone oltre a mangiarmene di crudi per colazione :sofico:
In genere sono i pitoni che mangiano gli altri. :D

Comunque male non ti farà di sicuro lavorare con Python. :cool:

[Kralizek]

Però puoi soltanto (pre)assegnare valori ad alcune proprietà definite: non puoi fare altro, come ad esempio ho fatto io prima in cui ho già "giocato" un po' con tutti i parametri che erano stati passati. ;)

puoi "giocare" con i valori se specifichi il codice del setter :)

private DateTime _DateOfBirth;
public DateTime DateOfBirth
{
get { return _DateOfBirth; }
set
{
if (value > DateTime.Today)
throw new OMGException("OMG!");
_DateOfBirth = value;
}
}

[vhost87]

Che per me non è affatto un complimento.

Peccato ;)

[cdimauro]

puoi "giocare" con i valori se specifichi il codice del setter :)

private DateTime _DateOfBirth;
public DateTime DateOfBirth
{
get { return _DateOfBirth; }
set
{
if (value > DateTime.Today)
throw new OMGException("OMG!");
_DateOfBirth = value;
}
}

Questo è possibile anche con Python (si chiamano properties), ma è una cosa un po' diversa. :fagiano:

[cionci]

Se il costruttore ha troppi parametri io ho spesso un sentore di refactoring :D

Comunque la cosa che solitamente si fa è raggruppare il tutto in varie strutture dati coerentemente con i dati.

Imho qualsiasi costrutto che permetta di specificare una quantità di parametri variabile usato per passare un numero di parametri costante è un obbrobrio.
Sono una schifezza per chi legge. Io sarei per la bacchettata sulle manine :D

[cdimauro]

Se il numero di parametri passati è costante, sembra pure a me da idioti utilizzare un costrutto sintattico per accettarne in quantità variabile.

Gli strumenti vanno usati se servono realmente, non per puro esercizio. ;)

[vhost87]

Se il numero di parametri passati è costante, sembra pure a me da idioti utilizzare un costrutto sintattico per accettarne in quantità variabile.

Gli strumenti vanno usati se servono realmente, non per puro esercizio. ;)

In effetti... :rolleyes:
Io lo userò per esercizio :D :D :D
Almeno imparo ciò che hai fatto, stupendo :D

[malocchio]

Aggiungerei l'opzione in NetBeans
"premi punto (.) seleziona Costruttore(...) Generate", il gioco è fatto.
Ovviamente dopo aver definito le varie variabili d'istanza.

Il guaio è che il codice generato non fa altro che assegnare alle variabili d'istanza il valore dei parametri tramite =, senza usare i setter. (O magari li usa se sono già stati scritti, non ho mai provato :confused:).
Magari la funzionalità si può personalizzare....

Sono d'accordo con Cionci, quando i parametri sono davvero tanti vuol dire che bisognerebbe creare qualche classe in più per "raggrupparli"

ps. Carine le "proprietà" del C# / VB, molto meglio dei getter e setter del Java!

[Kralizek]

Aggiungerei l'opzione in NetBeans
"premi punto (.) seleziona Costruttore(...) Generate", il gioco è fatto.
Ovviamente dopo aver definito le varie variabili d'istanza.

Il guaio è che il codice generato non fa altro che assegnare alle variabili d'istanza il valore dei parametri tramite =, senza usare i setter. (O magari li usa se sono già stati scritti, non ho mai provato :confused:).
Magari la funzionalità si può personalizzare....

Sono d'accordo con Cionci, quando i parametri sono davvero tanti vuol dire che bisognerebbe creare qualche classe in più per "raggrupparli"

ps. Carine le "proprietà" del C# / VB, molto meglio dei getter e setter del Java!

certe volte creco che il java abbisogni di una rinfrescata... per certi versi é vecchio.

in confronto c# 4 è da :spruz: ... properties ed automatic properties, linq, costruttori automatici, type inference, supporto al DLR (guardatevi cosa si riesce a fare con ExpandoObject usato con dynamic), lambda expressions, delegates e inline functions. Ah, dimenticavo... PLINQ.

Oramai mi diverto a mandare pezzi di codice c# ad un mio amico che lavora in java e vederlo rosicare...

[mindwings]

certe volte creco che il java abbisogni di una rinfrescata... per certi versi é vecchio.

in confronto c# 4 è da :spruz: ... properties ed automatic properties, linq, costruttori automatici, type inference, supporto al DLR (guardatevi cosa si riesce a fare con ExpandoObject usato con dynamic), lambda expressions, delegates e inline functions. Ah, dimenticavo... PLINQ.

Oramai mi diverto a mandare pezzi di codice c# ad un mio amico che lavora in java e vederlo rosicare...

Sfornano troppe tecnologie a tempo di record mi chiedo quanti sono i dev che riescono a tenersi aggiornati :fagiano: ... Alla fine se il linguaggio cambia rapidamente e aggiunge sempre nuove features va a finire che il codice non e' uniforme toh qui C# 2.0 qui 3.0... In python 3 hanno rimosso dal linguaggio alcune features presenti nella versione 2x per rendere il codice piu' uniforme possibile, che secondo me e' un gran pregio.

[Kralizek]

beh aspetta, il rigore sintattico resta quello. semplicemente hai strumenti in più che prima non si avevano.

considera che .NET si affaccia su innumerevoli piattaforme. Alla fine si usa .NET per programmare su mobile, web, windows, office automation, crm e cosi via.

[cdimauro]

Sfornano troppe tecnologie a tempo di record mi chiedo quanti sono i dev che riescono a tenersi aggiornati :fagiano: ... Alla fine se il linguaggio cambia rapidamente e aggiunge sempre nuove features va a finire che il codice non e' uniforme toh qui C# 2.0 qui 3.0... In python 3 hanno rimosso dal linguaggio alcune features presenti nella versione 2x per rendere il codice piu' uniforme possibile, che secondo me e' un gran pregio.
Ehm, aspetta un attimo: dal linguaggio non è stata rimossa nessuna funzionalità. Soltanto alcune duplicazioni che, in quanto tali, erano contrarie alla filosofia del linguaggio ("There should be one-- and preferably only one --obvious way to do it."). :fagiano:

Il che, come dici tu, è servito anche a rendere il linguaggio più uniforme.

[mindwings]

Ehm, aspetta un attimo: dal linguaggio non è stata rimossa nessuna funzionalità. Soltanto alcune duplicazioni che, in quanto tali, erano contrarie alla filosofia del linguaggio ("There should be one-- and preferably only one --obvious way to do it."). :fagiano:

Il che, come dici tu, è servito anche a rendere il linguaggio più uniforme.

Si l'hai detto meglio di me, mi riferivo a map(), filter() e reduce() in ogni caso hanno fatto refactoring :D sul linguaggio migliorandolo senza aggiungere altri costrutti.
EDIT: In ogni caso adesso per un programmatore C# ci sono piu' modi per svolgere un compito e per forza di cose deve comprendere tutto di un linguaggio altrimenti non riesce a comprendere codice scritto da uno sviluppatore che per esempio ha gia' assimilato ed utilizza le features di C# 4.

[cdimauro]

Si l'hai detto meglio di me, mi riferivo a map(), filter() e reduce() in ogni caso hanno fatto refactoring :D sul linguaggio migliorandolo senza aggiungere altri costrutti.
Qualcosina (di molto utile :sbav:) l'hanno aggiunta. :cool:
EDIT: In ogni caso adesso per un programmatore C# ci sono piu' modi per svolgere un compito e per forza di cose deve comprendere tutto di un linguaggio altrimenti non riesce a comprendere codice scritto da uno sviluppatore che per esempio ha gia' assimilato ed utilizza le features di C# 4.
Concordo. E' un linguaggio abbastanza complesso.

[PGI-Bis]

certe volte creco che il java abbisogni di una rinfrescata... per certi versi é vecchio.

Che il cielo ce ne scampi. L'ultima volta che l'hanno "rinfrescato" hanno aggiunto i generici, abbiamo evitato per un soffio l'oscena sintassi delle chiusure, ci va di culo che nel project coin l'unico orrendume sia l'operatore elvis (stesso tizio delle chiusure che non ho capito perchè, visto che lavora per google, non impesta un po' android o chrome e balle varie e lascia in pace Duke :mad: ).

Java lasciatemelo così com'è che sarebbe perfetto se non avesse i generici.

Ci sono 209 linguaggi che girano sulla piattaforma Java: gufate gli altri 208!

[Kralizek]

che hanno i generics che non ti piacciono?

[PGI-Bis]

public <A, B extends Comparable<? super java.util.Map.Entry<? extends A, ? super B>>> void gesummaria(A a, B b)

Ma dov'era il problema nello scrivere String s = (String) lista.get(x) ?

Perchè non è che coi generici Java sia diventato all'improvvisio un monumento alla solidità dei tipi. E' esattamente come prima solo più complicato.

Mi immagino tutti quei poveri ciccini che prima dovevano scrivere (String) o (Integer), o poverini coi ditini santi che ci fanno male cucci cucci... ma potessero incarnirglisi tutte e dieci le unghie delle dita!

[Kralizek]

non conosco Java, ma in C# scrivere cose


ArrayList lista = new ArrayList();
lista.Add(1);
lista.Add("hello");
lista.Add('c');
lista.Add(DateTime.Now);


è perfettamente legale. Certo se ti trovi in questa situazione sei fesso tu :)

però io trovo più giusto lasciare il gioco di box/unbox un'opzione più che un obbligo per lo sviluppatore :)

[malocchio]

non conosco Java, ma in C# scrivere cose


ArrayList lista = new ArrayList();
lista.Add(1);
lista.Add("hello");
lista.Add('c');
lista.Add(DateTime.Now);


è perfettamente legale. Certo se ti trovi in questa situazione sei fesso tu :)

però io trovo più giusto lasciare il gioco di box/unbox un'opzione più che un obbligo per lo sviluppatore :)

Puoi anche in Java.
Se non usi i generics è come se avessi "Object" sempre tra parentesi angolate, quindi quando fai lista.get() hai un reference di tipo Object e per poter utilizzare "appieno" l'oggetto devi fare un cast esplicito prendendoti le tue responsabilità.
Sotto questo punto di vista Java = C#

[Kralizek]

perfetto, supponevo fosse lo stesso :)

E allora perchè preferire una lista non tipizzata ad una bellissima lista tipizzata? :)

[PGI-Bis]

Dipende da quanto "costa" quella bellissima lista tipizzata in termini di grammatica.

Perchè se il prezzo è di 700 pagine di "Java Generics FAQ" io direi che è caro. Che sono metà di quelle che servono per spiegare i generici di C# ma, francamente, questi non sono fatti che riguardano chi usa C# (se la memoria non mi inganna il già citato lanzichenecco che partecipò all'impestazione di Java passò per quel di Redmond e lasciò in dote gli "in" e "out" prima di migrare verso altri e più putridi lidi.).

PS: per l'argomento del topic concordo con cionci, contropaccotto e via. Sull'argomento "metodo con numero variabile di parametri" chi li ha inventati meriterebbe una notte di passione con una tribù di Yeti.

[malocchio]

Dipende da quanto "costa" quella bellissima lista tipizzata in termini di grammatica.

Perchè se il prezzo è di 700 pagine di "Java Generics FAQ" io direi che è caro. Che sono metà di quelle che servono per spiegare i generici di C# ma, francamente, questi non sono fatti che riguardano chi usa C# (se la memoria non mi inganna il già citato lanzichenecco che partecipò all'impestazione di Java passò per quel di Redmond e lasciò in dote gli "in" e "out" prima di migrare verso altri e più putridi lidi.).

PS: per l'argomento del topic concordo con cionci, contropaccotto e via. Sull'argomento "metodo con numero variabile di parametri" chi li ha inventati meriterebbe una notte di passione con una tribù di Yeti.

Stasera ti senti piuttosto lanciato eh? :rotfl:

[PGI-Bis]

Ero indeciso tra gli Yeti e Sergio Japino ma il secondo ha già la sua bella croce, lasciamolo stare.

[Tommo]

public <A, B extends Comparable<? super java.util.Map.Entry<? extends A, ? super B>>> void gesummaria(A a, B b)

Ma dov'era il problema nello scrivere String s = (String) lista.get(x) ?

Perchè non è che coi generici Java sia diventato all'improvvisio un monumento alla solidità dei tipi. E' esattamente come prima solo più complicato.

Mi immagino tutti quei poveri ciccini che prima dovevano scrivere (String) o (Integer), o poverini coi ditini santi che ci fanno male cucci cucci... ma potessero incarnirglisi tutte e dieci le unghie delle dita!

Mi sono trovato a doverlo fare per l'università ed è aborrente :asd:

Possibile che a lorsignori geni non gli sia venuto in mente di mettere un dannato metodo getKey(i) e getValue(i) dentro quella mappa?
No. Noi facciamo le cose a oggetti. Co 4 generics diversi.

Concordo che ultimamente Java sta peggiorando, l'intera libreria sembra scritta da qualcuno smanioso di dimostrare che ha studiato Linguaggi e Modelli, tutto teoricamente perfetto ma lento e scomodo alla 3a.
Non ho mai reinventato la wheel così tanto come in Java, tanto in C++ uso la STL almeno :asd:

[PGI-Bis]

Concordo che ultimamente Java sta peggiorando

Calma e gesso: non concordiamo. Generici a parte il resto si adegua perfettamente al mio ideale di linguaggio di programmazione. A meno che uno non abbia tre lobi frontali, nel qual caso potrebbe benissimo usare Scala.

[Tommo]

Calma e gesso: non concordiamo. Generici a parte il resto si adegua perfettamente al mio ideale di linguaggio di programmazione. A meno che uno non abbia tre lobi frontali, nel qual caso potrebbe benissimo usare Scala.

Ok diciamo che concordo con me stesso allora :asd:

[cdimauro]

Dipende da quanto "costa" quella bellissima lista tipizzata in termini di grammatica.

Perchè se il prezzo è di 700 pagine di "Java Generics FAQ" io direi che è caro. Che sono metà di quelle che servono per spiegare i generici di C# ma, francamente, questi non sono fatti che riguardano chi usa C# (se la memoria non mi inganna il già citato lanzichenecco che partecipò all'impestazione di Java passò per quel di Redmond e lasciò in dote gli "in" e "out" prima di migrare verso altri e più putridi lidi.).
Anche a me la sintassi dei generic ha sempre fatto schifo. Una delle cose più brutte che abbia mai visto in un linguaggio di programmazione.
PS: per l'argomento del topic concordo con cionci, contropaccotto e via. Sull'argomento "metodo con numero variabile di parametri" chi li ha inventati meriterebbe una notte di passione con una tribù di Yeti.
Ma anche no. Se è una questione di gusti, amen, ma tecnicamente la trovo una funzionalità molto comoda in tante occasioni. :cool:

[banryu79]

A meno che uno non abbia tre lobi frontali, nel qual caso potrebbe benissimo usare Scala.
Ciao PGI, mi ricordavo che tempo fa stessi provando Scala, e, forse mi sbaglio, ma avevo avuto l'impressione che il tuo primo impatto con il linguaggio non fosse stato brutto. Che ti ha fatto cambiare opinione?

[cdimauro]

Vedere PGI mischiare codice a oggetti con codice funzionale era qualcosa di impagabile. :D

Si vede che, magari, s'è rivisto pure lui, e ha deciso di tornare al suo sano integralismo. :p

[PGI-Bis]

Ciao PGI, mi ricordavo che tempo fa stessi provando Scala, e, forse mi sbaglio, ma avevo avuto l'impressione che il tuo primo impatto con il linguaggio non fosse stato brutto. Che ti ha fatto cambiare opinione?

Il linguaggio mi piace sempre. I tre lobi frontali servono per tenerlo sotto controllo. Tra il compilatore che induce, le librerie che simboleggiano e tu che in tutto 'sto ben di dio un po' del tuo ce lo vuoi sempre mettere, arrivi a scrivere righe di codice che, guardandole, dici "E' bellissimo!" poi due giorni non riesci più neanche a capire se è codice sorgente o ti si sono bruciati dei pixel sull'LCD.

[banryu79]

Il linguaggio mi piace sempre. I tre lobi frontali servono per tenerlo sotto controllo. Tra il compilatore che induce, le librerie che simboleggiano e tu che in tutto 'sto ben di dio un po' del tuo ce lo vuoi sempre mettere, arrivi a scrivere righe di codice che, guardandole, dici "E' bellissimo!" poi due giorni non riesci più neanche a capire se è codice sorgente o ti si sono bruciati dei pixel sull'LCD.
Ah, capito :asd:
E' un po' come quando uno scrive con una grafia così contorta che a volte gli capita di non riuscire a leggere quello che lui stesso ha scritto... solo che in quel caso la colpa è interamente dello scrittore, non della penna (a meno di non voler scrivere impugnando un albero).

Scherzi a parte, non ho mai capito quale lato della medaglia "potenza espressiva" sia quello positivo: se l'estrema sintesi di una formula che dice tanto in poco spazio a prezzo dell'immediatezza di decodifica da parte del lettore, oppure l'estrema chiarezza a prezzo di molto spazio per dire l'equivalente...
(Lasciando completamente perdere il caso peggiore: quello in cui si richiede tanto spazio per dire poco in modo complicato)

[Kralizek]

Mah, io invece sono del parere opposto, i generics ti aiutano a raggruppare codice simile senza dover riscrivere le stesse cose per tipi diversi.

Ad esempio oggi ho scritto questo Extension Method


public static IEnumerable<GroupedEntity<HierarchyEntity<TMainType, TSubType>>> GroupAndCountBy<TSource, TMainType, TSubType, TBaseType> (
this IEnumerable<TSource> source,
Func<TSource, IEnumerable<TBaseType>> rawSelector,
Func<TBaseType, int> idSelector,
Func<TSubType, TMainType> parentSelector,
Func<TBaseType, string> sorter,
Func<TMainType, TMainType> mainCloner,
Func<TSubType, TSubType> subCloner
)
where TSource : ISearchObject, ISearchObject<TSource>
where TBaseType : class
where TMainType : class, TBaseType
where TSubType : class, TBaseType
{
Dictionary<int, int> rawEntitiesQ = new Dictionary<int, int>();
Dictionary<int, int> mainEntitiesQ = new Dictionary<int, int>();

var rawItems = source.SelectMany(rawSelector).Distinct();

foreach (TSource sourceItem in source)
{
List<int> addedMainEnt = new List<int>();

foreach (TBaseType baseItem in rawSelector(sourceItem))
{
int id = idSelector(baseItem);

rawEntitiesQ.IncreaseValue(id);

if (baseItem is TMainType)
{
if (!addedMainEnt.Contains(id))
mainEntitiesQ.IncreaseValue(id);
}
else
{
TSubType subTypeItem = baseItem as TSubType;
int parentID = idSelector(parentSelector(subTypeItem));

if (!addedMainEnt.Contains(parentID))
mainEntitiesQ.IncreaseValue(parentID);
}
}
}

var subTypes = rawItems.OfType<TSubType>();
var mainTypes = rawItems.OfType<TMainType>().Union(subTypes.Select(parentSelector).Distinct());

var res = (from mainTypeItem in mainTypes
orderby sorter(mainTypeItem)
select new GroupedEntity<HierarchyEntity<TMainType, TSubType>>
{
Entity = new HierarchyEntity<TMainType,TSubType>
{
Entity = mainCloner(mainTypeItem),
SubItems = (from subTypeItem in subTypes
where idSelector(parentSelector(subTypeItem)) == idSelector(mainTypeItem)
orderby sorter(subTypeItem)
select new GroupedEntity<TSubType>
{
Entity = subCloner(subTypeItem),
Count = rawEntitiesQ[idSelector(subTypeItem)]
}).ToArray()
},

Count = mainEntitiesQ[idSelector(mainTypeItem)]
}).ToArray();

return res;
}

public static void IncreaseValue(this IDictionary<int, int> dict, int key)
{
if (!dict.ContainsKey(key))
dict.Add(key, 0);

dict[key]++;
}


Che mi permette di eseguire codice simile su tipi sostanzialmente diversi senza fare copia&incolla&rinomina


var resPlaces = educations.GroupAndCountBy<Education, Country, City, Place>(
e => e.RawPlaces,
p => p.ID,
c => c.Country,
p => p.Name,
c => new Country { ID = c.ID, Name = c.Name, Coordinates = c.Coordinates },
c => new City { ID = c.ID, Name = c.Name, Coordinates = c.Coordinates });

var resCategories = educations.GroupAndCountBy<Education, MainCategory, SubCategory, Category>(
e => e.RawCategories,
c => c.ID,
s => s.MainCategory,
c => c.Name,
c => new MainCategory { ID = c.ID, Name = c.Name },
c => new SubCategory { ID =c.ID, Name = c.Name });

var resTypes = educations.GroupAndCountBy<Education, MainEducationType, SubEducationType, EducationType>(
e => new[] { e.RawEducationType },
t => t.ID,
s => s.MainType,
t => t.Name,
t => new MainEducationType { ID = t.ID, Name = t.Name },
t => new SubEducationType { ID = t.ID, Name = t.Name });


ok, magari ho esagerato con le lambda... peró lo trovo comodo :)

[PGI-Bis]

Francamente non ci si capisce una mazza.

P.s.: per non ingenerare equivoci, non che sia scritto male (è c#, non saprei dire), o che non sia pulito o che altro. E' che proprio a vederlo non si capisce. Lo stesso sarebbe se si facesse in Java. Io lo guardo nel suo complesso, mi chiedo "che sta facendo questo?" e la prima risposta che mi viene è "boh". Sono l'unico?

[malocchio]

Francamente non ci si capisce una mazza.
Sono l'unico?

No, ma penso che dipenda soprattutto dal fatto che non sappiamo di preciso ad esempio cosa sono TBaseType GroupedEntity ISearchObject eccetera...
Se avessimo un po' di queste conoscenze forse potremmo dedurre una qualche logica dietro a tutto quel codice...

Ma quanto ci vuole a imparare ad usare come si deve il C#? Si sta sviluppando così in fretta che se non si sta al passo con i tempi poi si rischia magari di doverlo imparare tutto in una sola botta e lì la vedo dura.. :ops2:

[Kralizek]

Francamente non ci si capisce una mazza.

P.s.: per non ingenerare equivoci, non che sia scritto male (è c#, non saprei dire), o che non sia pulito o che altro. E' che proprio a vederlo non si capisce. Lo stesso sarebbe se si facesse in Java. Io lo guardo nel suo complesso, mi chiedo "che sta facendo questo?" e la prima risposta che mi viene è "boh". Sono l'unico?

tranquillo, é perfettamente normale non capire cosa fa un metodo che lavora su una struttura di classi di cui non si ha conoscenza.
Non volevo assolutamente far vedere quanto sono figo a programmare, semplicemente l'obiettivo del post era quello di far vedere come, usando opportunamente tipi generici e lambda expressions si riesce a riusare codice per strutture simili laddove non ci sia alcuna "parentela" (nel senso di ereditarietá) tra i diversi casi ;)

No, ma penso che dipenda soprattutto dal fatto che non sappiamo di preciso ad esempio cosa sono TBaseType GroupedEntity ISearchObject eccetera...
Se avessimo un po' di queste conoscenze forse potremmo dedurre una qualche logica dietro a tutto quel codice...


Esatto ;)


Ma quanto ci vuole a imparare ad usare come si deve il C#? Si sta sviluppando così in fretta che se non si sta al passo con i tempi poi si rischia magari di doverlo imparare tutto in una sola botta e lì la vedo dura.. :ops2:

Mah, io programmo su .NET dalla versione 1.0 ed ho giochicchiato sulle varie beta non appena venivano rilasciate.
Ad un eventuale neofita di .NET, consiglierei di studiare per bene .NET 2.0. (A meno che non si voglia lavorare su Windows, in tal caso, inizierei da .NET 2.0 + WPF).
Successivamente studiare WCF e WF (.NET 3.0), type inference, lambdas, linq ed automatic properties (.NET 3.5) sono cose che vengono facilmente da sé.

Sia chiaro "studiare .NET 2.0" sembra poco, ma non lo é. ;)

[PGI-Bis]

tranquillo, é perfettamente normale non capire cosa fa un metodo che lavora su una struttura di classi di cui non si ha conoscenza.

Ecco, forse avremo davvero fatto un passo avanti nel campo dei linguaggi di programmazione quando diventerà inconcepibile.

Perchè se tu esprimessi a parole ciò che fa quel codice sono certo che capiremmo tutti.

[banryu79]

Ecco, forse avremo davvero fatto un passo avanti nel campo dei linguaggi di programmazione quando diventerà inconcepibile.

Perchè se tu esprimessi a parole ciò che fa quel codice sono certo che capiremmo tutti.
Eh, anche questo frutterebbe un Turing Award :D

[PGI-Bis]

Be' prima o poi ci arriveranno. Non nell'immediato futuro ma è inevitabile. E' curioso ma alla fine tutto quel che serve è un insieme di regole così sottili e complesse che il codice risultante non può che essere facilissimo da leggere.

[banryu79]

E' curioso ma alla fine tutto quel che serve è un insieme di regole così sottili e complesse che il codice risultante non può che essere facilissimo da leggere.
Umm, non saprei: non sono così sicuro che il grado di complessità di un simile sistema formale abbia un ordine di grandezza che rientra nella scala di quelli gestibili dalla mente umana (e quindi formalizzabile).
Sempre se ho capito cosa vuoi dire.

[PGI-Bis]

Direi che pensiamo a cose diverse perchè un linguaggio naturale e le sue regole sono certamente gestibili - altrimenti non parleremmo.

Qualcuno sa per caso se ci sono studi in rete sull'applicazione dei linguaggi naturali alla programmazione?

[Tommo]

Non so quanto sia ottimo applicare un linguaggio naturale alla programmazione;
il linguaggio naturale è ambiguo, strettamente dipendente dal contesto, richiede tonnellate di "special keywords" per ogni singolo ambito di ogni singolo problema...

credo proprio che un ipotetico "compilatore di linguaggio naturale" sarebbe ne più ne meno che un'AI che capisce che intendi e poi scrive il programma, molto similmente a come fa un programmatore sotto contratto...

Anche perchè il "there should be one best way to do something" se ne va a farsi friggere... se io chiedo al compilatore "dato un array A fai il sorting crescente" quanti migliaia di modi ci sono per farlo? :asd:
Per essere stringenti alla fine ci vorrebbe un design doc di decine di pagine come serve a qualsiasi persona, quindi il tutto mi sembra quantomeno infattibile :asd:

[marco.r]

Ecco, forse avremo davvero fatto un passo avanti nel campo dei linguaggi di programmazione quando diventerà inconcepibile.

Perchè se tu esprimessi a parole ciò che fa quel codice sono certo che capiremmo tutti.

Si', ma ognuno in modo sottilmente diverso.
"Stampa gli appuntamenti dal 3 dicembre al 10 gennaio".
Avrai chi ti stampa tutti gli appuntamenti del 10, chi non te ne stampa nessuno, chi considera la mezzanotte di Greenwich etc

[PGI-Bis]

Ed è diverso da quello che capita oggi?

Io ho un programma che a un certo punto, per una particolare sequenza di input, va letteralmente fuori di testa: inizia un ciclo di selezioni e deselezioni, senza fine.

C'è, nel suo codice, un punto in cui evidentemente gil è imposto di fare così. Ma non è certo "quello che volevo dirgli di fare".

E' un fraintendimento anche questo, no? Ho voluto far fare al PC qualcosa e quel qualcosa generalmente accade tranne che in un particolare caso, un "border line", dove ciò che per me aveva un significato in verità ne ha un altro.

[Tommo]

Ed è diverso da quello che capita oggi?

Io ho un programma che a un certo punto, per una particolare sequenza di input, va letteralmente fuori di testa: inizia un ciclo di selezioni e deselezioni, senza fine.

C'è, nel suo codice, un punto in cui evidentemente gil è imposto di fare così. Ma non è certo "quello che volevo dirgli di fare".

E' un fraintendimento anche questo, no? Ho voluto far fare al PC qualcosa e quel qualcosa generalmente accade tranne che in un particolare caso, un "border line", dove ciò che per me aveva un significato in verità ne ha un altro.

Scusa ma non c'entra assolutamente un cavolo :asd:

Nell'esempio che fai te il computer esegue alla lettera quello che il gli ho IMPOSTO; il conflitto è nel mio cervello dato che non ho saputo tradurre le mie parole in codice funzionante.

La situazione di ambiguità sarebbe decisamente più frustrante perchè dovresti "spiegargli" dove sbaglia, e l'errore non dipende assolutamente da te... ma dal compiler.

Inoltre quoto marco.r, una cosa semplice come "Stampa gli appuntamenti dal 3 dicembre al 10 gennaio" per essere non ambigua dovrebbe diventare tipo
"Scrivi a schermo tramite Console dei Comandi (cmd.exe) gli appuntamenti salvati nel file apposito, che ha l'utente attivo dal 3 dicembre 2009 compreso al 10 gennaio 2010 escluso, in base all'orario di sistema".
Ecco, questo inizia a diventare preciso... e nemmeno ho definito alcun tipo di struttura dati per appuntamenti, file, data, sistema, utenti, che sicuramente andavano definite in precedenza.

Qualcosa mi dice che il codice C++ veniva più corto :asd:

D'altra parte c'è un motivo se il linguaggio matematico (il linguaggio logico per eccellenza) usa simboli e lettere ed è comprensibile come il cirillico no?

[PGI-Bis]

C'è un linguaggio, una frase, due significati, uno logicamente corretto e uno inferito. E' chiaro che sono io a inferire: l'altro non è istruito a farlo.

Potrebbe? Be', ci sono applicazioni inferenziali. Non ci sono, che io sappia, linguaggi di programmazione inferenziali.

Il problema dell'esistenza di più modi di ordinare un vettore di fronte alla richiesta di farlo senza specificare il come si risolve nello stesso modo in cui si comprano due ciabatte.

Avete mai provato a dire al vostro panettiere "mi dia due ciabatte con la mano sinistra"?

Pur negando di averlo mai fatto posso dirvi che vi guarderà come se foste matti.

Capita anche se chiedete una minerale naturale gassata liscia alla commessa del bar del Cinecity di Mantova (sempre per prendere un caso astratto).

Nella comunicazione verbale ci sono dei meccanismi inferenziali che rendono superflue alcune informazioni in alcuni contesti e dei meccanismi di controllo logico che causano una specie di "corto circuito".

Insomma, si può essere ambigui ed ottenere una risposta corretta, in contesti in cui non è che gli esseri umani siano coi neuroni tutti accesi pronti a dar fondo a ventimila anni di evoluzione. Sono risposte quasi istintive - quello che otterremmo se per assurdo a qualcuno che io non conosco, ma che lo guardano un po' strano da qualche tempo a questa parte, venisse in mente di provare.

Prima o poi si cercherà di farlo anche coi calcolatori, non è che possano triturare i marroni ancora per molto con le classi, le lambda expression e robe così.

Comunque, siete dei nichilisti della madonna. :D

[Tommo]

Si ma il panettiere non è msvc che cavolo :asd:

Quello che stai dicendo te implica l'esistenza di una intelligenza artificiale "forte"...
Cioè noi, l'intelligenza più mirabolante e multiforme del creato ci mettiamo ANNI per comprendere come tradurre pensieri in algoritmi, per poi impiegarci MESI a farlo davvero, e te mi dici che un programma dovrebbe farlo automaticamente e magari in qualche minuto? naah :D

E trascuriamo quante volte ho chiesto l'acqua liscia e mel'hanno data gassata, o che ho saputo di dover seguire un corso 2 settimane dopo che era iniziato.

Tu non stai parlando di scrivere un linguaggio, ma di scrivere un programmatore :asd:
Il che corrisponde all'idea di "singolarità tecnologica", dove la tecnologia impara a migliorarsi da sola.

Comunque "ideologicamente" credo che questo sia possibile, ma penso che noi non la vedremo coi nostri occhi...

PS: il "significato oggettivo" dei nostri pensieri è puramente soggettivo e frutto di come vediamo la realtà, anche quando si prova a spiegarlo ad un'altra persona... altrimenti saremmo tutti d'accordo. Ma qua si entra nel filosofico...
Più nel concreto: "scrivi" nella frase di prima; solo questo si può fare in centinaia di modi verbosissimi da spiegare...

[PGI-Bis]

Be', non è neanche rubbia se è per questo.

Comunque, son possibilità. L'anno scorso mi pare che... Snaffiger... Snulzer... insomma, uno dei chief architect di .NET ad una conferenza avesse detto che la sua previsione per gli sviluppi della programmazione fosse una specie di fusion - a mo' di cucina - tra diverse prospettive. Ecco, secondo me qualcuno potrebbe osare di più.

[cdimauro]

Vabbé, ma Scala è già sulla buona strada (quel minestrone delle prospettive). :fagiano:

[banryu79]

Quello che stai dicendo te implica l'esistenza di una intelligenza artificiale "forte"...
Cioè noi, l'intelligenza più mirabolante e multiforme del creato ci mettiamo ANNI per comprendere come tradurre pensieri in algoritmi, per poi impiegarci MESI a farlo davvero, e te mi dici che un programma dovrebbe farlo automaticamente e magari in qualche minuto? naah :D

Ma, in "linea di principio" personalmente non mi sento di escluderne la possibilità.

Quello che sento di escludere, è la fattibilità concreta, perchè se fosse fattibile dall'uomo, implicherebbe la capacità, per la mente umana, di gestire livelli di complessità di un ordine mostruosamente elevato... e io non credo sia così.

Dietro la faccenda, c'è sempre l'ombra del secondo teorema di Godel e le sue implicazioni per i sistemi formali. In particolare se un sistema formale non può arrivare a contenere la citazione di se stesso, ovvero non può produrre come teorema il fatto che se stesso è vero, ma può solo aggiungere questo predicato come nuovo assioma, producendo di fatto un nuovo sistema formale che comprende il precedente ma "pecca" allo stesso modo del vecchio, e così via, in anelli di complessità crescente all'infinito... la vedo dura per noi uomini arrivare a produrre la versione artificale isomorfa della mente umana.

Al massimo si può arrivare a produrre un'intelligenza artificiale sufficientemente complessa/raffinata da ingannarci (bisognerebbe quantificare, io conosco solo il test di Turing).

Bisogna vedere se per ottenere un linguaggio di programmazione di potenza espressiva pari o quasi a quella del linguaggio naturale (io ho capito che era a questo che intendeva PGI nel post di ieri sera) occorra o meno una complessità pari a quella della mente umana.

Direi che pensiamo a cose diverse perchè un linguaggio naturale e le sue regole sono certamente gestibili - altrimenti non parleremmo.

[PGI-Bis]

Vabbé, ma Scala è già sulla buona strada (quel minestrone delle prospettive). :fagiano:

Ma guarda che scala è molto bello come linguaggio. Mi terrorrizza il fatto che avendo questa estrema flessibilità espressiva inizino a circolare linee di codice elengatissime per capire le quali bisogna disintegrarsi le cataratte sul monitor.

Non è che sia così diverso da python: gli togli la tipazione statica e sono entrambi procedural imperativi orientati agli oggentuzioni.

[Tommo]

-cut-

Beh, il teorema di Godel mi sa di citato a sproposito in questo ambito...
solo di logica, se come dici te un sistema può produrre solo sistemi che gli sono inferiori, questo proverebbe nientemeno che l'esistenza di un creatore :asd:

Al contrario, io credo che la nostra intelligenza esce da eoni di DNA rimischiato a caso... e credo sia questo il processo da emulare ;)
Cioè dovrebbe essere possibile mettere su un sistema di regole che evolutivamente tramite selezione, cioè, a caso, riesce in tempi decenti a superarci...

Comunque sfugge un punto fondamentale: se le macchine diventassero in grado di interpretare il nostro linguaggio tanto da scrivere programmi, i programmi stessi non servirebbero più a niente :asd:

[marco.r]

Ed è diverso da quello che capita oggi?

Io ho un programma che a un certo punto, per una particolare sequenza di input, va letteralmente fuori di testa: inizia un ciclo di selezioni e deselezioni, senza fine.

C'è, nel suo codice, un punto in cui evidentemente gil è imposto di fare così. Ma non è certo "quello che volevo dirgli di fare".

E' un fraintendimento anche questo, no? Ho voluto far fare al PC qualcosa e quel qualcosa generalmente accade tranne che in un particolare caso, un "border line", dove ciò che per me aveva un significato in verità ne ha un altro.

C'è una differenza sostanziale. Per un linguaggio di programmazione in generale esiste un riferimento (il suo standard) che permette di chiarire in maniera univoca il significato di una certa espressione.

[marco.r]

C'è un linguaggio, una frase, due significati, uno logicamente corretto e uno inferito. E' chiaro che sono io a inferire: l'altro non è istruito a farlo.

Potrebbe? Be', ci sono applicazioni inferenziali. Non ci sono, che io sappia, linguaggi di programmazione inferenziali.

Il problema dell'esistenza di più modi di ordinare un vettore di fronte alla richiesta di farlo senza specificare il come si risolve nello stesso modo in cui si comprano due ciabatte.

Avete mai provato a dire al vostro panettiere "mi dia due ciabatte con la mano sinistra"?

Non parlo di livello di dettaglio. Che il pane mi venga dato con la sinistra o con la destra poco importa, tanto quel che ottengo e' lo stesso. Il problema e' quando la stessa espressione puo' voler dire cose diverse e in contrasto tra di loro.
Gia' adesso che in teoria il compilatore e' un precisino i programmi non fanno quello che voglio, figuriamoci se devono pure interpretare le mie intenzioni :asd:
Detto questo, fuggo vigliaccamente dalla discussione, visto che e' ormai deragliata nella filosofia :asd:

[cdimauro]

Ma guarda che scala è molto bello come linguaggio. Mi terrorrizza il fatto che avendo questa estrema flessibilità espressiva inizino a circolare linee di codice elengatissime per capire le quali bisogna disintegrarsi le cataratte sul monitor.
Appunto, anche la mia impressione è quella. Scala sta a Java, come Perl sta al C. E ho detto tutto.
Non è che sia così diverso da python: gli togli la tipazione statica e sono entrambi procedural imperativi orientati agli oggentuzioni.
Python è molto più dinamico, ma soprattutto più leggibile.

Per quanto riguarda linguaggi umani e di programmazione, suggerisco di dare un'occhiata a Lojban (http://it.wikipedia.org/wiki/Lojban), che si presta quale "ponte" fra i due mondi. ;)