Ricominciare a programmare... da dove?

[MaxArt]

Ieri mi è stato chiesto se era possibile sviluppare un software per ambito medico da mio zio. Niente di troppo complicato, almeno come progetto iniziale, e credo di essere in grado di farlo.
Il problema è che è da parecchio che non programmo in maniera intensiva, e sostanzialmente non ho mai programmato per Windows, ma solo per DOS. Non ho mai neanche programmato in maniera decente ad oggetti...

Non ho difficoltà ad imparare nuovi linguaggi, è ciò che mi preoccupa di meno. Quello che volevo chiedervi è:
- Che linguaggio potrei usare per creare un'applicazione non troppo complicata ed abbastanza user-friendly? Mi servirebbe chiaramente di qualcosa di sufficientemente potente, senza però arrivare a creare un engine 3d!
- Che risorse per l'apprendimento posso trovare, nel web o qualcosa di economico nelle librerie, oltre a quelle elencate nel thread sulle guide?

Come sistema operativo devo usare Windows XP, ma se possibile vorrei mantenere la compatibilità anche con Vista, 2000 e 98/ME.

Grazie mille a chi mi vorrà consigliare! :)

[isAlreadyInUse]

Bhe scegli tra Java o .NET

[MaxArt]

Bhe scegli tra Java o .NETCon .NET intendi C#, J# e VB.NET?
E' necessaria l'installazione di .NET Framework, vero? Mentre il Java ha bisogno del JVM?
Potresti dirmi in breve i vantaggi dell'uno e dell'altro?

Ah, un'aggiunta: se possibile, vorrei crearmi un ambiente di sviluppo freeware :)

[isAlreadyInUse]

Tra i linguaggi .NET bhe devi scehliere tu quello piu cngeniale a te io direi C#
Come ambienti di sviluppo per il .NET trovi la versione Express del viasual studio 2008 e per java netbeans o eclipse

[k0nt3]

consiglio anche io o JAVA o .NET (linguaggio C#), ma richiedono la programmazione a oggetti.. quindi dovrai studiartela un pò ;)

ps. che linguaggi conosci già?

[MaxArt]

Come ambienti di sviluppo per il .NET trovi la versione Express del viasual studio 2008 e per java netbeans o eclipseSono ambienti gratuiti? :stordita:
Anche io ero orientato al C#.

ps. che linguaggi conosci già?Veramente di tutto un po'... :stordita:
Da ragazzino usavo il QuickBasic (e tanto!), che poi ho cominciato ad integrare con l'assembler. Ho programmato tutto le calcolatrici ed organizer che ho avuto (sia con il linguaggio interno, sia con l'assembler nel caso della mia TI-86 con processore Z80), creato pagine web con javascript, creato ambienti ad oggetti per i MOO (http://it.wikipedia.org/wiki/MUD_Object_Oriented) (chi se li ricorda?)... Insomma, di tutto un po'.

Il C l'ho imparato relativamente di recente, per un esame all'univesità... In un mese lo passai con 30 e lode ed il mese dopo ero a Porto a rappresentare la mia università in una gara di programmazione, dopo aver vinto la selezione locale, programmando appunto in C.
Anche questo se non aveva molto a che fare con la conoscenza del linguaggio in sé ma più con la capacità di inquadramento dei problemi e la strutturazione del programma, quindi, difficoltà ad imparare non ne ho.

Però, di programmazione ad oggetti ne ho fatta poca: dovrò impararla meglio. :read:

[k0nt3]

Visal Studio Express è gratuito, solo che non sono sicuro che puoi usarlo in un ambito commerciare (come può essere lo studio di un medico). al massimo ci sono altri ambienti gratuiti per C# (ad esempio SharpDevelop).
per java invece di sicuro non ci sono problemi con netbeans e eclipse.
sono due linguaggi molto simili, anche se a mio avviso java è pochino più didattico per quanto riguarda la programmazione a oggetti, mentre C# ha alcune caratteristiche un pò "sporche"

[fek]

Se non ti interessa la portabilita' e sei solo interessato a Win32, puoi indirizzarti verso .NET e quindi C# o C++/CLI. La particolarita' di questo ambiente e' la facilita' di interoperare diversi linguaggi (e' nato per questo): puoi quindi scrivere l'intera applicazione in C# e, fosse necessario, scrivere alcune parti in C++/CLI (la versione .NET di C++). Esistono versioni di Python e Ruby che compilano verso la piattaforma .NET.

C++/CLI da questo punto di vista e' ottimo perche' ti permette di mischiare C++ nativo e C++/CLI (.NET) nello stesso codice e il risultato puo' essere immediatamente consumato in C#. Ho scritto un paio di anni fa un piccolo engine 3d di prova che si interfacciava a D3D in C++ nativo, esponeva le classi dell'engine a .NET via C++/CLI e consumava l'engine stesso da C# per l'applicazione. Prima o poi lo distribuisco per curiosita'.

[variabilepippo]

Visal Studio Express è gratuito, solo che non sono sicuro che puoi usarlo in un ambito commerciare


Tutti le versioni gratuite degli IDE (Visual Studio Express, Netbeans/Eclipse, Turbo C++ / Turbo Delphi / Turbo Delphi .NET, ...) sono utilizzabili in ambito commerciale.

Per Visual C# leggi la settima risposta della FAQ ufficiale (http://www.microsoft.com/express/support/faq/).

[isAlreadyInUse]

Si ma credo che alui serva una cosa piu semplice e immedita

[MaxArt]

sono due linguaggi molto simili, anche se a mio avviso java è pochino più didattico per quanto riguarda la programmazione a oggetti, mentre C# ha alcune caratteristiche un pò "sporche":confused: Se ti va di spiegarlo io sono qui.. :stordita:

Dunque pensi che il Java mi permetta un approccio più veloce al problema?

[71104]

Ho scritto un paio di anni fa un piccolo engine 3d di prova che si interfacciava a D3D in C++ nativo, esponeva le classi dell'engine a .NET via C++/CLI e consumava l'engine stesso da C# per l'applicazione. Prima o poi lo distribuisco per curiosita'. mi sa che hai fatto un giro inutile:

http://msdn2.microsoft.com/en-us/library/bb318659(VS.85).aspx

Benefits of DirectX 9.0 for Managed Code

By eliminating the Component Object Model (COM) interoperability layer, DirectX 9.0 for Managed Code improves performance.

:Prrr:

[71104]

sono due linguaggi molto simili, anche se a mio avviso java è pochino più didattico per quanto riguarda la programmazione a oggetti, mentre C# ha alcune caratteristiche un pò "sporche" ah guarda le sue "sporcizie" ce le ha pure Java eh! :O

[k0nt3]

:confused: Se ti va di spiegarlo io sono qui.. :stordita:

Dunque pensi che il Java mi permetta un approccio più veloce al problema?
uhm no :D
didattico nel senso che magari java ti permette di imparare meglio a programmare a oggetti.
diciamo che comunque su piattaforme windows .NET ha un piccolo vantaggio.. in sostanza lancia una monetina :p

[k0nt3]

Tutti le versioni gratuite degli IDE (Visual Studio Express, Netbeans/Eclipse, Turbo C++ / Turbo Delphi / Turbo Delphi .NET, ...) sono utilizzabili in ambito commerciale.

Per Visual C# leggi la settima risposta della FAQ ufficiale (http://www.microsoft.com/express/support/faq/).
grazie per l'informazione :D ho sempre avuto il dubbio

[MaxArt]

diciamo che comunque su piattaforme windows .NET ha un piccolo vantaggio.. in sostanza lancia una monetina :pPenso che allora opterò, per il momento, per il C#, ma non è detto che non impari entrambi. Anzi, magari è anche probabile.

Orbene, ora cosa dovrei procurarmi come software ? Il Visual Studio 2008 Express e basta?
Che documentazione dovrei leggere per incominciare a visualizzare una finestra con su scritto "Hallo, world!"?

[71104]

Orbene, ora cosa dovrei procurarmi come software ? Il Visual Studio 2008 Express e basta? http://www.microsoft.com/express/download/

se ricordo bene l'installer di Visual Studio 2008 provvede anche all'installazione del framework .NET 3.5 (l'ultima versione)

Che documentazione dovrei leggere per incominciare a visualizzare una finestra con su scritto "Hallo, world!"? http://msdn2.microsoft.com/en-us/library/kx37x362.aspx
http://msdn2.microsoft.com/en-us/library/ms229335.aspx

[^TiGeRShArK^]

Penso che allora opterò, per il momento, per il C#, ma non è detto che non impari entrambi. Anzi, magari è anche probabile.

Orbene, ora cosa dovrei procurarmi come software ? Il Visual Studio 2008 Express e basta?
Che documentazione dovrei leggere per incominciare a visualizzare una finestra con su scritto "Hallo, world!"?
sono molto simili java e c#..
una volta che impari uno puoi sempre imparare l'altro (almeno le cose basi) senza alcuna difficoltà.
Secondo me, visto che devi restare su windows, va benissimo il C#.

[^TiGeRShArK^]

Penso che allora opterò, per il momento, per il C#, ma non è detto che non impari entrambi. Anzi, magari è anche probabile.

Orbene, ora cosa dovrei procurarmi come software ? Il Visual Studio 2008 Express e basta?
Che documentazione dovrei leggere per incominciare a visualizzare una finestra con su scritto "Hallo, world!"?
basta che crei una windows application e nel designer metti una label con su scritto "Hello World!" :p
Sinceramente è anche fin troppo semplice..
La prima applicazioncina che avevo fatto senza nessuna conoscenza di C# era un clone della calcolatrice (standard non scientifica) di windows.. che era un pò + stimolante del classico hello world :D

[fek]

mi sa che hai fatto un giro inutile:

Non ho esposto tutte le D3D, ma solo poche classi ad alto livello scritte in C++ nativo ;)
Per quanto in realta delle prestazioni non potesse importarneme nulla, il livello di controllo che ho su un engine 3d in C++ e' inavvicinabile dalle dx.net (purtroppo, aggiungo).

Ti assicuro che un conto e' lasciare al GC il controllo sul ciclo di vita di un oggetto Mesh o Camera, e tutto un altro paio di maniche lasciargli il controllo su un vertex buffer o una texture. Ouch.

[sottovento]

Che tipo di software devi sviluppare? Hai scritto in ambito medico, ma si puo' andare dalla gestione delle cartelle cliniche di pazienti, ... all'elaborazione digitale di immagini, alla modellizzazione di casi clinici.

Il mio consiglio e' quello di usare un linguaggio specializzato al tuo problema: d'accordissimo che C/C++/Java sono molto piu' potenti e general-purpose.
Se pero' il tuo problema e', per esempio, gestire clienti (in sostanza, gestire database) allora potresti usare un linguaggio piu' adatto al questo scopo ben preciso: ti permette di realizzare una soluzione funzionante in veramente poco tempo, e con una buona affidabilita'.
In piu', ti puoi focalizzare sul problema e non sullo strumento. Bada bene, non e' cosa da poco

[cdimauro]

Per questo tipo di applicazioni c'è anche Delphi che è eccellente per sviluppare applicazioni dotate di GUI, ed esiste sia in versione Win32 che .NET.

[Ziosilvio]

- Che linguaggio potrei usare per creare un'applicazione non troppo complicata ed abbastanza user-friendly? Mi servirebbe chiaramente di qualcosa di sufficientemente potente, senza però arrivare a creare un engine 3d!
- Che risorse per l'apprendimento posso trovare, nel web o qualcosa di economico nelle librerie, oltre a quelle elencate nel thread sulle guide?
Stavo per suggerire Python (http://www.python.org/).

Poi ho visto che cdimauro è già intervenuto e ha dato un consiglio diverso, per cui... boh...

[Dott.Wisem]

Sinceramente non ne posso più di persone che consigliano Java/C# per ogni richiesta di info su un linguaggio di progr. da usare per un certo scopo...

Vorrei imparare a programmare... Usa Java o C#.
Vorrei creare un blocco note... Usa Java o C#.
Vorrei creare un gestionale... Usa Java o C#.
Vorrei creare un motore 3D... Usa Java o C#.
Vorrei creare un tool di gestione del desktop... Usa Java o C#.
Vorrei creare un sistema operativo... Usa Java o C#.
Vorrei creare un sistema di gestione dei semafori della mia città... Usa Java o C#.
Vorrei creare il software per l'autopilota di una navicella spaziale... Usa Java o C#.
Vorrei creare un robot più intelligente di me (basta poco). Usa Java o C#.
Vorrei creare un software che mi alza la tavoletta del cesso se riconosce che sono maschio, o me la abbassa se sono femmina... Usa Java o C#.

E "abbasta"!! :sofico:

[isAlreadyInUse]

Allora d'ora in poi consiglierò CLIPPER :D

[MaxArt]

Che tipo di software devi sviluppare? Hai scritto in ambito medico, ma si puo' andare dalla gestione delle cartelle cliniche di pazienti, ... all'elaborazione digitale di immagini, alla modellizzazione di casi clinici.Formulazione di diete. Quindi sì, dovrà avere a che fare con un database di alimenti.

Sinceramente non ne posso più di persone che consigliano Java/C# per ogni richiesta di info su un linguaggio di progr. da usare per un certo scopo...Il tuo appunto è valido, ma nel mio caso avevo chiesto io stesso un linguaggio più generico perché questo programma che dovrei realizzare sarebbe solo il primo (spero) di questo mio ritorno alla programmazione.

Però quello della tavoletta del cesso può essere un'idea :asd:

[variabilepippo]

IMHO questa è una delle risposte più sensate (http://forum.ioprogrammo.it/index.php/topic,3661.msg19429.html#msg19429) all'annosa questione del "Con cosa dovrei iniziare?!?". :read:

[AnonimoVeneziano]

IMHO questa è una delle risposte più sensate (http://forum.ioprogrammo.it/index.php/topic,3661.msg19429.html#msg19429) all'annosa questione del "Con cosa dovrei iniziare?!?". :read:

Di questa frase:


e) P-scripting sono ovviamente i linguaggini di scripting che iniziano per P: Python e Perl, nonché - per estensione - anche Ruby e Rebol. D\'altronde, eccetto forse Perl, sono nati per essere appresi nel giro di poche ore, pardon, giorni.



sono curioso di sentire cosa ne pensa Cesare :sofico:

[71104]

progettazione di semplici librerie (e demoni, VxD, DLL...), VxD!! :| non ho capito se scherzava o cosa... :asd: :asd: :asd:

[variabilepippo]

VxD!! :| non ho capito se scherzava o cosa.


Puoi sempre chiederglielo... Quell'utente è un gran mattacchione. :stordita:

[cdimauro]

Stavo per suggerire Python (http://www.python.org/).

Poi ho visto che cdimauro è già intervenuto e ha dato un consiglio diverso, per cui... boh...
Per la mia esperienza, nella realizzazione di applicazioni dotate di GUI, ambienti RAD come Delphi sono impagabili.

Onestamente da un po' di tempo lavoro con Delphi + Python (sempre per progetti dotati di GUI), delegando al primo la realizzazione (e gestione) dell'interfaccia grafica, e spostando sul secondo quanta più logica e gestione del database possibile.
Però non mi sento di consigliare questa soluzione a chi deve ricominciare.

P.S. Esistesse per Python un ambiente RAD produttivo, flessibile e comodo come quello di Delphi avrei già abbandonato quest'ultimo da tempo, ma non ci sono ancora soluzioni comparabili, purtroppo.

[cdimauro]

Di questa frase:

sono curioso di sentire cosa ne pensa Cesare :sofico:
Penso che stesse scherzando. Per lo meno è quello che mi è sembrato di capire leggendo anche il resto del messaggio. :p

[cdimauro]

Poi ho visto che cdimauro è già intervenuto e ha dato un consiglio diverso, per cui... boh...
Dimenticavo: troppo grazia! Il mio è un consiglio valido quanto quello degli altri. :p

[Dott.Wisem]

IMHO questa è una delle risposte più sensate (http://forum.ioprogrammo.it/index.php/topic,3661.msg19429.html#msg19429) all'annosa questione del "Con cosa dovrei iniziare?!?". :read:
Io direi:
- Imparare le basi della programmazione strutturata.
- Imparare il linguaggio C (utile anche per capire come funziona un elaboratore a basso livello ed evitare, in futuro, di creare mostruosità di inefficienze...).
- Imparare BENE i principi dell'Object Oriented.
- Imparare un qualsiasi linguaggio Object Oriented decente (ad esclusione dello SmallTalk che, nonostante sia il più puro dei linguaggi OO, sembra essere pensato per asceti, più che per programmatori). Possibilmente, scegliere un linguaggio che possa essere usato proficuamente anche nel seguito della propria carriera lavorativa (e qui, detesto dirlo, ma... Usare Java o C# :D). Il C++ oggi non ha più molta importanza, se non in progetti dove le massime performance sono l'assoluta priorità.
- Studiare la teoria dei database relazionali ed imparare l'SQL.
- Imparare ad interfacciare la propria applicazione con un database.

Parallelamente a tutto questo sarebbe bene imparare concetti di base sulle comunicazioni di rete, protocolli TCP/IP, linguaggio HTML, linguaggi di scripting. A piccole dosi però, approfondendo man mano che dovesse sorgere la necessità.

[sottovento]

Per questo tipo di applicazioni c'è anche Delphi che è eccellente per sviluppare applicazioni dotate di GUI, ed esiste sia in versione Win32 che .NET.

Non lo conosco, ma se dovessi realizzare un'applicazione come quella in oggetto penso che seguirei il tuo consiglio.

[cdimauro]

Io direi:
- Imparare le basi della programmazione strutturata.
- Imparare il linguaggio C (utile anche per capire come funziona un elaboratore a basso livello ed evitare, in futuro, di creare mostruosità di inefficienze...).
- Imparare BENE i principi dell'Object Oriented.
- Imparare un qualsiasi linguaggio Object Oriented decente (ad esclusione dello SmallTalk che, nonostante sia il più puro dei linguaggi OO, sembra essere pensato per asceti, più che per programmatori). Possibilmente, scegliere un linguaggio che possa essere usato proficuamente anche nel seguito della propria carriera lavorativa (e qui, detesto dirlo, ma... Usare Java o C# :D). Il C++ oggi non ha più molta importanza, se non in progetti dove le massime performance sono l'assoluta priorità.
- Studiare la teoria dei database relazionali ed imparare l'SQL.
- Imparare ad interfacciare la propria applicazione con un database.

Parallelamente a tutto questo sarebbe bene imparare concetti di base sulle comunicazioni di rete, protocolli TCP/IP, linguaggio HTML, linguaggi di scripting. A piccole dosi però, approfondendo man mano che dovesse sorgere la necessità.
In sostanza, a parte il C che è il linguaggio inutile per eccellenza (visto che il C++ ne è un superset), con Python potresti fare tutto ciò che hai detto e con un linguaggio strutturalmente molto più semplice di quelli che hai citato. :p
Non lo conosco, ma se dovessi realizzare un'applicazione come quella in oggetto penso che seguirei il tuo consiglio.
http://www.codegear.com/products/turbo

Qui ci sono le versioni gratuite di Delphi per Win32 e .NET. :)

[fek]

Io direi:
- Imparare le basi della programmazione strutturata.
- Imparare il linguaggio C (utile anche per capire come funziona un elaboratore a basso livello ed evitare, in futuro, di creare mostruosità di inefficienze...).
- Imparare BENE i principi dell'Object Oriented.

Per imparare bene i principi dell'OO, deve dimenticare cio' che ha imparato dal C e dalla programmazione strutturata. E allora perche' iniziare da li' e non direttamente dall'OO? :)

[k0nt3]

Per imparare bene i principi dell'OO, deve dimenticare cio' che ha imparato dal C e dalla programmazione strutturata. E allora perche' iniziare da li' e non direttamente dall'OO? :)

perchè è assolutamente falso che deve dimenticare la programmazione strutturata visto che è anche alla base del paradigma OO.
forse intendevi programmazione procedurale, anche io ho confuso le cose qualche volta :fagiano:

[Dott.Wisem]

In sostanza, a parte il C che è il linguaggio inutile per eccellenza (visto che il C++ ne è un superset), con Python potresti fare tutto ciò che hai detto e con un linguaggio strutturalmente molto più semplice di quelli che hai citato. :pIl 'C' è fondamentale per prendere familiarità con una sintassi che è diffusissima fra i linguaggi di programmazione più in voga, nonché per apprendere dei meccanismi di basso livello, come la gestione della memoria (heap e stack). Secondo me è utile proprio per farsi le ossa, non ho mai detto che si debba imparare per scriverci, oggi, applicazioni vere e proprie (sebbene nessuno lo vieti). Il Python non l'ho mai usato, ma anche se fosse il linguaggio più bello del mondo (cosa di cui dubito fortemente), io credo sia meglio consigliare di imparare quei linguaggi che sono maggiormente usati oggi nelle aziende. Quante aziende, in Italia, usano massicciamente Python? Quante usano Java o C#?

[fek]

perchè è assolutamente falso che deve dimenticare la programmazione strutturata visto che è anche alla base del paradigma OO.
forse intendevi programmazione procedurale, anche io ho confuso le cose qualche volta :fagiano:

Ehm... Riedito per colpa del mio mononeurone in crisi.

No, nella programmazione strutturata ti insegnano ad esempio che ogni funzione deve avere un punto di ingresso e un punto di uscita. E' una di quelle cose che devi dimenticate se vuoi inizare a scrivere del buon codice, come devi disimparare ad affidarti a cicli, strutture if, switch per programmare orientato agli oggetti, quindi affidandoti al polimorfismo per risolvere le catene di if, agli iteratori per evitare cicli for, etc. Ne abbiamo avuto un ottimo esempio in Diamonds proprio oggi: una catena di if eliminata a colpi di refactoring.

Il 'C' è fondamentale per prendere familiarità con una sintassi che è diffusissima fra i linguaggi di programmazione più in voga, nonché per apprendere dei meccanismi di basso livello,

Ma puoi prendere familiarita' con la sintassi C in un linguaggio come Java e non e' assolutamente importante apprendere meccanismi a basso livello. Puoi essere uno strepitoso programmatore senza assolutamente conoscere come funziona l'heap, o il modello di memoria del C, ma semplicemente sapendo risolvere problemi. C'e' sempre tempo per scendere nei particolari e imparare questi dettagli: all'inizio si deve imparare a risolvere problemi, non ad allocare blocchi di memoria nell'heap.

[Dott.Wisem]

Per imparare bene i principi dell'OO, deve dimenticare cio' che ha imparato dal C e dalla programmazione strutturata. E allora perche' iniziare da li' e non direttamente dall'OO? :)I concetti della programmazione strutturata si applicano tranquillamente anche nell'OO, che ne rappresenta un'evoluzione. A me piace affermare che l'OO rappresenta la "strutturazione" della programmazione strutturata. :D

[fek]

I concetti della programmazione strutturata si applicano tranquillamente anche nell'OO, che ne rappresenta un'evoluzione. A me piace affermare che l'OO rappresenta la "strutturazione" della programmazione strutturata. :D

La tua definizione mi piace :)
E' un'ulteriore astrazione, ma come tale e' meglio impararla subito. Ti faccio un esempio concreto:


if(droppable.getGridObject().getType().isFlashingGem()
&& !droppable.getFallingObject().isFalling())
{
listOfFlashingGems.add(droppable);
}


Questo e' OOP? :)
Eppure in C scriveresti qualcosa di equivalente, perche' questo ti viene insegnato.

Poi devi dimenticarlo e iniziare a scrivere una cosa tipo:


droppable.addIfNotFallingTo(listOfFlashingGems);


Dove il metodo e' polimorfico, che sara' implementato solo da falshing gem . In tutta l'implementazione l'if sparisce. Chi ha scritto il primo codice veniva dritto dal C/C++. Io ad un principiante impedirei di usare gli if.

[fek]

Altro fresco esempio tratto da Diamonds:


public Droppable getCrushableByFlashAt(Cell cell)
{
Droppable gem = getDroppableAt(cell);

if(gem == null)
{
return null;
}

if(gem.getFallingObject() != null && gem.getFallingObject().isFalling())
{
return null;
}

if(gem.getGridObject().getType().isStone())
{
return null;
}

return gem;
}


Brividi di freddo. Sembra C.
Null Pattern e sparisce il primo if. E poi serve un metodo polimorfico per eliminare gli altri due, ma qui la cosa diventa piu' complessa, proprio perche' chi ha scritto questo codice viene dal C e dal paradigma di programmazione strutturata. Altrimenti non avrebbe mai usato quell'isStone().

E questo codice fa rifattorizzato.

[k0nt3]

fek è vero quello che dici, cioè quando si programma a oggetti bisogna vedere le cose da una prospettiva diversa, ma è anche vero che le strutture di controllo servono sempre. se le hai imparate prima di affrontare la programmazione a oggetti ti puoi concentrare solo sulla programmazione OO, in caso contrario invece devi anche affiancare l'apprendimento della programmazione strutturata. non è così immediato stabilire da cosa è meglio partire

[fek]

fek è vero quello che dici, cioè quando si programma a oggetti bisogna vedere le cose da una prospettiva diversa, ma è anche vero che le strutture di controllo servono sempre. se le hai imparate prima di affrontare la programmazione a oggetti ti puoi concentrare solo sulla programmazione OO, in caso contrario invece devi anche affiancare l'apprendimento della programmazione strutturata. non è così immediato stabilire da cosa è meglio partire

Ma infatti io penso che si debbano insegnare le strutture di controllo mentre si programma in un linguaggio ad alto livello che ti costringe all'OOP. "Guarda, qui devi creare un metodo virtuale perche' bla bla bla, ah, eventualmente, se e' troppo complesso, usa un if...".

[Dott.Wisem]

Attenti però con il refactoring. Io lo faccio speso, in modo da risparmiare codice e concentrare le modifiche in poche parti isolate. Però ad abusarne, si rischia di far fumare il cervello inutilmente... :D Io lo applico dove lo ritengo strettamente necessario per guadagnare in manutenibilità. ;)

P.S.: un linguaggio molto carino è questo qua: Suneido (http://www.suneido.com). E' orientato allo sviluppo di applicazioni gestionali ed ha una sintassi Java/C-like. L'ambiente di sviluppo assomiglia molto allo SmallTalk, per chi ci avesse avuto a che fare. E' anche OpenSource.

[k0nt3]

@fek
si ma tu dai per scontato che uno sa usare gli if, i while e tutto il resto :D per certa gente ci vuole un corso solo per imparare a usare quei quattro costrutti di base :asd:

[fek]

Attenti però con il refactoring. Io lo faccio speso, in modo da risparmiare codice e concentrare le modifiche in poche parti isolate. Però ad abusarne, si rischia di far fumare il cervello inutilmente... :D Io lo applico dove lo ritengo strettamente necessario per guadagnare in manutenibilità. ;)

Io non smetto mai di rifattorizzare il codice :)
Per me non e' una fase della programmazione, e' la norma, la mia metodologia di design del codice. Io progetto il codice mentre lo scrivo e lo rifattorizzo allo stesso tempo. Non c'e' codice che ho scrivo che non sia allo stesso tempo rifattorizzato. E' incredibile quanto tempo risparmio facendo cosi' (soprattutto perche' non sovraingegnerizzo, ma questo e' un altro discorso).

Fatti un giro per Diamonds... su su su.

@fek
si ma tu dai per scontato che uno sa usare gli if, i while e tutto il resto :D per certa gente ci vuole un corso solo per imparare a usare quei quattro costrutti di base :asd:

Ma e' proprio questo il punto, io non glielo voglio insegnare che cos'e' un if. Ho tenuto tanti anni fa corsi di Java e C++ quando stavo finendo l'universita', e non gli insegnavo gli if, gli insegnavo a programmare. Poi l'uso di questi costrutti gli usciva naturale.

[^TiGeRShArK^]

..però in certi casi eliminare la complessità ciclomatica di un metodo, a parte l'utilizzo dell'extract method è piuttosto incasinato...
o quanto meno per me :fagiano:
esempio:

public void onFileChanged(object sender, FileSystemEventArgs file)
{
if ((file.FullPath.Replace("\\\\", "\\")) != Logger.getLogFile())
{
if (fileRenamed)
{
fileRenamed = false;
}
else
{
copyFile(sender, file);
}
}
}


private void copyFile(object sender, FileSystemEventArgs file)
{
string baseDir = getBaseDir((FileSystemWatcher)sender);
baseDir = baseDir.Replace(":", "");
if (file.ChangeType != WatcherChangeTypes.Deleted)
{
if (!isTemporaryFile(file.Name) && !Directory.Exists(file.FullPath))
{
Logger.log(file.FullPath + " changed.");
Logger.log("Starting copy worker");
CopyFileWorker worker = new CopyFileWorker(file.FullPath, destDir + '\\' + baseDir + '\\' + file.Name);
Thread workerThread = new Thread(worker.doWork);
workerThread.Start();
while (!workerThread.IsAlive) ;
Logger.log("copy worker started");
}
}
}

..come fare a eliminare la catena di if in questo caso? :mbe:
...è un handler del FileSystemListener... quindi il tipo di evento che lancia non lo posso personalizzare ...
come si fa a "decidere" quale ramo seguire senza strutture di controllo visto che non posso usare il polimorfismo? :fagiano:

ah... e il booleano mi serve come variabile di controllo per coordinarmi con un altro handler :fagiano:

[Dott.Wisem]

Io non smetto mai di rifattorizzare il codice :)
Per me non e' una fase della programmazione, e' la norma, la mia metodologia di design del codice. Io progetto il codice mentre lo scrivo e lo rifattorizzo allo stesso tempo. Non c'e' codice che ho scrivo che non sia allo stesso tempo rifattorizzato. E' incredibile quanto tempo risparmio facendo cosi' (soprattutto perche' non sovraingegnerizzo, ma questo e' un altro discorso).
Per quello ci vuole pazienza ed esperienza e... varia da persona a persona. A volte uno è pigro e non si mette a fare refactoring in 'real time', mentre scrive codice. Poi quando è soddisfatto della funzionalità, dà uno sguardo al codice da poco scritto e, se vede nefandezze, rifattorizza. Altre volte, il refactoring viene proprio naturale, essendo che lo si è fatto tante di quelle volte che si intuisce subito dove possa essere assolutamente necessario.
Fatti un giro per Diamonds... su su su.No, ti prego... Già il mio lavoro è precario... :D

[fek]

Perche' non puoi personalizzare il tipo?
Tiger, non ho mai visto una situazione nella quale non fosse possibile togliere una catena di if. Non dico che convenisse sempre, a volte un semplice if e' la soluzione piu' semplice, ma e' sempre possibile eliminarlo se si riproduce per via assessuata di hokuto :D

[fek]

Per quello ci vuole pazienza ed esperienza e... varia da persona a persona. A volte uno è pigro e non si mette a fare refactoring in 'real time', mentre scrive codice. Poi quando è soddisfatto della funzionalità, dà uno sguardo al codice da poco scritto e, se vede nefandezze, rifattorizza. Altre volte, il refactoring viene proprio naturale, essendo che lo si è fatto tante di quelle volte che si intuisce subito dove possa essere assolutamente necessario.

Guarda, rifattorizzare o meno non e' una questione di mancanza di pigrizia, ma piu' di forma mentale. Come dici giustamente ci vuole esperienza: quando impari non ti accorgi di rifattorizzare, lo fai naturalmente. Diventa proprio il tuo modo naturale di scrivere il codice, ed e' perfetto per me che sono un pigrone: scrivo meno codice.

No, ti prego... Già il mio lavoro è precario... :D

Non dirlo a me :D
Ormai ho preso il ritmo di tornare a casa alle 22, accendere msn, mi arriva il puntuale messaggio di Federico "dobbiamo rifattorizzare questo metodo!" e per rilassarmi da 12 ore di C++... mi metto a programmare in Java... ole'.

[^TiGeRShArK^]

ed ecco la versione di copyFile con l'ennesimo extract method...

private void copyFile(object sender, FileSystemEventArgs file)
{
string baseDir = getBaseDir((FileSystemWatcher)sender);
baseDir = baseDir.Replace(":", "");
if (mustCopy(file))
{
Logger.log(file.FullPath + " changed.");
Logger.log("Starting copy worker");
CopyFileWorker worker = new CopyFileWorker(file.FullPath, destDir + '\\' + baseDir + '\\' + file.Name);
Thread workerThread = new Thread(worker.doWork);
workerThread.Start();
while (!workerThread.IsAlive) ;
Logger.log("copy worker started");
}
}


private bool mustCopy(FileSystemEventArgs file)
{
return ((file.ChangeType != WatcherChangeTypes.Deleted) &&
!isTemporaryFile(file.Name) && !Directory.Exists(file.FullPath));
}

[^TiGeRShArK^]

Perche' non puoi personalizzare il tipo?
Tiger, non ho mai visto una situazione nella quale non fosse possibile togliere una catena di if. Non dico che convenisse sempre, a volte un semplice if e' la soluzione piu' semplice, ma e' sempre possibile eliminarlo se si riproduce per via assessuata di hokuto :D
..e come faccio? :p
il FileSystemWatcher mi manda sempre eventi di quel tipo e io le mani a botte di override lì non ce le metto :D
Quindi nel mio handler mi arriva sempre un oggetto di tipo FileSystemEventArgs.
..Per cui a naso direi: no polimorfismo no party :fagiano:

[fek]

private void copyFile(object sender, FileSystemEventArgs file)
{
// sono sicurissimo che questo lo puoi tirare fuori di li' in qualche modo ora
if (!mustCopy(file)) /// puoi girare l'if qui
{
return;
}

string baseDir = getBaseDir((FileSystemWatcher)sender);
baseDir = baseDir.Replace(":", "");

// Extract method qui:

Logger.log(file.FullPath + " changed.");
Logger.log("Starting copy worker");
CopyFileWorker worker = new CopyFileWorker(file.FullPath, destDir + '\\' + baseDir + '\\' + file.Name);
Thread workerThread = new Thread(worker.doWork);
workerThread.Start();
while (!workerThread.IsAlive) ;
Logger.log("copy worker started");

}


private bool mustCopy(FileSystemEventArgs file)
{
return ((file.ChangeType != WatcherChangeTypes.Deleted) &&
!isTemporaryFile(file.Name) && !Directory.Exists(file.FullPath));
}


Prova cosi'.

[fek]

..e come faccio? :p
il FileSystemWatcher mi manda sempre eventi di quel tipo e io le mani a botte di override lì non ce le metto :D
Quindi nel mio handler mi arriva sempre un oggetto di tipo FileSystemEventArgs.
..Per cui a naso direi: no polimorfismo no party :fagiano:

Non conoco l'applicazione quindi vado spannometrico con l'antica tecnica zen del muflone bianco: tiro a caso.
Guarda l'ultima versione del codice, ti suggerisce che magari c'e' un modo per filtrare a monte tutti i file che non devono essere copiati prima che vengono spediti in giro da quell'evento.

[^TiGeRShArK^]

private void copyFile(object sender, FileSystemEventArgs file)
{
// sono sicurissimo che questo lo puoi tirare fuori di li' in qualche modo ora
if (!mustCopy(file)) /// puoi girare l'if qui
{
return;
}

string baseDir = getBaseDir((FileSystemWatcher)sender);
baseDir = baseDir.Replace(":", "");

// Extract method qui:

Logger.log(file.FullPath + " changed.");
Logger.log("Starting copy worker");
CopyFileWorker worker = new CopyFileWorker(file.FullPath, destDir + '\\' + baseDir + '\\' + file.Name);
Thread workerThread = new Thread(worker.doWork);
workerThread.Start();
while (!workerThread.IsAlive) ;
Logger.log("copy worker started");

}


private bool mustCopy(FileSystemEventArgs file)
{
return ((file.ChangeType != WatcherChangeTypes.Deleted) &&
!isTemporaryFile(file.Name) && !Directory.Exists(file.FullPath));
}


Prova cosi'.
mmm....
e perchè mettere?

if (!mustCopy(file)) /// puoi girare l'if qui
{
return;
}
.........

:mbe:
mi pare + leggibile com'era prima :mbe:

[^TiGeRShArK^]

Non conoco l'applicazione quindi vado spannometrico con l'antica tecnica zen del muflone bianco: tiro a caso.
Guarda l'ultima versione del codice, ti suggerisce che magari c'e' un modo per filtrare a monte tutti i file che non devono essere copiati prima che vengono spediti in giro da quell'evento.
ah capito ora :D
no.. non si può perchè devo avere un comportamento diverso in caso sia stato precedentemente lanciato un evento di rename..
mmm...
però spè..
forse pensandoci ora posso provare a settare il booleano sempre e cmq a false...
In quel modo potrei trattare tutti i tipi di file nello stesso modo....
..sperando che non scoppi tutto :fagiano:

[fek]

mmm....
e perchè mettere?

if (!mustCopy(file)) /// puoi girare l'if qui
{
return;
}
.........

:mbe:
mi pare + leggibile com'era prima :mbe:

Questo e' un refactoring Cinese. Si chiamano if-guard e io le uso a tappeto. Hanno questa strana proprieta' di aprire la strada ad altri refactoring, soprattutto nei cicli e rendono il codice piu' logico eliminando quelle odiose catene di if che spaginano. Ormai lo faccio praticamente senza pensarci, giro tutti gli if.

C'e' anche un refactoring di Fowler che tratta questi casi.

Occhio a non usare come ho fatto qui gli if negati (ho questo brutto vizio io): meglio cambiare il nome del metodo.

[^TiGeRShArK^]

no.. non si può.....
il booleano va trattato per forza in maniera diversa...
quindi al max posso arrivare a questo credo..:

public void onFileChanged(object sender, FileSystemEventArgs file)
{
if (fileRenamed)
{
fileRenamed = false;
}
else
{
copyFile(sender, file);
}
}


private void copyFile(object sender, FileSystemEventArgs file)
{
if (mustCopy(file))
{
string baseDir = getBaseDir((FileSystemWatcher)sender);
baseDir = baseDir.Replace(":", "");
Logger.log(file.FullPath + " changed.");
Logger.log("Starting copy worker");
CopyFileWorker worker = new CopyFileWorker(file.FullPath, destDir + '\\' + baseDir + '\\' + file.Name);
Thread workerThread = new Thread(worker.doWork);
workerThread.Start();
while (!workerThread.IsAlive) ;
Logger.log("copy worker started");
}
}


private bool mustCopy(FileSystemEventArgs file)
{
return ((file.ChangeType != WatcherChangeTypes.Deleted) &&
!isTemporaryFile(file.Name) && !Directory.Exists(file.FullPath)) &&
(file.FullPath.Replace("\\\\", "\\")) != Logger.getLogFile();
}

..con mustCopy che è una mostruosità :eek:

[^TiGeRShArK^]

Questo e' un refactoring Cinese. Si chiamano if-guard e io le uso a tappeto. Hanno questa strana proprieta' di aprire la strada ad altri refactoring, soprattutto nei cicli e rendono il codice piu' logico eliminando quelle odiose catene di if che spaginano. Ormai lo faccio praticamente senza pensarci, giro tutti gli if.

C'e' anche un refactoring di Fowler che tratta questi casi.

Occhio a non usare come ho fatto qui gli if negati (ho questo brutto vizio io): meglio cambiare il nome del metodo.
ah la tecnica del return nell'if in effetti non la uso quasi mai..
preferisco sempre eseguire il mio codice nel lato positivo e non mettere il ramo negativo con il return perchè tanto alla fine esce automaticamente dal metodo...

[fek]

ah la tecnica del return nell'if in effetti non la uso quasi mai..
preferisco sempre eseguire il mio codice nel lato positivo e non mettere il ramo negativo con il return perchè tanto alla fine esce automaticamente dal metodo...

Ma vedi che e' illogico come e' scritto ora?
Il path tipico del metodo e' quello nell'if nella tua versione, e si legge come l'if che e' un eccezione ad un metodo che naturalmente fa... nulla.

Gira quell'if, cambia nome al metodo e rifattorizza quel mustCopy che e' orrido!

[AnonimoVeneziano]

..ed e' perfetto per me che sono un pigrone ...



... e per rilassarmi da 12 ore di C++... mi metto a programmare in Java... ole'.

Queste due frasi non combinano proprio :sofico:

Ciao

PS = Ma gli shaders per DX9/10 in che linguaggio si scrivono?

[^TiGeRShArK^]

voilà..

public void onFileChanged(object sender, FileSystemEventArgs file)
{
if (isCopyNotNeeded(file))
{
fileRenamed = false;
return;
}
copyFile(sender, file);
}


private void copyFile(object sender, FileSystemEventArgs file)
{
string baseDir = getBaseDir((FileSystemWatcher)sender);
baseDir = baseDir.Replace(":", "");
Logger.log(file.FullPath + " changed.");
Logger.log("Starting copy worker");
CopyFileWorker worker = new CopyFileWorker(file.FullPath, destDir + '\\' + baseDir + '\\' + file.Name);
Thread workerThread = new Thread(worker.doWork);
workerThread.Start();
while (!workerThread.IsAlive) ;
Logger.log("copy worker started");
}


private bool isCopyNotNeeded(FileSystemEventArgs file)
{
if (fileRenamed || isDeleted(file) || isDirectory(file) || isLogFile(file))
{
return true;
}
return false;
}

..meglio di così mi sa che non si può.. :fagiano:

EDIT:
ultima modifca che non ce la facevo a lasciarla in quel modo :asd:

public void onFileChanged(object sender, FileSystemEventArgs file)
{
if (isCopyNeeded(file))
{
copyFile(sender, file);
}
}

...e ora si deve vedere se funge tutto... :eek:

[^TiGeRShArK^]

..a parte un not che mi ero ovviamente perso nel refactoring va che è un bijoux :D
ora committo va :p

[fek]

..a parte un not che mi ero ovviamente perso nel refactoring va che è un bijoux :D
ora committo va :p

Molto meglio ora no? Non hai la netta sensazione di aver reso il mondo un posto un po' migliore?


private bool isCopyNotNeeded(FileSystemEventArgs file)
{
if (fileRenamed)
{
return true;
}
if (isDeleted(file))
{
return true;
}
if (isDirectory(file))
{
return true;
}
if (isLogFile(file))
{
return true;
}
return false;
}



Aaaah, adoro gli if guard. E sono certo che con un attimo di pazienza mi togli pure questi if :)

[MaxArt]

Ehm, mi fa piacere che questa discussione vi interessi così tanto :stordita:

Ma infatti io penso che si debbano insegnare le strutture di controllo mentre si programma in un linguaggio ad alto livello che ti costringe all'OOP. "Guarda, qui devi creare un metodo virtuale perche' bla bla bla, ah, eventualmente, se e' troppo complesso, usa un if...".Immagino che a questo punto non stiate parlando di me, ma in generale, visto che ho detto che la programmazione strutturata è sostanzialmente l'unica cosa che ho mai fatto... :asd:

Io non smetto mai di rifattorizzare il codice :)Che significa rifattorizzare? :stordita:

[fek]

Che significa rifattorizzare? :stordita:

Pentiti!

Questa e' la Parola:

http://www.refactoring.com/
What is Refactoring?
Refactoring is a disciplined technique for restructuring an existing body of code, altering its internal structure without changing its external behavior. Its heart is a series of small behavior preserving transformations. Each transformation (called a 'refactoring') does little, but a sequence of transformations can produce a significant restructuring. Since each refactoring is small, it's less likely to go wrong. The system is also kept fully working after each small refactoring, reducing the chances that a system can get seriously broken during the restructuring.



Questa e' la Bibbia:

http://www.amazon.com/Refactoring-Improving-Existing-Addison-Wesley-Technology/dp/0201485672

[^TiGeRShArK^]

Ehm, mi fa piacere che questa discussione vi interessi così tanto :stordita:

Immagino che a questo punto non stiate parlando di me, ma in generale, visto che ho detto che la programmazione strutturata è sostanzialmente l'unica cosa che ho mai fatto... :asd:

Che significa rifattorizzare? :stordita:

..quello che ho appena fatto in questo thread :D
in pratica cambiare il codice senza modificarne le funzionalità esposte all'esterno in modo da avere un codice + leggibile... :p

[^TiGeRShArK^]

Molto meglio ora no? Non hai la netta sensazione di aver reso il mondo un posto un po' migliore?


private bool isCopyNotNeeded(FileSystemEventArgs file)
{
if (fileRenamed)
{
return true;
}
.........
}



Aaaah, adoro gli if guard. E sono certo che con un attimo di pazienza mi togli pure questi if :)

mmm...
a questo c'ero arrivato al passo precedente di:

private bool isCopyNotNeeded(FileSystemEventArgs file)
{
if (fileRenamed || isDeleted(file) || isDirectory(file) || isLogFile(file))
{
return true;
}
return false;
}

..poi li avevo tolti perchè nel codice definitivo non mi piacciono tanto gli if-guard :fagiano:
..dici che posso eliminare anche quella catena di if? :mbe:

[^TiGeRShArK^]

..dici che posso eliminare anche quella catena di if? :mbe:
eh..
potendo creare dei figli di FileSystemEventArgs e passando all'handler il figlio corretto sarebbe una cavolata..
ma qui il polimorfismo non lo posso usare... :fagiano:
...altre soluzioni? :mbe:

[cdimauro]

Il 'C' è fondamentale per prendere familiarità con una sintassi che è diffusissima fra i linguaggi di programmazione più in voga,
E' una sintassi a dir poco ORRIDA e che invoglia alla scrittura di codice poco leggibile: meglio cercare di liberarsene.
nonché per apprendere dei meccanismi di basso livello, come la gestione della memoria (heap e stack).
Che sono del tutto inutili ai fini della risoluzione di un problema. Per farsi male con queste cose (e altre di livello ancora più basso) c'è sempre tempo.
Secondo me è utile proprio per farsi le ossa, non ho mai detto che si debba imparare per scriverci, oggi, applicazioni vere e proprie (sebbene nessuno lo vieti).
Fermo restando quanto scritto sopra, rimane il fatto che il C++ è un SUPERSET del C, per cui è assolutamente privo di senso lavorare con quest'ultimo.
Il Python non l'ho mai usato, ma anche se fosse il linguaggio più bello del mondo (cosa di cui dubito fortemente),
[PYNTEGRALISTA MODE ON]
Lo è, lo è. :D
[PYNTEGRALISTA MODE OFF]
io credo sia meglio consigliare di imparare quei linguaggi che sono maggiormente usati oggi nelle aziende. Quante aziende, in Italia, usano massicciamente Python? Quante usano Java o C#?
Io credo che prima di tutto bisogna imparare a programmare, e per questo Python IMHO rappresenta l'optimum, e poi, se proprio necessario, si può sempre passare a lavorare con altri linguaggi per masochisti autolesionisti.

[cdimauro]

Pentiti!

Questa e' la Parola:

http://www.refactoring.com/
What is Refactoring?
Refactoring is a disciplined technique for restructuring an existing body of code, altering its internal structure without changing its external behavior. Its heart is a series of small behavior preserving transformations. Each transformation (called a 'refactoring') does little, but a sequence of transformations can produce a significant restructuring. Since each refactoring is small, it's less likely to go wrong. The system is also kept fully working after each small refactoring, reducing the chances that a system can get seriously broken during the restructuring.



Questa e' la Bibbia:

http://www.amazon.com/Refactoring-Improving-Existing-Addison-Wesley-Technology/dp/0201485672
Mi sa che il forum si sta riempendo di predicatori... :p

Comunque nel caso dello sviluppo di videogiochi per telefonini purtroppo non è sempre possibile utilizzare classi & polimorfismo "come da manuale".

Ad esempio con la famigerata serie 40 di Nokia col profilo J2ME "base" abbiamo un limite di 64KB per il JAR del gioco e 200KB per l'heap (se non ricordo male), e inoltre la sola definizione di una classe si porta via ben 500 byte (circa) di memoria (per non parlare del fatto che un boolean richiede ben QUATTRO byte, per cui si è costretti a usare il tipo byte, definire le costanti true e false come 1 e 1, ed eseguire casting da byte a boolean dove c'è da testare delle condizioni :muro:).
A queste condizioni la tendenza è avere pochissime classi (SIGH) e catene di if (RI-SIGH) per risparmiare quanta più memoria possibile. :(

[^TiGeRShArK^]

Mi sa che il forum si sta riempendo di predicatori... :p

Comunque nel caso dello sviluppo di videogiochi per telefonini purtroppo non è sempre possibile utilizzare classi & polimorfismo "come da manuale".

Ad esempio con la famigerata serie 40 di Nokia col profilo J2ME "base" abbiamo un limite di 64KB per il JAR del gioco e 200KB per l'heap (se non ricordo male), e inoltre la sola definizione di una classe si porta via ben 500 byte (circa) di memoria (per non parlare del fatto che un boolean richiede ben QUATTRO byte, per cui si è costretti a usare il tipo byte, definire le costanti true e false come 1 e 1, ed eseguire casting da byte a boolean dove c'è da testare delle condizioni :muro:).
A queste condizioni la tendenza è avere pochissime classi (SIGH) e catene di if (RI-SIGH) per risparmiare quanta più memoria possibile. :(
cazz delle limitazioni...:mbe:
sono stato fortunatissimo allora a programmare sul 9500 ai tempi :stordita:

[Dott.Wisem]

E' una sintassi a dir poco ORRIDA e che invoglia alla scrittura di codice poco leggibile: meglio cercare di liberarsene.Capisco che sei nato e cresciuto con Pascal e derivati, ma la sintassi base del C, una volta imparata, ti entra nel sangue. E se molti linguaggi importanti di oggi sono derivati da esso (sintatticamente parlando), evidentemente non è solo una mia impressione...
Che sono del tutto inutili ai fini della risoluzione di un problema. Per farsi male con queste cose (e altre di livello ancora più basso) c'è sempre tempo.
Entrare nella filosofia di funzionamento di un elaboratore, per quanto mi riguarda, è una cosa che andrebbe fatta prima e non dopo. In questo modo si riuscirà ad apprezzare molto di più l'utilizzo di un linguaggio, in futuro, che, per esempio, usi garbage collector, che sia dinamicamente tipato, ecc.
Fermo restando quanto scritto sopra, rimane il fatto che il C++ è un SUPERSET del C, per cui è assolutamente privo di senso lavorare con quest'ultimo.E infatti io non ho mai detto che oggi uno debba mettersi a scrivere applicazioni in C. ;)
[PYNTEGRALISTA MODE ON]
Lo è, lo è. :D
[PYNTEGRALISTA MODE OFF]
Mi faresti qualche esempio breve e coinciso da cui si desume il motivo per cui Python debba essere considerato il linugaggio migliore del mondo?
Io credo che prima di tutto bisogna imparare a programmare, e per questo Python IMHO rappresenta l'optimum, e poi, se proprio necessario, si può sempre passare a lavorare con altri linguaggi per masochisti autolesionisti.Purtroppo spesso non si ha la possibilità di adottare il proprio linguaggio preferito, ma bisogna adattarsi al linguaggio che ci impone la situazione.
Interessante la classifica che si può trovare a questo link (http://www.tiobe.com/index.htm?tiobe_index) (che però tiene conto della diffusione su internet, non nelle aziende).

[cdimauro]

Capisco che sei nato e cresciuto con Pascal e derivati, ma la sintassi base del C, una volta imparata, ti entra nel sangue.
Questo non lo metto in dubbio: anch'io ho dovuto impararla e la uso tranquillamente, ma continua a NON piacermi proprio.
E se molti linguaggi importanti di oggi sono derivati da esso (sintatticamente parlando), evidentemente non è solo una mia impressione...
E' dovuto soltanto alla diffusione del C. Se si fosse diffuso un altro linguaggio oggi ne avremmo tanti altri che si ispirerebbero alla sua sintassi.
Entrare nella filosofia di funzionamento di un elaboratore, per quanto mi riguarda, è una cosa che andrebbe fatta prima e non dopo. In questo modo si riuscirà ad apprezzare molto di più l'utilizzo di un linguaggio, in futuro, che, per esempio, usi garbage collector, che sia dinamicamente tipato, ecc.
Ecco, parli di futuro e mi trovi pienamente d'accordo: son tutte cose che andrebbero viste, studiate e utilizzate dopo, nel momento in cui se ne presenterà la necessità. :p
E infatti io non ho mai detto che oggi uno debba mettersi a scrivere applicazioni in C. ;)
Benissimo. :)
Mi faresti qualche esempio breve e coinciso da cui si desume il motivo per cui Python debba essere considerato il linugaggio migliore del mondo?
Te ne faccio tre brevissimi:
>>> import __hello__
Hello world...
>>> from __future__ import braces
File "<stdin>", line 1
SyntaxError: not a chance
>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
:p
Purtroppo spesso non si ha la possibilità di adottare il proprio linguaggio preferito, ma bisogna adattarsi al linguaggio che ci impone la situazione.
Sì, lo so, ma se si ha la forza di portare avanti con convinzione (e argomentazioni :D) le proprie idee, a volte si ha la possibilità di cambiare le cose. ;)
Interessante la classifica che si può trovare a questo link (http://www.tiobe.com/index.htm?tiobe_index) (che però tiene conto della diffusione su internet, non nelle aziende).
Sì, la conosco, e come vedi Python si trova in buona posizione.

Poi agli scettici basta dire che colossi come Google, Yahoo (e mi risulta anche Microsoft, ma devo verificare) usano Python, per togliere di mezzo (o quanto meno ridurre) l'alone di diffidenza nei confronti di questo bellissimo linguaggio. :)

[fek]

E' una sintassi a dir poco ORRIDA e che invoglia alla scrittura di codice poco leggibile: meglio cercare di liberarsene.

Perche' la sintassi di Python con quei due penti e l'indentazione e' bella :|

[fek]

Entrare nella filosofia di funzionamento di un elaboratore, per quanto mi riguarda, è una cosa che andrebbe fatta prima e non dopo.

Sei schiavo della mentalita' dell'hacker. Devi essere pragmatico. Programmare vuol dire risolvere un problema, e puoi risolvere probabilmente il 90% dei problemi senza avere la piu' pallida idea di come sia fatto un elaboratore. E questo numero col passare degli anni aumenta.

Quindi, sapere come e' fatto un elaboratore e' per il 90% dei programmatori perfettamente inutile. Puo' essere imparato dopo come approfondimento, non prima.

[^TiGeRShArK^]

Perche' la sintassi di Python con quei due penti e l'indentazione e' bella :|
:asd:
..sinceramente preferisco le parentesi graffe io per delimitare i blocchi di codice :p
..infatti già ruby mi piace di + dato che generalmente si può scegliere se usare l'end o le parentesi graffe per i blocchi....anche se l'indentazione di default di ruby a due spazi non mi piace proprio.. sono troppo abituato ai 4 spazi ormai :fagiano:

[cdimauro]

Perche' la sintassi di Python con quei due penti e l'indentazione e' bella :|
Lo sapevo che saresti intervenuto. :D

Beh, l'indentazione è quella-che-se-non-la-rispetti-in-Diamonds-ti-spiezzo-le-ditine: "necessaria". Con Python è semplicemente obbligatoria rispettarla, e il codice lo si legge come fosse... pseudocodice.
Fran, non dirmi che i tuoi sorgenti hanno un'indentazione "variabile", perché non ci credo. :p

I due punti servono a separare la condizione dal codice vero e proprio che dev'essere eseguito. Qui è una questione di gusti: io mi sono abituato, e visivamente mi salta all'occhio questo simbolo.
Comunque per la definizione delle label mi sembra si usi allo stesso modo in C/C++... :angel:

[cdimauro]

:asd:
..sinceramente preferisco le parentesi graffe io per delimitare i blocchi di codice :p
..infatti già ruby mi piace di + dato che generalmente si può scegliere se usare l'end o le parentesi graffe per i blocchi....anche se l'indentazione di default di ruby a due spazi non mi piace proprio.. sono troppo abituato ai 4 spazi ormai :fagiano:
More ways to do the SAME thing... :muro:
Già immagino sorgenti che usano indifferentemente l'end o le parentesi graffe. :Puke:

No, Ruby (e peggio ancora PERL) non fa proprio per me... :(

[fek]

Beh, l'indentazione è quella-che-se-non-la-rispetti-in-Diamonds-ti-spiezzo-le-ditine: "necessaria". Con Python è semplicemente obbligatoria rispettarla, e il codice lo si legge come fosse... pseudocodice.
Fran, non dirmi che i tuoi sorgenti hanno un'indentazione "variabile", perché non ci credo. :p

I miei no, ma so esattamente dove un blocco di codice finisce perche' c'e' il delimitatore, mentre in Python mi devo andare a guardare dove e' indentato rispetto al resto :muro:

Chi ha avuto questa brillante idea deve morire di morte lenta ed estremamente dolorosa.

[cdimauro]

Ah, adesso capisco il perché della tua avversione. :stordita:

Però, scusa, non sei d'accordo che una funzione/metodo dev'essere costituito da poche righe di codice? :fiufiu:

Diciamo che, almeno per quanto mi riguarda, l'obiettivo è di avere l'intero corpo di una funzione visibile (anche se alcune volte ho dovuto scriverne di molto lunghe :muro: ).

[fek]

Però, scusa, non sei d'accordo che una funzione/metodo dev'essere costituito da poche righe di codice? :fiufiu:

Assolutamente si'. Ma voglio che questo dipenda da una scelta consapevole del programmatore, non dal fatto che la sintassi del linguaggio e' scritta dal fratellino furbo di Torvalds :D

[cdimauro]

Ci sono IDE come SPE che risolvono il problema in maniera piuttosto gradevole (e funzionale: se si sbaglia l'indentazione viene immediatamente segnalato). :fiufiu:

[^TiGeRShArK^]

Ci sono IDE come SPE che risolvono il problema in maniera piuttosto gradevole (e funzionale: se si sbaglia l'indentazione viene immediatamente segnalato). :fiufiu:
a parte che ormai ad usare qualsiasi cosa non sia eclipse ormai mi viene l'orticaria..:asd:
cmq il fatto di non delimitare chiaramente la fine dei blocchi con un end, con una parentesi graffa o con quello che vuoi, per me diminuisce la leggibilità del codice in quanto ti costringe a "sprecare + risorse del tuo cervello" per ottenere quest'informazione che è invece immediata nel caso dei delimitatori.
Esempio tipico:
io metto le parentesi graffe anche quando devo scrivere qualcosa del genere:

if (fran.hatesPython()) {
return;
}

mentre molti preferiscono usare la sintassi abbreviata:

if (fran.hatesPython())
return;

che è perfettametne equivalente alla sintassi di python e che non mi piace proprio nemmeno in Java/C# o quello che è.
L'unico caso in cui NON uso le parentesi graffe è questo:

while (fran.isNotReadyToGoHome()) ;

hokutoShinken.fight(nantoSeiken);
....

qui preferisco inserire il ; che segnala che non fa niente nella stessa rige del while, però seguito da uno spazio e da una riga vuota in modo da essere visibile.
Va bene che alla fine sono gusti personali..
però penso che diversi su questo forum avversino la sintassi di python soprattutto per questo motivo :p

[cdimauro]

Me ne rendo conto, ma... sui gusti non si discute. :p

Il codice Python lo trovo leggibilissimo, e non faccio fatica a ricercare i blocchi di codice. :)

[mindwings]

questione di abitudine :p

[cdimauro]

a parte che ormai ad usare qualsiasi cosa non sia eclipse ormai mi viene l'orticaria..:asd:
Dimenticavo: prova SPE. Vedrai che ti verrà facilissimo riconoscere dove inizia e finisce un blocco. :)

[fek]

Ci sono IDE come SPE che risolvono il problema in maniera piuttosto gradevole (e funzionale: se si sbaglia l'indentazione viene immediatamente segnalato). :fiufiu:

Ma sarebbe solo bastato non far progettare Python ad una scimmia :D

[fek]

while (fran.isNotReadyToGoHome()) ;




Infinite loop! :cry:

[Ziosilvio]

so esattamente dove un blocco di codice finisce perche' c'e' il delimitatore, mentre in Python mi devo andare a guardare dove e' indentato rispetto al resto
Ma i delimitatori ce li hai anche in Python... esempio:
if len(s)>0: #{
t = s.capitalize()
t += ('... ma quanto sono bravo io :D')
print t
#}
:D

[cdimauro]

ROTFL :rotfl: :rotfl: :rotfl:

Mi ricorda quando lavoravo all'ST e mi sono creato roba come:

#DEFINE endif ;

if (condizione) {
} endif
solo perché odiavo dover scrivere:
if (condizione) {
} /* end if */
:p

P.S. Saranno scimmie che hanno toccato uno strano monolito... :fiufiu:

[^TiGeRShArK^]

Dimenticavo: prova SPE. Vedrai che ti verrà facilissimo riconoscere dove inizia e finisce un blocco. :)

ci ho giochiccchiato un pò ai tempi con Stani's python editor...
Ma tieni conto che a me risultano orribili anche netbeans e visual studio 2008 dopo essermi abituato alle comodità di CTRL + 1 in eclipse :D

[cdimauro]

OK, allora non ci sono speranze: o Eclipse o morte. :p

Per curiosità: che fa CTRL + 1?

[Dott.Wisem]

Questo non lo metto in dubbio: anch'io ho dovuto impararla e la uso tranquillamente, ma continua a NON piacermi proprio.Pensa un po', a me il Pascal (e derivati) ha sempre fatto senso come sintassi. :D

E' dovuto soltanto alla diffusione del C. Se si fosse diffuso un altro linguaggio oggi ne avremmo tanti altri che si ispirerebbero alla sua sintassi. Il C si è diffuso perché all'epoca non c'era niente di simile. Non esisteva un linguaggio ad alto livello che, contemporaneamente, rendeva facile accedere a basso livello alla macchina. Tanti sviluppatori costretti ad usare l'assembler, finalmente poterono passare ad un linguaggio ad alto livello (concentrando l'assembler solo a quelle porzioni critiche). Inoltre in C è stato implementato oltre il 90% del codice Unix originale (e continuò ad essere usato in gran parte dei sistemi unix-like, in seguito sviluppati). Di conseguenza, gran parte degli sviluppatori di software per grossi sistemi informativi, dovettero impararlo. Pian piano il suo successo sconfinò anche nell'ambito dei Personal Computer... Mi ricordo il mitico Turbo-C della Borland... Era tutto quello che un programmatore potesse desiderare: un comodo editor con help integrato, un ottimo debugger ed uno dei migliori compilatori dell'epoca su macchine MS-DOS...

Ecco, parli di futuro e mi trovi pienamente d'accordo: son tutte cose che andrebbero viste, studiate e utilizzate dopo, nel momento in cui se ne presenterà la necessità. :pSe uno certe cose non le impara prima, rischia di riempire tranquillamente il proprio codice di cose del genere:

for (i = 0; i < array.Size(); i++)
{
...
...
}

invece di:

array_size = array.Size();
for (i = 0; i < array_size; i++)
{
...
...
}



Benissimo. :)

Te ne faccio tre brevissimi:
[...]Non ho capito bene... Io intendevo degli esempi di codice (del tipo: "Guarda come è semplice e leggibile questo codice in Python, mentre in altri linguaggi farebbe schifo", non dei proclami di fede. :D

Sì, lo so, ma se si ha la forza di portare avanti con convinzione (e argomentazioni :D) le proprie idee, a volte si ha la possibilità di cambiare le cose. ;)Se ti limiti al proclama di prima, ognuno rimarrà con le sue convinzioni. :D
Sì, la conosco, e come vedi Python si trova in buona posizione.Prendi 10 aziende a caso in Italia, e domanda quanti usano Python come tool di sviluppo... :p
Alla fine, bisogna anche essere pratici. Se poi tu hai un'azienda tutta tua o sei un libero professionista, allora ovviamente puoi usare il linguaggio che ti pare. :)

[Dott.Wisem]

Sei schiavo della mentalita' dell'hacker. Devi essere pragmatico. Programmare vuol dire risolvere un problema, e puoi risolvere probabilmente il 90% dei problemi senza avere la piu' pallida idea di come sia fatto un elaboratore. E questo numero col passare degli anni aumenta.

Quindi, sapere come e' fatto un elaboratore e' per il 90% dei programmatori perfettamente inutile. Puo' essere imparato dopo come approfondimento, non prima.Saper risolvere un problema in astratto è un conto. Saperlo implementare in maniera decente (ovvero in un modo che sia il miglior compromesso fra efficienza e manutenibilità) è un altro... Magari sarà per questo che il DWM di Vista, in termini di framerate, non ha performance paragonabili a Quartz di MacOSX? DWM e Quartz fanno entrambi le stesse cose. Solo che, a parità di hardware, il secondo le fa decisamente meglio...

[fek]

Saper risolvere un problema in astratto è un conto. Saperlo implementare in maniera decente (ovvero in un modo che sia il miglior compromesso fra efficienza e manutenibilità) è un altro... Magari sarà per questo che il DWM di Vista, in termini di framerate, non ha performance paragonabili a Quartz di MacOSX? DWM e Quartz fanno entrambi le stesse cose. Solo che, a parità di hardware, il secondo le fa decisamente meglio...

Quando parlo di "risolvere un problema", intendo risolvere il problema che e' posto dal cliente quindi nei limiti prestazionali che sono imposti e nei tempi previsti di consegna. Nel 90% dei casi per implementare una soluzione funzionante esattamente come richiesta dal cliente ed entro i limiti imposti non e' necessario conoscere i dettagli dell'elaboratore.

Nota: Il DWM non aggiorna tutto lo schermo ad una cadenza fissa come un videogioco, ma solo quello che necessita' essere renderizzato.

[Dott.Wisem]

Quando parlo di "risolvere un problema", intendo risolvere il problema che e' posto dal cliente quindi nei limiti prestazionali che sono imposti e nei tempi previsti di consegna. Nel 90% dei casi per implementare una soluzione funzionante esattamente come richiesta dal cliente ed entro i limiti imposti non e' necessario conoscere i dettagli dell'elaboratore.Ovviamente, io per dettagli non intendo conoscere in una CPU quante unità ALU, quante unità FPU, quante pipeline ci sono, quanto sono lunghe, se è un'architettura in-order o out-of-order, quanta cache L1 e L2 c'è a disposizione, ecc., ma giusto quei principi di base che ti evitano di compiere degli errori grossolani che, anche se il software creato funzionerà uguale, lo penalizzeranno di una grossa percentuale nelle performance.
Certo, a volte, la cosa non conta minimamente, nel senso che l'ammontare dei dati da gestire non è e non sarà mai tale da determinare preoccupazioni nel caso in cui ci siano delle inefficienze anche pesanti.
Ma se uno non si abitua a cercare la buona programmazione fin da subito, sono convinto che finirà per creare codice ingombrante e inefficiente anche in situazioni dove andrebbe ricercato un minimo di efficienza.
Il lusso di programmare "in maniera comoda", per me se lo può permettere solo chi ha sufficiente esperienza da poter giudicare che, in alcune situazioni è desiderabile perdere in performance e guadagnare notevolmente in leggibilità.

[fek]

Il lusso di programmare "in maniera comoda", per me se lo può permettere solo chi ha sufficiente esperienza da poter giudicare che, in alcune situazioni è desiderabile perdere in performance e guadagnare notevolmente in leggibilità.

A parte che nella stragrande maggioranza dei casi e' desiderabile perdere in performance e guadagnare in leggibilita', a meno che un profiler dica il contrario e ci sia un constraint di qualche tipo da raggiungere, ma, ripeto, il 90% dei programmatori non incontra mai questa situazione. E per loro conoscere il modello di memoria del C e' del tutto superfluo. Non gli aiutera' a risolvere piu' problemi.

Ma qui il problema e' addirittura a monte: e' gia' superfluo per la maggior parte dei programmatori, figurati per uno che prima di sapere che cos'e' una malloc deve imparare che cos'e' un oggetto...

[^TiGeRShArK^]

OK, allora non ci sono speranze: o Eclipse o morte. :p

Per curiosità: che fa CTRL + 1?

non sai che fa CTRL + 1? :D
TUTTO! :D
è un content assist contestualizzato in base a quello che stai facendo...
qualche esempio...
scrivo:
socket.getInputStream();
e spingo CTRL + 1 e faccio INVIO.
Mi crea automaticamente una variabile del tipo corretto e che ha un nome che mi fa scegliere tra inputStream, iStream, is.
Altro esempio...
voglio rinominare una variabile o un metodo....
CTRL + 1 sulla variabile e scelgo rename (in caso non ricordassi la notissima shortcut ALT+SHIFT+R :asd: )
vuoi convertire la variabile locale su cui sei col cursore in quel momento in un field?
..niente di + semplice....
CTRL + 1, scegli l'opzione giusta (dovrebbe essere una volta verso l'altro se non erro :asd: ) e via.. fa tutto lui :D
e cmq ci sono molte altre cose che puoi fare con CTRL+1 e che ora non mi vengono in mente.
Queta è senza dubbio la feature di Eclipse di cui sento maggiormente la mancanza utilizzando altri editor :cry:
niente

[^TiGeRShArK^]

Se uno certe cose non le impara prima, rischia di riempire tranquillamente il proprio codice di cose del genere:

for (i = 0; i < array.Size(); i++)
{
...
...
}

infatti questo è orrido.

invece di:

array_size = array.Size();
for (i = 0; i < array_size; i++)
{
...
...
}

Ma questo è anche peggio.
legge del perfetto profiler:
1) IL problema prestazionale non è MAI dove lo immagini, quindi NON ottimizzare facendo assunzioni quasi certamente sbagliate.
2) Nel caso tu voglia ottimizzare ricordati il punto primo.
3) SE e SOLO SE hai effettivametne dei problemi prestazionali che ti impediscono di soddisfare i requisiti del committente allora fai un profiling del codice.
4) DOPO il profiling puoi trovare una migliore soluzione ALGORITMICA al tuo problema.
5) Se non sei riuscito in alcun modo a trovare una soluzione ALGORITMICA al tuo problema allora puoi ottimizzare a livello di codice seguendo pedissequamente le informazioni ottenute dal profiler.

Tutto questo per dire cosa?
che il codice migliore nel caso che hai esposto è il seguente in java:

for (String string : array) {
do.whatEver.you.want.with(string);
}

o in C#:

foreach (string element in array) {
do.WhatEver.You.Want.With(element);
}

che è indubbiamente molto immediato e leggibile...
ah..ovviamente l'optimum sarebbe avere un'array con un nome + significativo di "array", ma ho usato la variabile che hai usato tu per chiarezza :p

Non ho capito bene... Io intendevo degli esempi di codice (del tipo: "Guarda come è semplice e leggibile questo codice in Python, mentre in altri linguaggi farebbe schifo", non dei proclami di fede. :DSe ti limiti al proclama di prima, ognuno rimarrà con le sue convinzioni. :DPrendi 10 aziende a caso in Italia, e domanda quanti usano Python come tool di sviluppo... :p
Alla fine, bisogna anche essere pratici. Se poi tu hai un'azienda tutta tua o sei un libero professionista, allora ovviamente puoi usare il linguaggio che ti pare. :)
:fiufiu:

:asd:

[fek]

for (i = 0; i < array.Size(); i++)
{
...
...
}

invece di:

array_size = array.Size();
for (i = 0; i < array_size; i++)
{
...
...
}

E fa bene ad usare la prima versione, che e' piu' leggibile della seconda e tanto qualunque compilatore sul pianeta ottimizza array.Size() perche' e' un valore costante che puo' essere portato fuori dal loop :)

Mai pregiudicare la leggibilita' per una presunta ottimizzazione tanto piu' se il compilatore la fa per noi.

[^TiGeRShArK^]

E fa bene ad usare la prima versione, che e' piu' leggibile della seconda e tanto qualunque compilatore sul pianeta ottimizza array.Size() perche' e' un valore costante che puo' essere portato fuori dal loop :)

Mai pregiudicare la leggibilita' per una presunta ottimizzazione tanto piu' se il compilatore la fa per noi.
è meglio la mia versione :mad:

:asd:

P.S. quando è possibile usare degli iteratori ovviamente, aggiungo per completezza ;)

[fek]

è meglio la mia versione :mad:

Si', maledetto il giorno che ho imparato il C++ :muro:

[Dott.Wisem]

E va beh, ora non stiamo a sottilizzare, l'esempio magari non era perfettamente calzante, ma si era capito il senso. :p

Io, nel linguaggio che uso spesso, ad esempio, l'avrei scritto così:

for obj in array { ... }

che è molto meglio di tutti i codici sopra esposti. Da notare che l'array può essere composto da elementi eterogenei e, quindi, ogni obj può essere un oggetto di tipo diverso (il linguaggio è dinamicamente tipato).

[^TiGeRShArK^]

eh beh..
pure:

elements.each {|element|
do.wathever.you.want.with element
}

non è male :p

(da notare la mancanza delle parentesi tonde intorno ad element che me gusta mucho :asd: )

[Dott.Wisem]

eh beh..
pure:

elements.each {|element|
do.wathever.you.want.with element
}

non è male :p

(da notare la mancanza delle parentesi tonde intorno ad element che me gusta mucho :asd: )Lo potrei fare anche io in questo modo (sempre usando lo stesso linguaggio), ma mi risulta molto più leggibile come l'ho scritto prima. :p

[cdimauro]

Pensa un po', a me il Pascal (e derivati) ha sempre fatto senso come sintassi. :D
E' sempre una questione di gusti, ma almeno il Pascal ha una sintassi decisamente più leggibile. ;)
Il C si è diffuso perché all'epoca non c'era niente di simile. Non esisteva un linguaggio ad alto livello che, contemporaneamente, rendeva facile accedere a basso livello alla macchina. Tanti sviluppatori costretti ad usare l'assembler, finalmente poterono passare ad un linguaggio ad alto livello (concentrando l'assembler solo a quelle porzioni critiche).
Esistevano già altri linguaggi come il Pascal e il BCPL (l'ho citato perché è da questo che il C è stato derivato) usati anche per la programmazione di sistema (se fai qualche ricerca vedrai che ci sono esempi di s.o. scritti in Pascal, di cui alcuni molto vecchi).
Inoltre in C è stato implementato oltre il 90% del codice Unix originale (e continuò ad essere usato in gran parte dei sistemi unix-like, in seguito sviluppati). Di conseguenza, gran parte degli sviluppatori di software per grossi sistemi informativi, dovettero impararlo.
Infatti il suo successo è legato a Unix.
Pian piano il suo successo sconfinò anche nell'ambito dei Personal Computer... Mi ricordo il mitico Turbo-C della Borland... Era tutto quello che un programmatore potesse desiderare: un comodo editor con help integrato, un ottimo debugger ed uno dei migliori compilatori dell'epoca su macchine MS-DOS...
Però hai dimenticato il buon vecchio Turbo Pascal, che precedette il Turbo di C di un bel po' di anni (ricordo che usavo la versione 3.0 nel 1985 a scuola, al terzo anno dell'ITIS) e che, oltre a essere forse il primo IDE integrato, offriva la possibilità di inserire codice in linguaggio macchina tramite la keyword inline. ;)
Se uno certe cose non le impara prima, rischia di riempire tranquillamente il proprio codice di cose del genere:

for (i = 0; i < array.Size(); i++)
{
...
...
}

invece di:

array_size = array.Size();
for (i = 0; i < array_size; i++)
{
...
...
}
Spiegami che c'entra la conoscenza di "certe cose" (si parlava di dettagli di più basso livello, e io qui non ne vedo proprio) coi due pezzi di codice che hai riportato. :mbe:

Per il resto quoto Fran e Danilo e rilancio:
for Element in Array:
Do.WhatEver.You.Want.With(Element)
:D
Non ho capito bene... Io intendevo degli esempi di codice (del tipo: "Guarda come è semplice e leggibile questo codice in Python, mentre in altri linguaggi farebbe schifo", non dei proclami di fede. :D
Non so quanto sarebbe significativo riportati singoli pezzi di codice che mostrino l'utilizzo dei vari costrutti e/o tipi che un linguaggio come Python mette a disposizione.

Comunque un esempietto l'aveva fornito ZioSilvio in precedenza e un altro te l'ho fornito io qui sopra (che mostra l'uso di un iteratore su un tipo "sequenza"; quindi è "compatibile" con tuple, liste, dizionari, insiemi, e in generale qualunque oggetto che esponga adeguati metodi di iterazione).

Se sei interessato ti posso fornire diversi altri esempi, ma fai prima a leggerti un qualunque tutorial "quick" o questa http://en.wikipedia.org/wiki/Python_syntax_and_semantics paginetta su wikipedia, e poi se ti affascina puoi approfondire meglio (visto che i tutorial e questa paginetta non trattano tutti gli elementi del linguaggio).

Ti posto pure qualcosa di più avanzato: http://c2.com/cgi/wiki?MixinsForPython per farti vedere come con poco codice è possibile implementare concetti come i "mixin", che non sono presenti nativamente nel linguaggio.
Python non avrebbe bisogno dei mixin, visto che supporta l'ereditarietà multipla "modello C++", ma i mixin presentano delle interessanti proprietà che eliminano alcuni dei problemi del precedente modello
La cosa bella nel caso dell'implementazione Python è che, tra l'altro, è possibile applicare i mixin alle singole istanze di una classe. :D
Se ti limiti al proclama di prima, ognuno rimarrà con le sue convinzioni. :D
Se vuoi "toccare con mano" non ho alcuna difficoltà a tirar fuori materiale sull'argomento. Vedi sopra. ;)
Prendi 10 aziende a caso in Italia, e domanda quanti usano Python come tool di sviluppo... :p
Alla fine, bisogna anche essere pratici.
Indubbiamente non è diffuso come altri linguaggi, ma sta acquistando fama e notorietà, e ci sono aziende che lo usano (i server che implementano la gestione e la business logic di questo http://448.virgilio.it/ sono scritti tutti in Python, come pure diverse applicazioni "di supporto" :fiufiu:) :)
Se poi tu hai un'azienda tutta tua o sei un libero professionista, allora ovviamente puoi usare il linguaggio che ti pare. :)
Non ho un'azienda mia, non sono un libero professionista ma... uso il linguaggio che mi pare. :D
Anzi, quando sono arrivato in quest'azienda mi è stato chiesto esplicitamente di cercare un altro linguaggio (diverso da quelli che venivano già usati qui) con cui realizzare un'applicazione (che sarebbe dovuta essere pronta in 20 giorni) per aumentare il numero di strumenti a disposizione per la nostra piattaforma.

Fortunatamente ho a che fare con responsabili e colleghi dotati di una certa apertura mentale. ;)

[cdimauro]

non sai che fa CTRL + 1? :D
TUTTO! :D
è un content assist contestualizzato in base a quello che stai facendo...
qualche esempio...
scrivo:
socket.getInputStream();
e spingo CTRL + 1 e faccio INVIO.
Mi crea automaticamente una variabile del tipo corretto e che ha un nome che mi fa scegliere tra inputStream, iStream, is.
Altro esempio...
voglio rinominare una variabile o un metodo....
CTRL + 1 sulla variabile e scelgo rename (in caso non ricordassi la notissima shortcut ALT+SHIFT+R :asd: )
vuoi convertire la variabile locale su cui sei col cursore in quel momento in un field?
..niente di + semplice....
CTRL + 1, scegli l'opzione giusta (dovrebbe essere una volta verso l'altro se non erro :asd: ) e via.. fa tutto lui :D
e cmq ci sono molte altre cose che puoi fare con CTRL+1 e che ora non mi vengono in mente.
Queta è senza dubbio la feature di Eclipse di cui sento maggiormente la mancanza utilizzando altri editor :cry:
niente
Mumble. Purtroppo per la sua natura "dinamica" mi pare difficile che si possa realizzare qualcosa del genere in Python (o in altri linguaggi di scripting dinamicamente tipati).

Con Python 3.0 si potrà fare, per le funzioni e i metodi che useranno le annotazioni nella definizione della lista degli argomenti.

[banryu79]

non sai che fa CTRL + 1?
TUTTO!
è un content assist contestualizzato in base a quello che stai facendo...


Fico, avevo scaricato Eclipse il mese scorso e dopo aver scritto qualche classe e averci dato un occhiata veloce l'ho abbandonato in preda alla frustrazione perchè non ero riuscito a trovare la funzionalità equivalente a "Refactor..." di NetBeans :stordita:

Mo spe' che torno a smanettarci sopra, mi sa che l'ho lasciato troppo in fretta :asd:

[fek]

Fico, avevo scaricato Eclipse il mese scorso e dopo aver scritto qualche classe e averci dato un occhiata veloce l'ho abbandonato in preda alla frustrazione perchè non ero riuscito a trovare la funzionalità equivalente a "Refactor..." di NetBeans :stordita:

Mo spe' che torno a smanettarci sopra, mi sa che l'ho lasciato troppo in fretta :asd:

Ma quale miglior modo di giocare con Eclipse (e imparare un po' di agile) se non un paio di task di Diamonds? ;)

[^TiGeRShArK^]

Fico, avevo scaricato Eclipse il mese scorso e dopo aver scritto qualche classe e averci dato un occhiata veloce l'ho abbandonato in preda alla frustrazione perchè non ero riuscito a trovare la funzionalità equivalente a "Refactor..." di NetBeans :stordita:

Mo spe' che torno a smanettarci sopra, mi sa che l'ho lasciato troppo in fretta :asd:

:eek:
eclipse ha più funzionalità di refactor rispetto a netbeans :O
Per scrivere codice assolutamente non c'è paragone tra i due riguardo a produttività.....
anche l'intuitività di usare ALT + freccia su o giù per spostare una riga o un intera selezione in giro per il codice è spettacolare..
in netbeans c'è pure ma devi spingere CTRL + ALT se non erro...
ah..
e cmq se spingi ALT + SHIFT + S in eclipse vedi un bell'elenco di funzioni utili...
quella che uso molto spesso è ALT + SHIFT + S + R per generare i getters e i setters.
E per finire c'è il mitico CTRL + SHIFT + L che ti visualizza un elenco di quasi tutte le shortcut di eclipse :D
ah...
se vuoi vedere tutte le funzioni di refactor di eclipse basta che apri il menu refactor.... e ti esce l'impossibile :asd:

..confesso che vorrei avere i tentacoli a volte per poter programmare meglio spingendo tutte queste combinazioni di tasti.. :stordita:

:asd:

[^TiGeRShArK^]

Ma quale miglior modo di giocare con Eclipse (e imparare un po' di agile) se non un paio di task di Diamonds? ;)

:cry:
e io sono anche in ritardo col secondo lavoro... :muro:
non mi ricordare ogni secondo che per ora sono out.. :sob:

..cmq visto che ci siamo leggendo ieri sera avevo intravisto non mi ricordo dove che volevate introdurre un Iterator per i droppables in Grid..
bhè.. NON lo fate assolutamente altrimenti vi beccate una ConcurrentModification ogni volta che andate a rimuovere una droppable dalla griglia.
Molto meglio avere esposta la lista così si può iterare col foreach quando non si devono rimuovere elementi, e, quando necessario, si possono eliminare le droppables utilizzando il normale ciclo for.

[darkmax]

Io uso DevC++ per imparare a programmare in C.. quando compilo e dopo eseguo non mi visualizza(o meglio è troppo veloce) la finestra con il mio risultato. Come devo fare per farla vedere?

[VICIUS]

Io uso DevC++ per imparare a programmare in C.. quando compilo e dopo eseguo non mi visualizza(o meglio è troppo veloce) la finestra con il mio risultato. Come devo fare per farla vedere?
Qui stanno parlando di tutt'altra cosa. Ti conviene aprire una discussione tutta tua in cui chiedere aiuto per il tuo problema. :)

[Dott.Wisem]

Pascal ha una sintassi decisamente più leggibile. ;)Non per me... De gustibus... :p
[...]Spiegami che c'entra la conoscenza di "certe cose" (si parlava di dettagli di più basso livello, e io qui non ne vedo proprio) coi due pezzi di codice che hai riportato. :mbe:Beh, sapere che una chiamata ad una funzione ha un "costo" certamente superiore all'utilizzo di una variabile, non è una cosa così naturale per chi non ha appreso certi concetti di base... Anche questo è un dettaglio di basso livello.

Per il resto quoto Fran e Danilo e rilancio:
for Element in Array:
Do.WhatEver.You.Want.With(Element)
:DChe, tranne che per l'uso delle parentesi graffe, è praticamente identico a quello che faccio io in un altro linguaggio:
for component in array
{
MazingaZ.LanciatemiQueiDannati(component)
MazingaZ.LanciaUnInsultoCasuale()
}
:D

[...]
Python non avrebbe bisogno dei mixin, visto che supporta l'ereditarietà multipla "modello C++", ma i mixin presentano delle interessanti proprietà che eliminano alcuni dei problemi del precedente modello
La cosa bella nel caso dell'implementazione Python è che, tra l'altro, è possibile applicare i mixin alle singole istanze di una classe. :D Anche nel linguaggio che piace a me, tempo fa implementai i Mixin senza troppe difficoltà. L'ereditarietà multipla credo sia un grande flop, in quanto i problemi che introduce sono molti di più di quelli che andrebbe a risolvere... Ecco perché in molti linguaggi OO è prevista solo ereditarietà singola ed è nato il concetto di Mixin, ovvero, delle classi di supporto che non possono essere istanziate singolarmente, ma che possono essere usate a mò di ereditarietà multipla da altre classi (ovviamente con diversi limiti che, nella maggior parte dei casi, sono accettabili).

Se vuoi "toccare con mano" non ho alcuna difficoltà a tirar fuori materiale sull'argomento. Vedi sopra. ;)

Indubbiamente non è diffuso come altri linguaggi, ma sta acquistando fama e notorietà, e ci sono aziende che lo usano (i server che implementano la gestione e la business logic di questo http://448.virgilio.it/ sono scritti tutti in Python, come pure diverse applicazioni "di supporto" :fiufiu:) :)

Non ho un'azienda mia, non sono un libero professionista ma... uso il linguaggio che mi pare. :D
Anzi, quando sono arrivato in quest'azienda mi è stato chiesto esplicitamente di cercare un altro linguaggio (diverso da quelli che venivano già usati qui) con cui realizzare un'applicazione (che sarebbe dovuta essere pronta in 20 giorni) per aumentare il numero di strumenti a disposizione per la nostra piattaforma.

Fortunatamente ho a che fare con responsabili e colleghi dotati di una certa apertura mentale. ;)Beh, sei decisamente fortunato sotto questo aspetto. Solitamente il linguaggio e l'ambiente di sviluppo da usare ti viene imposto, a meno che non sia tu il Team Leader di un progetto (e che non ti siano state date restrizioni di nessun tipo).

[banryu79]

Ma quale miglior modo di giocare con Eclipse (e imparare un po' di agile) se non un paio di task di Diamonds? ;)

Molto volentieri, mi ero anche fatto vivo tempo fa sul sito (e tra l'altro, è stato dopo aver letto il Progetto Diamonds che mi sono creato un account sul forum, in cui ero capitato per puro caso).
Ancora non mi sono fatto avanti perchè devo trovare lo spazio e gli strumenti per farlo [spazi = periodo un po' full, tra lavoro e arredo del mini che mi sono comprato in vista del trasferimento sono un tantinello preso :D strumenti = pc con meno di 6 anni di vita e più di 256MB di ram... hai voglia a far girare in maniera pulita Eclipse... al lavoro ho il portatile dell'azienda che è una bomba ma a casina no)]
Quando sarà il momento mi farò avanti, cmq vi seguo con interesse, specie ora che state fattorizzando a manetta.


@fek: A proposito, sarebbero interessantissimi (almeno per me) dei thread strutturati che mostrano spezzoni di codice da fattorizzare, e poi la soluzione adottata per quel caso per arrivare a del "codice che respira", un po' come hai fatto in questa discussione con lo spezzone di codice postato da TigerShar :)

[banryu79]

:eek:
eclipse ha più funzionalità di refactor rispetto a netbeans :O

Spettacolare, grazie delle info! :D

[Dott.Wisem]

Comunque state facendo venirmi voglia di provare l'IDE Eclipse, che purtroppo non ho ancora avuto modo di saggiare. Ne sento parlare molto bene. Al momento sono abituato col pachiderma Visual Studio che, sebbene sia un mattone, è davvero comodissimo (autocompletamento delle keyword, autorilevamento dei namespace mancanti, ecc.).

Visto che mi trovo, nello sviluppo di un applicativo con GUI da collegare a dati provenienti da un DBMS locale o remoto, che linguaggio/ambiente di sviluppo reputate più idoneo? Quello che vi consente di sviluppare interfaccia, connessione al db e reportistica in maniera più comoda e veloce, insomma. Eclipse è buono anche per sviluppare GUI e report (magari tramite plugin)?

[^TiGeRShArK^]

Comunque state facendo venirmi voglia di provare l'IDE Eclipse, che purtroppo non ho ancora avuto modo di saggiare. Ne sento parlare molto bene. Al momento sono abituato col pachiderma Visual Studio che, sebbene sia un mattone, è davvero comodissimo (autocompletamento delle keyword, autorilevamento dei namespace mancanti, ecc.).

Visto che mi trovo, nello sviluppo di un applicativo con GUI da collegare a dati provenienti da un DBMS locale o remoto, che linguaggio/ambiente di sviluppo reputate più idoneo? Quello che vi consente di sviluppare interfaccia, connessione al db e reportistica in maniera più comoda e veloce, insomma. Eclipse è buono anche per sviluppare GUI e report (magari tramite plugin)?
Visual Studio 2008 lo sto usando proprio in questo momento e devo dire che fa pena rispetto ad eclipse per la scrittura di codice puro..
Hai minori strumenti di refactoring e l'accesso alle (limitate) shortcut da tastiera è molto + complesso con l'utilizzo di combinazioni multiple che mi stanno davvero sulle balle.
Per quanto riguarda al creazione di GUI però eclipse è molti indietro.
Per quello sono molto meglio l'editot grafico del Visual Studio o quello di Netbeans.
Infatti io solitamente quando programmo in java implemento tutta la logica e il codice "puro" con eclipse e poi creo l'interfaccia grafica con Netbeans.
Matisse, l'editor di GUI di Netbeans, è anni luce avanti al Visual Editor di Eclipse.
Per quanto riguarda i report invece non ti so essere d'aiuto dato che non mi è ancora capitato di scriverne... :boh:

[^TiGeRShArK^]

dimenticavo :O

1000.times {puts 'Eclipse RULEZ!!!'}

da provare rigorosamente qui:
http://tryruby.hobix.com/

(mi piace troppo 'sto sito :D)

[Dott.Wisem]

Visual Studio 2008 lo sto usando proprio in questo momento e devo dire che fa pena rispetto ad eclipse per la scrittura di codice puro..
Hai minori strumenti di refactoring e l'accesso alle (limitate) shortcut da tastiera è molto + complesso con l'utilizzo di combinazioni multiple che mi stanno davvero sulle balle.
Per quanto riguarda al creazione di GUI però eclipse è molti indietro.
Per quello sono molto meglio l'editot grafico del Visual Studio o quello di Netbeans.
Infatti io solitamente quando programmo in java implemento tutta la logica e il codice "puro" con eclipse e poi creo l'interfaccia grafica con Netbeans.
Matisse, l'editor di GUI di Netbeans, è anni luce avanti al Visual Editor di Eclipse.
Per quanto riguarda i report invece non ti so essere d'aiuto dato che non mi è ancora capitato di scriverne... :boh:
Nooo.... Usare due IDE per la stessa applicazione: nooooooo! :D
Meglio usarne uno e convivere con i suoi difettucci...
Grazie della risposta, comunque. :)

[fek]

Comunque state facendo venirmi voglia di provare l'IDE Eclipse, che purtroppo non ho ancora avuto modo di saggiare. Ne sento parlare molto bene. Al momento sono abituato col pachiderma Visual Studio che, sebbene sia un mattone, è davvero comodissimo (autocompletamento delle keyword, autorilevamento dei namespace mancanti, ecc.).

Eclipse e' meraviglioso. E quale miglior modo di impararlo se non farsi qualche task di Diamonds? ;)

[banryu79]

Per quanto riguarda i report invece non ti so essere d'aiuto dato che non mi è ancora capitato di scriverne... :boh:

Beh, se parliamo di Eclipse e NetBeans stimao parlando di Java come linguaggio principale di riferimento.

In questo caso quoto TigerShark, l'editor per GUI Matisse di NetBeans è eccezionale (se sei disposto a lasciargli fare il suo lavoro, dato che crea nelle classi dei blocchi di codice "marcati" e non modificabili).

Per quanto riguarda la connessione al db mi pare che l'ultimo NetBeans (ver 6.x) accoppiato a Java 1.6 ha un binding diretto con un database nativo (Derby mi pare, è giusto?).

Per la reportistica sotto Java, io ti consiglierei l'utilizzo della libreria OpenSource JasperReports :)

[^TiGeRShArK^]

Nooo.... Usare due IDE per la stessa applicazione: nooooooo! :D
Meglio usarne uno e convivere con i suoi difettucci...
Grazie della risposta, comunque. :)

perchè che ci vuole? :D
una volta scritta la business logic la importi sotto netbeans e continui da lì :p

una volta ho dovuto anche successivamente RE-importarla in eclipse perchè da netbeans non riuscivo in nessun modo a rendere il codice della GUI compatibile con java 1.4.2.. in eclipse invece un paio di shortcut da tastiera, un cambio di settaggi e via.. tutto perfetto :D

[Dott.Wisem]

Eclipse e' meraviglioso. E quale miglior modo di impararlo se non farsi qualche task di Diamonds? ;)Ecco, lo sapevo dove volevi andare a parare... :D
Comunque, per delle operazioni di editing veloci di un codice, io uso spesso Notepad++, che è davvero favoloso nella sua semplicità e leggerezza (supporta l'evidenziazione della sintassi in una quantità mostruosa di linguaggi).

[fek]

Ecco, lo sapevo dove volevi andare a parare... :D

Ho creato dei mostri, tu puoi essere il prossimo :D

[cdimauro]

Non per me... De gustibus... :p
Sui gusti non si discute, ma sulla leggibilità di Pascal vs C c'è molto da dire: http://en.wikipedia.org/wiki/Comparison_of_Pascal_and_C e comunque: http://en.wikipedia.org/wiki/Obfuscated_code

Obfuscated code is source code that is (usually intentionally) very hard or ambiguous to read and understand with extraneous information. Some languages are more prone to obfuscation than others. C, C++ and Perl are most often cited as easily obfuscatable languages.

;)
Beh, sapere che una chiamata ad una funzione ha un "costo" certamente superiore all'utilizzo di una variabile, non è una cosa così naturale per chi non ha appreso certi concetti di base... Anche questo è un dettaglio di basso livello.
E' un dettaglio che riguarda anche linguaggi di alto livello come Python, ma qui non stiamo parlando di modello di memoria, dimensione (ed endianess) dei dati, ecc.
Che, tranne che per l'uso delle parentesi graffe, è praticamente identico a quello che faccio io in un altro linguaggio:
for component in array
{
MazingaZ.LanciatemiQueiDannati(component)
MazingaZ.LanciaUnInsultoCasuale()
}
:DAnche nel linguaggio che piace a me, tempo fa implementai i Mixin senza troppe difficoltà.
Quale sarebbe questo linguaggio?
L'ereditarietà multipla credo sia un grande flop, in quanto i problemi che introduce sono molti di più di quelli che andrebbe a risolvere...
Dipende sempre da come la si usa e dal problema che si deve modellare.
Ecco perché in molti linguaggi OO è prevista solo ereditarietà singola ed è nato il concetto di Mixin, ovvero, delle classi di supporto che non possono essere istanziate singolarmente, ma che possono essere usate a mò di ereditarietà multipla da altre classi (ovviamente con diversi limiti che, nella maggior parte dei casi, sono accettabili).
Ma anche qui, come vedi, ci sono problemi.

Ogni modello di "ereditarietà" si porta i suoi bei pro e contro (anche quello a interfacce multiple di Java, e ne parlammo anche tempo fa con PGI-Bis e qualcun altro).
Beh, sei decisamente fortunato sotto questo aspetto. Solitamente il linguaggio e l'ambiente di sviluppo da usare ti viene imposto, a meno che non sia tu il Team Leader di un progetto (e che non ti siano state date restrizioni di nessun tipo).
Guarda, ero appena arrivato da una settimana (quindi l'ultima ruota del carro come si suol dire :D) e mi hanno detto di scegliermi il linguaggio che preferivo (possibilmente nuovo) per scrivere quell'applicazione. :p
Visto che mi trovo, nello sviluppo di un applicativo con GUI da collegare a dati provenienti da un DBMS locale o remoto, che linguaggio/ambiente di sviluppo reputate più idoneo? Quello che vi consente di sviluppare interfaccia, connessione al db e reportistica in maniera più comoda e veloce, insomma. Eclipse è buono anche per sviluppare GUI e report (magari tramite plugin)?
Delphi è LA soluzione a tutti i tuoi problemi. ;)

[cdimauro]

Comunque, per delle operazioni di editing veloci di un codice, io uso spesso Notepad++, che è davvero favoloso nella sua semplicità e leggerezza (supporta l'evidenziazione della sintassi in una quantità mostruosa di linguaggi).
Puoi provare anche PSPad Pro: http://www.pspad.com/ che tra l'altro è Vista-compliant (funziona benissimo anche con gli account limitati, e per me è fondamentale :D ). ;)

[Dott.Wisem]

[...]Quale sarebbe questo linguaggio?L'avevo linkato diversi post fa, ma nessuno l'ha preso in considerazione... Si chama Suneido (www.suneido.com). E' un ambiente di programmazione opensource che comprende un linguaggio object oriented interpretato davvero molto semplice e comodo, un IDE (molto rudimentale, ma perfettamente funzionale), un DBMS e dei meccanismi per creare facilmente interfacce grafiche e report. Praticamente, tutto l'ambiente di sviluppo è costruito mediante Suneido stesso, esattamente come avviene per SmallTalk. E' un progetto giovane, ma per me ha del notevole potenziale.
Delphi è LA soluzione a tutti i tuoi problemi. ;)Peccato che quando vedo un codice Pascal-like mi spuntino bollicine su tutto il corpo (quasi come quando vedo un codice scritto in Cobol, o peggio, in Lisp)... :D

[cdimauro]

OK, grazie per le informazioni. Beh, per me Suneido è... troppo C-like. :D

[Dott.Wisem]

OK, grazie per le informazioni. Beh, per me Suneido è... troppo C-like. :DLa sintassi, di base, sembra C-like, ma in realtà è molto diverso.

Ad esempio:

mia_funzione = function(oggetto) {
for elemento in oggetto
Print( Display(elemento) )
return "-- FINE ELENCO --"
}

oggetto = Object(1, 2, 3, campo1: 'ciao', campo2: "mondo")

Scrivendo 'mia_funzione(oggetto)' otterrei:
1
2
3
"mondo"
"ciao"
"-- FINE ELENCO --"

Avrei anche potuto scrivere la funzione di sopra in questo modo:
mia_funzione = funzione(oggetto) {
dim = oggetto.Size();
for (i = 0; i < dim; i++)
Print( Display(oggetto) );
return "-- FINE ELENCO --";
}
che è molto più C-like, ma la scelta sta al programmatore. ;) Posso decidere di terminare ogni riga con un ';' oppure posso anche fregarmente ed andare semplicemente a capo. Il codice continuerà a funzionare. :)

Ogni elemento in Suneido, ad esclusione delle keyword, è un oggetto di qualche classe. Ad esempio, in Suneido è perfettamente lecito scrivere:

64.Sqrt()

che ovviamente restituirebbe 8. In questo caso, Sqrt() è un metodo incorporato nella classe Numbers, della quale fanno parte tutti i numeri in Suneido. Analogamente, potrei creare un mio metodo della classe Numbers che mi consentirebbe di scrivere una cosa del tipo:

123.InLettere()

ottenendo:

"centoventitre"

Forte, no? :) Questa, praticamente, è la caratteristica dei linguaggi object-oriented puri, dove tutto è un oggetto. SmallTalk, ad esempio, è fatto in questo modo e se non sbaglio anche Ruby permette delle cose simili.

C'è anche il supporto per i blocchi:

mioBlocco = { |x, y| x * y }

mioBlocco(3, 2)
=> 6

Le funzioni ed i blocchi si definiscono e si assegnano alle variabili, senza nessuna predichiarazione. Magia della tipizzazione dinamica.

Potrei continuare per ore sulla sua sintassi, ma la cosa più bella di Suneido è che con un unico ambiente puoi creare la logica di un DBMS, un'interfaccia grafica e dei report, tutto in maniera estremamente integrata e semplificata. In realtà questo è anche il suo punto debole, in quanto al momento non prevede meccanismi di collegamento a DBMS esterni (sebbene nessuno vieti di implementarli usando lo stesso linguaggio Suneido), quindi se avete DB già fatti in MySQL, MS SQL, ecc., non potrete sfruttare Suneido per collegarvi ad essi.

[cdimauro]

La sintassi richiama un po' quella di JavaScript e un po' Ruby.

E' un vero peccato che non supporti altri DB, ma in questo assomiglia ad Access.

Comunque anche Python è un linguaggio OO "puro": qualunque cosa è un oggetto, perfino il tipo di un oggetto. :p

[fek]

Peccato che quando vedo un codice Pascal-like mi spuntino bollicine su tutto il corpo (quasi come quando vedo un codice scritto in Cobol, o peggio, in Lisp)... :D

Curioso, e' la stessa reazione che ho io quando vedo un codice scritto in Python o leggo una perla di Torvalds.

[cdimauro]

Però tu in Turbo Pascal c'hai lavorato "in gioventù", se non sbaglio... :fiufiu: :p

[fek]

Però tu in Turbo Pascal c'hai lavorato "in gioventù", se non sbaglio... :fiufiu: :p

Si' e aveva i delimitatori! :D
Adoravo il Pascal. Oddio, quello che scrivevo io non era proprio Pascal, ma una cosa tipo:


Procedure Blit(..)
asm
... put 2000 lines of kick ass asm386 here


Poi ho dimenticato quasi totalmente l'asm386.

[cdimauro]

Ricordavo bene allora. :D

Per me era più o meno lo stesso: c'era parecchio codice 80x86 fra inline, asm, ed external object (per il codice 386+: più comodo che far ricorso all'inline o all'asm coi prefissi 66h e/o 67h), ma la maggior parte era Pascal (che, fra i linguaggi "tradizionali", continuo ad adorare).

Comunque se è solo per i delimitatori, presenteremo una mozione a Guido per averne una qualche forma (no bracket :D), ma la vedo dura... :stordita:

[Dott.Wisem]

Curioso, e' la stessa reazione che ho io quando vedo un codice scritto in Python o leggo una perla di Torvalds.:D

[Dott.Wisem]

Comunque se è solo per i delimitatori, presenteremo una mozione a Guido per averne una qualche forma (no bracket :D), ma la vedo dura... :stordita:Perché, no bracket? Sono leggibilissimi e la vista può concentrarsi sul resto del codice (invece di disperdersi su potenziali 'begin' e 'end' che possono far confondere).

[cdimauro]

Perché, no bracket? Sono leggibilissimi e la vista può concentrarsi sul resto del codice (invece di disperdersi su potenziali 'begin' e 'end' che possono far confondere).
Il perché l'avevo scritto:
>>> from __future__ import braces
File "<stdin>", line 1
SyntaxError: not a chance
:D

Comunque io trovo molto più facile seguire i begin/end piuttosto che {}.
Diciamo che ho una particolare avversione per le accozzaglie di simboli (che mi fanno confondere), e preferisco di gran lunga leggere parole (in inglese).

[Dott.Wisem]

Il perché l'avevo scritto:
>>> from __future__ import braces
File "<stdin>", line 1
SyntaxError: not a chance
:D

Comunque io trovo molto più facile seguire i begin/end piuttosto che {}.
Diciamo che ho una particolare avversione per le accozzaglie di simboli (che mi fanno confondere), e preferisco di gran lunga leggere parole (in inglese).Mah, secondo me nella definizione sintattica di un linguaggio ideale, la delimitazione dei blocchi (che, semanticamente parlando, fa parte della punteggiatura di un codice), deve essere indicata da simboli, non da parole. E' come se io, per indicare un fine istruzione, scrivessi una parola, invece di un ';' o similare:

pi := 3.14 END
IF pi = 3.14 THEN Print("me lo ricordo ancora") END
...

[cdimauro]

Quindi questo:
pi = 3.14
if pi == 3.14:
print "me lo ricordo ancora"
per te andrebbe bene. :)

[Dott.Wisem]

Quindi questo:
pi = 3.14
if pi == 3.14:
print "me lo ricordo ancora"
per te andrebbe bene. :)Si, anche se quel ':' alla fine dell'if mi confonde un po'.

[Dott.Wisem]

Stavo dando un'occhiata a Python e, a parte la sintassi, mi sembra un linguaggio molto simile a Suneido da un punto di vista concettuale. Esempio:

in Python:

#An example of a class
class Shape:
def __init__(self,x,y):
self.x = x
self.y = y
description = "This shape has not been described yet"
author = "Nobody has claimed to make this shape yet"
def area(self):
return self.x * self.y
def perimeter(self):
return 2 * self.x + 2 * self.y
def describe(self,text):
self.description = text
def authorName(self,text):
self.author = text
def scaleSize(self,scale):
self.x = self.x * scale
self.y = self.y * scale

In Suneido:
//An example of a class
shape = class
{
Description: "This shape has not been described yet"
Author: "Nobody has claimed to make this shape yet"
New(x,y)
{
.x = x
.y = y
}
Area()
{
return .x * .y
}
Perimeter()
{
return 2 * .x + 2 * .y
}
Describe(text)
{
.Description = text
}
AuthorName(text)
{
.Author = text
}
ScaleSize(scale)
{
.x = .x * scale
.y = .y * scale
}
}
Notare che in Suneido quando scrivo '.qualcosa', in realtà è come se scrivessi 'this.qualcosa'. Difatti Suneido consente (ma non obbliga) di omettere la keyword 'this', in modo da snellire la sintassi. Effettivamente, scrivere delle espressioni complesse riempite di this.XXX o self.XXX, alla fine risulta scomodo.

Python ha liste, tuple e dizionari. Le liste sono insiemi indicizzati di valori. Le tuple sono come le liste ma sono insiemi immutabili. Infine, i dizionari consentono di associare dei valori a delle parole. A differenza degli elementi nelle liste, gli elementi nei dizionari non vengono memorizzati nell'ordine in cui vengono aggiunti.

In Suneido, liste e dizionari sono combinati in un unico tipo di dato: il tipo Object (che è anche una classe, essendo Suneido un linguaggio OO puro). Quindi, in Suneido, io posso avere un'unica lista di valori contenente sia valori indicizzati che non indicizzati. Esempio:

myobj = Object(10, 20, 30, 40, autore: "Dott.Wisem", titolo: "Suneido è meglio di Python. Gnegnegne.")

myobj[2]
=> 30

myobj.autore
=> "Dott.Wisem"

Da quel poco che ho visto, in Python non si può fare la cosa di sopra, a meno che il programmatore non si definisca un nuovo tipo di dato che si comporti come sopra.

Così come Python ha le tuple, Suneido ha gli oggetti read-only, che si definiscono usando il cancelletto, invece del termine 'Object'. Ad esempio:

my_readonly_obj = #(1, 2, 3, 4, field1: 'hello')

[cdimauro]

Si, anche se quel ':' alla fine dell'if mi confonde un po'.
E' questione di abitudine. Vediamo se riusciamo a convincere Guido a farglielo togliere... :fagiano:
Stavo dando un'occhiata a Python e, a parte la sintassi, mi sembra un linguaggio molto simile a Suneido da un punto di vista concettuale. Esempio:

in Python:

#An example of a class
class Shape:
def __init__(self,x,y):
self.x = x
self.y = y
description = "This shape has not been described yet"
author = "Nobody has claimed to make this shape yet"
def area(self):
return self.x * self.y
def perimeter(self):
return 2 * self.x + 2 * self.y
def describe(self,text):
self.description = text
def authorName(self,text):
self.author = text
def scaleSize(self,scale):
self.x = self.x * scale
self.y = self.y * scale

In Suneido:
//An example of a class
shape = class
{
Description: "This shape has not been described yet"
Author: "Nobody has claimed to make this shape yet"
New(x,y)
{
.x = x
.y = y
}
Area()
{
return .x * .y
}
Perimeter()
{
return 2 * .x + 2 * .y
}
Describe(text)
{
.Description = text
}
AuthorName(text)
{
.Author = text
}
ScaleSize(scale)
{
.x = .x * scale
.y = .y * scale
}
}
Notare che in Suneido quando scrivo '.qualcosa', in realtà è come se scrivessi 'this.qualcosa'. Difatti Suneido consente (ma non obbliga) di omettere la keyword 'this', in modo da snellire la sintassi. Effettivamente, scrivere delle espressioni complesse riempite di this.XXX o self.XXX, alla fine risulta scomodo.
Dipende da quello che ci devi fare. In Python comunque non si può rimuovere self (che comunque puoi chiamare come vuoi: anche s può andare benissimo, ad esempio :)) perché:
- metodi e funzioni sono sostanzialmente la stessa cosa;
- in Python dev'essere esplicito ciò che stai facendo.

Da una parte hai lo svantaggio di dover scrivere di più, dall'altro quello di poter trattare i metodi esattamente come se fossero delle funzioni (che è molto comodo in tante situazioni).
Python ha liste, tuple e dizionari. Le liste sono insiemi indicizzati di valori. Le tuple sono come le liste ma sono insiemi immutabili. Infine, i dizionari consentono di associare dei valori a delle parole. A differenza degli elementi nelle liste, gli elementi nei dizionari non vengono memorizzati nell'ordine in cui vengono aggiunti.
Esatto.
In Suneido, liste e dizionari sono combinati in un unico tipo di dato: il tipo Object (che è anche una classe, essendo Suneido un linguaggio OO puro). Quindi, in Suneido, io posso avere un'unica lista di valori contenente sia valori indicizzati che non indicizzati. Esempio:

myobj = Object(10, 20, 30, 40, autore: "Dott.Wisem", titolo: "Suneido è meglio di Python. Gnegnegne.")

myobj[2]
=> 30

myobj.autore
=> "Dott.Wisem"
E' simile a PHP allora (linguaggio che notoriamente "amo" molto :p).
Da quel poco che ho visto, in Python non si può fare la cosa di sopra, a meno che il programmatore non si definisca un nuovo tipo di dato che si comporti come sopra.
No, perché liste e dizionari sono dati concettualmente diversi.
Così come Python ha le tuple, Suneido ha gli oggetti read-only, che si definiscono usando il cancelletto, invece del termine 'Object'. Ad esempio:

my_readonly_obj = #(1, 2, 3, 4, field1: 'hello')
Utili perché semplificano la scrittura di applicazioni multithread. :)