Newsgroup: it.comp.lang.c++
Titolo: Quale ambiente gratuito per C++, con GUI, il cui sviluppo non è fermo?

Su Windows XP.
Vorrei, dopo averlo studiacchiato alcuni anni fa attraverso le guide
che si trovano in rete, dopo aver programmato con PHP-GTK per la
scrittura di applicazioni di calcolo per ingegneria civile,
approfondire e questa volta per bene il C++.
Il mio obiettivo a lungo termine (da fare non da solo ma in equipe) è
la stesura di un programmone di calcolo strutturale agli Elementi
Finiti (F.E.M.), in cui sono da gestire decine di migliaia di
equazioni con il calcolo matriciale. Scrivere dei pre/processori per
l'input dei dati anche grafici (come disegno di una struttura 3D
unifilare, ed anche import di un file DXF da far riconoscere
all'ambiente grafico, per poi assegnare le sezioni geometriche,
vincoli, tabelle dei materiali da passare al processore). Scrivere dei
post/processori grafici per la visualizzazione di deformate, stati di
stress materiale con mappe a colori.
Ovviamente inizierei con cose molto semplici per familiarizzare col
linguaggio, la scrittura di GUI, prendere confidenza con la forza
bruta del calcolo numerico.
Gradirei mi consigliaste un ambiente di sviluppo gratuito stabile,
semplice da configurare, con compilatore, tool per le librerie
grafiche tipo wxwidgets o Gtk (+ o MM?) o altre consigliate. Credo
sarebbero importanti anche le OpenGL nel mio progetto.
Facendo le mie ricerche, pare che DEV-C++ sia ormai fermo nello
sviluppo dal 2005, stessa cosa dicasi per Mingw Developer Studio della
http://www.parinyasoft.com
 anc'esso dal 2005, Code::Blocks non so.
Pare che MingwDS sia già un ambiente ipercompleto, con prescatolate le
wx. Le GTK si potrebbero istallare come plug-in.
Un piccolo appunto: alcuni mi consigliano per l'ambizioso progetto di
studiare Erlang, linguaggio funzionale, sicuro, rapido da sviluppare
(codice non prolisso) e veloce nell'esecuzione. Solo che, credo, non è
abbastanza testato o non ci sono ancora a disposizione potenti
librerie per calcolo matematico come quelle richieste per un progetto
come il mio.
Forse però un ambiente che consenta di scrivere in più linguaggi e di
compilarsi, oltre che aiutare l'edit del testo, sarebbe utile, così si
evita di imparare troppi software e istallare troppe cose.
Pare che molti usino Eclipse per sviluppare in C++, Java, ed esista un
plug-in Erlang. Ma Eclipse essendo scritto in Java e per java, ha
bisogno che sia installato Java o quale applicativo? Cosa mette a
disposizione per chi è interessato al C++? Compilatore,
Debugger,Linker, e varie, compresi librerie grafiche e tool visuali
(mi vengono in mente VisualWx, Glade, wxGlade, wxDesigner).
In sostanza, quali software devo cominciare a procurarmi, in che
ordine vanno installati e come vanno configurati?
So che pongo una marea di interrogativi, ma gradirei che mi aiutaste a
chiarirmi un po' le idee così da evitare di perdere altro tempo in
ricerche che ormai si protraggono da mesi senza cominciare a fare
nulla di sensato e costruttivo.

 nulla di sensato e costruttivo.
-- 
After more than 30 years of programming we ought to know that the 
design of complex software is inherently difficult.
Niklaus Wirth

ambienti, compilatori, etc etc etc. Davvero ben fatto.
Confermo.

 VisualWx, Glade, wxGlade, wxDesigner).
Oltre ad Eclipse, anche netbeans supporta progetti in C/C++. Devo ancora
provare ad usare in maniera sistematica, ma le premesse sembrano buone. 
Eclipse sembra piu' completo ma anche un pelino piu' ostico da usare
(almeno all'inizio). Se proprio vuoi provarli, devi avere il java runtime 
env installato (sul quale la ide gira). 
Quello che mettono a disposizione sono l'ide e funzioni di editing
ricerca, sostituzione codice etc. Per compilare/linkare etc si appoggiano
a compilatori specifici (ad esempio sotto linux, 'puntano' sulla suite dei
compilatori g++), quindi devi avere anche un compilatore C/C++ gia' 
funzionante per la tua piattaforma. 
Ti hanno gia' proposto Python x le gui. Il consiglio e' ottimo. Se proprio 
vuoi esagerare, in C++ ci sarebbe anche Qt che e' portabile ma la licenza 
e' free solo per gli open source.
Facci sapere come ti orienti
- gio

 Come dico sotto, tu vuoi Code::Blocks.
Se uno sta usando DevCpp, c'è qualche motivo per cui NON dovrebbe 
passare a Code::Blocks?
E.

 e' free solo per gli open source.
Il problema in questo caso è che vorrei avere degli eseguibili e
proteggere un po' il codice. Python mi consente di farlo?
Certo, un linguaggio interpretato ha il vantaggio di vedere man mano,
riga per riga che scrivi, che guai combini, senza aspettare i tempi
del linker, compilare e chiedersi cosa non va. Con l'interprete basta
ricaricare e commentando il codice vedi tutto. parlo sempre per le mie
piccole e passate esperienze con PHP-GTK, e PHP con Apache Server su
Web per applicazioni di calcolo. Eh sì, so cosa state pensando... sono
una mosca bianca che vuole abbattere la muraglia cinese con un
coltellino svizzero.
le QT nn le prendo in considerazione. Visto il mio passato ormai
antico con PHP-GTK, il primo amore nn si scodra mai... Ma anche le Wx
andrebbero bene.

 andrebbero bene.
GTK puo' andare anche xche' si interfaccia benone con Python. Putroppo non 
ho mai programmato la GTK e quindi qui passo (anche se c'e' sempre la 
prima volta).
Cmq, a rischio di ripetermi, in questa fase devi capire/classificare cosa 
c'e' in giro con che licenze e cosa/da dove si puo' cominciare e che 
vantaggi ti darebbe. Poi x il C++ puoi sempre chiedere q.do hai dubbi
Ciao,
g
- <nome che vedi su> chiocciola 
libero.it

On 30 Mar, 00:18, "Jonas Willard (AKA \"Archeopteryx\")"
<cor.bonukFANCULOSPAM@libero_NOMAIL_.it> wrote:
Non pensavo assolutamente di trovare, alla mia prima apparizione in
it.comp.lang.c++ di trovare persone che effettivamente capiscono ciò
di cui parlo.
E sono ovviamente felicissimo di poter avere questo scambio con voi.
Anche per rispondere a GMLR (a proposito, poi tornerò in maniera
approfondita sul tuo post, ora devo scappare), so benissimo cosa
voglio fare, come deve venire, tutte le cose che il mio codice deve
fare in più rispetto al codice chiuso commerciale.
Di solito quelli chiusi sono software costosi e dedicati all'ambiente
civile-edile, per capirci cemento armato. Le esigenze mie, da civile
nel settore meccanico e progettista di strutture speciali in acciaio,
macchine di sollevamento, tipicamente Gru a torre (con l'esigenza
dunque di gestire diagrammi di portate, gruppo di rotazione,
riduttori, argani, carichi di tipo diverso da quelli contenute nelle
NT 2008 o DM96), strutture reticolari spaziali per coperture di grandi
luci, strutture tralicciate in alluminio, vanno ben oltre il semplice
calcoletto di solaio precostituito.
In sostanza ho bisogno di uno Straus7 esteso al mio settore, con tutta
una serie di procedure per automatizzare verifiche, visualizzazione
grafica della snellezza e lunghezza libera di inflessione,
classificazione delle sezioni ai fini della resistenza con Eurocodice
3 (acciaio) e 9 (alluminio), automatizzare l'immissione di carichi (ad
esempio nelle Gru tra oltre i carichi standard ho carichi viaggianti
con legge non costante, dinamicità, coppie dovute alla rotazione, per
cui, con un esempio modellato in Straus ho dovuto inserire circa 80
condizioni di carico a mano e poi combinarle).
Ma non disdegno la possibilità di semplificazioni per il calcolo di
villette o palazzi in cemento armato.
So benissimo che tutto ciò di cui ho bisogno come processore di
calcolo e motore grafico (di questi non tantissimi, ma ci sono, uno
per tutti GiD) esiste Open Source, tipo Felt, OpenSees, Tochnog,
Calculix, Code Aster, Seismosoft, tutti quelli sviluppati
dall'Università di Berkley (
http://nisee.berkeley.edu/software/
) e
tanti altri.
Riuscire a capirci qualcosa, leggendo un po' di codice, capire tra i
tanti quale farebbe al caso mio, come curare l'interfaccia grafica,
legare le parti terze e sviluppare solo l'arricchimento di procedure
di cui necessito sarebbe una gran cosa.
Poi ovvio, il sogno di ognuno di noi ingegneri appassionati di calcolo
e di codice sarebbe scrivere un motore F.E.M. o tradurre un Sap/Straus
nel linguaggio preferito, snello, produttivo e veloce, senza
complicazioni di puntatori (vedi Erlang per qualcuno).
E per questo, siccome tutto esiste in C++, DEVO imparare, con i miei
tempi, il C++, anche per indirizzare il lavoro del team di sviluppo.
Certo, non potrò essere mai un professionista sviluppatore, ma devo
sapere come trasmettere le notizie.
Ripeto, lo schema/manifesto del mio progetto esiste, ho già steso
l'iter e tutte le caratteristiche che deve avere, come il tipo di
elementi finiti da supportare (plate 3-4-6-8 nodi, Cavi/tiranti non
resistenti a compressione...), i materiali con cui avere a che fare,
le procedure interattive di verifiche ecc.
Ma credo che rispetto al Topic ed al gruppo it.comp.lang.c++ andrei
fuori tema.
Per chi come me è attratto dall'argomento, come ingegnere,
progettista, calcolatore o informatico, possiamo parlarne in altra
sede.
Ho in mente (ed in parte già fatto) di creare uno spazio apposito sul
web per il progetto.
Ciao e grazie! Siete una miniera d'oro per i vostri consigli e la
vostra competenza.



No. 
Ho usato DevCpp in passato e l'ho trovato inusabile, in contesti seri,
per i suoi problemi di integrazione con gdb. Per un po' ho anche
pensato di scaricare i sorgenti (sono in Delphi) e correggere gli
errori (in puro spirito open source :-) ma non ho mai avuto il tempo
di farlo, ahimé. Con Code::Blocks, invece, nessun problema (almeno per
ora :-)

Oltre ad Eclipse, anche netbeans supporta progetti in C/C++.
Personalmente sconsiglio di usare Eclipse (non conosco Netbeans).
Eclipse č un dinosauro succhia-risorse, č lento e pesante e non lo
vedo particolarmente adatto al C++. Lo sto usando con Java (purtroppo
per scelta del cliente abbiamo dovuto abbandonare IntelliJ). Quello
che ho notato č che tutto ciņ che si muove nell'ambito Java č
altamente inefficiente nel consumo di risorse e va bene, appunto, solo
per i javisti, che hanno in generale il campo molto limitato su come
fare le cose. Mi aggrego al consiglio su Code::Blocks. Forse valutare
l'acquisto di una versione di Visual Studio non sarebbe male.

di cui parlo.
Immagino che questo sia da prendere come un complimento :-)

 ora :-)
argh! Io al contrario sono giorni che tento ti pasare da DevC++ a 
Code::Blocks senza successo!
Questo solo perchè non riesco a risalire ad un problemuccio! In pratica sto 
sviluppando delle applicazioni che usano SDL ed ho la necessità di inserire 
nella riga di comando del linker i seguenti parametri:
-lmingw32 -lSDLmain -lSDL -lstdc++ -lgcc -lopengl32 -lglu32 -liberty -lSDL_mixer
il problema è che con DevC++, assegnando i vari percorsi per le librerie, 
fila tutto a meraviglia.
Con il CB mi da degli errori:
il linker mi dice che non trova "lSDL_mixer"
se lo elimino dalla riga di comando del linker invece mi da un altro comando 
per me incomprensibile:
undefined reference to `__alloca_probe'
Qualcuno mi saprebbe dare qualche dritta? :-)
Saluti

Questo solo perchè non riesco a risalire ad un problemuccio!
Scusami, ma non riesci a risolvere questo problema da *GIORNI*?
Perdonami ma è preccupante. Si tratta di impostare il percorso delle
librerie ed anche con Code::Blocks è fattibile.

 Immagino che questo sia da prendere come un complimento :-)
Parlo di ingegneria...
Non è un complimento, xkè sarebbe come dire mi aspettassi degli
scolaretti invece che dei professionisti dello sviluppo software.
Perchè credo tu abbia inteso parlassi di sviluppo vero?
Ehm... in verità era riferito alla questione puramente ingegneristica,
F.E.M. e calcolo matriciale, non dello sviluppo software/
programmazione C++.
Pensavo che parlare di cose tecniche ingegneristiche sarebbe stato
fuorviante e noioso, invece con mia sorpresa e soddisfazione scopro
che probabilmente ci sono alcuni che condividono le mie esperienze
professionali e la mia emozione di fronte all'idea di sviluppare
qualcosa di importante da mettere a disposizione di altri.
Jonas Willard e GMLR sembrano avere delle affinità con me, dal punto
di vista ingegneristico. In quello della programmazione ahimè sono un
pivellino... ;-)

 l'acquisto di una versione di Visual Studio non sarebbe male.
Ok, vada per Code:Blocks. Che sembra anche snello, con l'exe di solo
18 MB.
Ma dovreste aiutarmi ad installare e configurare le estensioni di cui
ho bisogno. Ed anzitutto a elencarmi ciò che devo procurarmi... ;-)
Compilatore, Debugger, Linker, OpenGL.
Per le GUI, con C++ sono meglio documentate (magari in italiano) e di
più facile uso le GTK+, GTK-, le WxWidgets, o altro?
Ho notato che nessuno si è espresso su MingwDeveloperStudio. Forse è
superato e pesante (125 MB la versione full!!!).
Per lo sviluppo di GUI in verità avevo pensato anche a C#, infatti ho
già installato il framework _NET 2.0 e sharpdevelop.
Mi interesserebbe anche un ambiente che possa identare codice Erlang,
perciò avevo parlato di Eclipse. Sono curioso di scoprire cosa e con
quale produttività posso fare con Erlang.
Ovviamente, pubblicato il manifesto del mio progetto, dovrei
costituire un team di sviluppo con una certa filosofia (una passione,
non fare competizione a colossi del settore), licenza, strumenti di
sviluppo (tal linguaggio per far tal cosa, nonchè i tools di sviluppo)
così che tutti parlino la stessa lingua.

 [...]
Manlio Perillo

 
http://www.ffconsultancy.com/products/ocaml_for_scientists/
http://www.amazon.com/F-Scientists-Jon-Harrop/dp/0470242116/ref=pd_bbs_2
?
ie=UTF8&s=books&qid=1206885638&sr=8-2
F# è l'implementazione di Ocaml della Microsoft, l'autore dei due libri è 
lo stesso, come praticamente lo stesso immagino sia il contenuto.
Nota comunque che Ocaml è un linguaggio multi paradigma, quindi dubito 
che in quel testo troverai una trattazione di algoritmi numerici 
funzionali.
Invece Haskell è un linguaggio funzionale puro.
Io personalmente il core numerico lo farei in C++ (meglio se esporti le 
funzioni secondo le convenzioni di chiamata C, perchè ti faciliti 
l'interfacciamento da parte di codice esterno), usando solo l'approccio 
procedurale e senza mettere oggetti in mezzo (ogni volta che l'ho visto 
fare, l'ho sempre visto fare nel modo sbagliato).
Nota comunque che è comunque possibile esportare funzioni in C da D, 
Ocaml e Haskell).
Manlio Perillo

 semplicissimo costruire GUI.
Non è solo la semplicità di *costruire* nel senso di 'disegnare'. Il 
punto è che il codice che rende vive le gui non ha particolari vantaggi 
ad essere scritto in C++ e IMHO giova molto scriverlo in un linguaggio 
di alto livello, specie visto che è una parte notoriamente rognosa da 
testare.


 passare a Code::Blocks?
Direi di no. Cioè, magari se uno è molto religioso e sta cercando di 
espiare qualche peccato...
-- 
I think computer viruses should count as life. I think it says 
something about human nature that the only form of life we have created 
so far is purely destructive. We've created life in our own image.
Stephen Hawking

 Web per applicazioni di calcolo. 
Python *non* è un linguaggio interpretato. Non più di quanto lo sia 
Java o C#. Ah, e comunque il concetto stesso di 'linguaggio 
interpretato' è un mezzo non-senso.
-- 
A good designer must rely on experience, on precise, logic thinking; 
and on pedantic exactness. No magic will do.
Niklaus Wirth

 librerie ed anche con Code::Blocks è fattibile.
Il problema è che mi sembra di ritrovare le stesse opzioni dappertutto, 
dalle impostazioni di compilazione del progetto a quelle geneali, percorsi, 
percorsi di ricerca sparsi ovunque! Tappo da una parte e sforo dall'altra. 
:-\

interpretato' è un mezzo non-senso.
Non capisco, sinceramente. Credo che non ci sia nulla di più
interpretabile di un linguaggio ;-)

ad essere scritto in C++ 
E io torno a ribadire che secondo me non è così, visto che esistono
strumenti come C++ Builder che facilitano di molto la costruzione, non
solo il disegno. Sono questioni slegate dal linguaggio.

già installato il framework _NET 2.0 e sharpdevelop.
Non vorrei darti una brutta notizia, ma ho il forte sospetto che lo
strumento che meglio si adatta alle tue esigenze sia Microsoft Visual
Studio. Io te lo consiglio per lo sviluppo C++ e per quello C# su
.NET.

Visual C++ Express + Platform SDK.
Gratuito, ottimo, e con licenza 'valida' anche per usi commerciali.

 dai una occhiata ad Haskell o OCaml.
E ddai Manlio! Non ti ci mettere pure tu! Sono già abbastanza
turbato!!! ;-)
Ogni giorno scopro un nuovo linguaggio e non inizio mai a lavorare sul
serio...
Cosa farebbero preferire Haskell o Ocaml ad Erlang? La mole di codice
già disponibile nel settore matematico/scentifico?
O sono anche più maturi come linguaggi?
Cmq, credo che il C++ sia obbligato se uno vuole avere padronanza,
controllo, efficienza e potenza, con soprattutto la possibilità di
riutilizzare i GB di codice già disponibile in rete per il mio
progetto. Non voglio essere una cima, ma almeno aprire il codice e
capire cosa fa!!!
Ed affiancare un linguaggio più spedito per la gestione dei segnali
via GUI, post-processione di calcolo per le rappresentazioni grafiche,
viste tabellari con evidenzazione/formattazione tipo "Excel con
formattazione condizionale" dei casi a rischio.
Potrebbero andarmi bene C#, Python, ma forse anche PHP-GTK, che
conosco meglio e che, a dire il vero, da lanciare per applicazioni
Client e fare calcoletti non mi è sembrato così lento...
Ammetto che un linguaggio funzionale mi stuzzica per la sua stessa
logica compatta. Come se scrivessi un teorema di algebra e lo
dimostrassi con la simbologia nuda, senza sovrappiù.

    che fa il controllo di autencità del tuo sw.
Non riesco a darti torto, ma certo, offuscare il codice, come dice
Andrea Laforgia <<Credo che con "proteggere il codice", l'OP
intendesse renderlo non troppo facile da scoprire e ammetterai che con
i "linguaggi interpretati" è abbastanza più semplice arrivare al
sorgente. >>
A proposito... l'OP sarei io? cosa significa??? perdonate la mia
ignoranza... ;)

 ignoranza... ;)
Slang da newsgroup... OP=original poster.
E.

 .NET.
Perchè spendere 400-500 euro per cominciare ad imparare e stendere
l'idea progettuale su carta, senza ancora sapere nello specifico di
che strumenti potrei aver bisogno (database, per esempio) quando c'è
materiale free e gratuito?
Non sono un professionista programmatore, vivo facendo l'ingegnere ed
il mio progetto sviluppo software parte come attività a tempo perso,
per poi cercare a sondare il terreno per costituire un gruppo di
appassionati che condivide la filosofia. Ed anche un manifesto
condivisibile del programma va pensato...
Poi, visto che vorrei costituire una comunità di sviluppo, sarebbe
buono che avessimo tutti gli stessi strumenti, così un problema ce lo
passiamo... e ci consigliamo. Se è tutto gratuito, stabile, potente e
senza eccessive limitazioni sarebbe meglio.

 capire cosa fa!!!
Sì, anch'io ti suggerisco di usare C++.
E.

 Perchè spendere 400-500 euro
Perché non ti scarichi la versione gratuita di Visual Studio invece?
Se fa al caso tuo ti compri la versione minimale.
-- 
Articolo 33 della Costituzione italiana: L'arte e la scienza sono 
libere e libero ne è l'insegnamento

 materiale free e gratuito?
Perché potrebbe valerne la pena. Non tutto ciò che è free e gratuito è
competitivo con quanto esiste a livello commerciale. Se vuoi vederlo
come un avvilimento filosofico, fallo pure, ma io bado alla
concretezza dei fatti.
Nel caso di Visual Studio, questo strumento è di gran lunga il più
potente e completo per lo sviluppo con .NET e C#.
Da sempre, poi, Visual C++ è lo standard de facto di chi programma in C
++ su piattaforma Microsoft.
La cifra che citi non mi sembra un granché, neanche per chi voglia
appena iniziare, se ci crede sul serio.
Insomma, non so quanto abbia senso sforzarsi di programmare con tool
free e gratuiti, se poi per tutto il tempo bisogna rimpiangere quelli
commerciali :-)

 [...]
Manlio Perillo

 ancora benissimo, ma è questione di esigenze personali).
Beh, parecchi dubbi me li sono toli.
Poi quando comincerò ad andare sul pratico sempre voi mi dovete
sopportare... ;-)
Ho appena installato Code::Blocks, appena ho tempo ci smanetto.

 concretezza dei fatti.
Io però penso che la differenza la vedi soprattutto nella parte GUI del 
codice. Se la sua idea è quella di separare la parte computazionale da 
quella di interfaccia, non credo Visual C++ ti dia molto vantaggio 
rispetto ai prodotti open.
Se poi vuoi creare una grossa squadra di sviluppatori (magari studenti 
universitari, se capisco bene), potrebbe diventare molto costoso fornire 
ad ognuno il compilatore commerciale.
E.

 percorsi di ricerca sparsi ovunque! Tappo da una parte e sforo dall'altra.
Perchè ci sono le opzioni 'generali' e poi quelle per il singolo
progetto.
-- 
cc = callcc {|cc| cc.call cc}; cc.call cc

 E.

 rispetto ai prodotti open.
Se pensi di riuscire a scrivere facilmente una GUI usando prodotti
open, auguri. E comunque con Visual Studio è possibilissimo creare GUI
anche in modo RAD, ormai. Io non credo che ci siano particolari
vantaggi, oltre al prezzo, nell'usare prodotti gratuiti e open
rispetto a VS. Se si affronta uno sviluppo "serio" su piattaforma
Windows, credo che prima o poi l'uso di Visual Studio sia obbligato.
Ognuno è libero di fare come gli pare, in ogni caso; io mi limito a
consigliare quello che secondo me è il meglio.

 interpretabile di un linguaggio ;-)
LOL :)
Scherzi a parte, un linguaggio è sostanzialmente un concetto astratto,
mentre essere interpretato o compilato è una prerogativa di
un'implementazione. Un linguaggio può essere tipicamente sia
interpretato che compilato. Non sono pochi i linguaggi che forniscono
*sia* un compilatore che un interprete.


 ignoranza... ;)
'Original Poster'. Ovvero chi ha iniziato il thread (o più in generale
quello che ha per primo postato).


un'implementazione.
Concordiamo. Vedi sopra ;-)

 passare a Code::Blocks?
Ok, l'ho installato. Sembra molto carino! Una domanda: c'è un sistema 
automatico per installare le librerie (sto usando GCC come compilatore) 
oppure devo copiare i files a mano?
E.

 Concordiamo. Vedi sopra ;-)
Probabilmente l'equivoco nasce dal fatto che si distinguono abbastanza
chiaramente due famiglie di linguaggi le cui caratteristiche
principali derivano dal fatto che i capostipiti erano interpretati
piuttosto che compilati.
L'elemento determinante e' il fatto di avere o meno a disposizione, al
momento dell'avvio del programma, tutti i meccanismi che ne consentono
la manipolazione e che sono disponibili quando lo si scrive. Si puo'
parlare di linguaggi dinamici e linguaggi statici, anche se di solito
con questa distinzione ci si riferisce al type system. E' altrettanto
vero che soprattutto nei linguaggi dinamici il codice e' comunque
rappresentato all'interno del type system stesso.
Ciao,
Nicola


 > [...]
Molto imho, oggi ci sono due fagmiglie di linguaggi e il concetto chiave 
che fa da "discrimine" è la "biunivocità" tra il sorgente e la roba che 
viene mandata in esecuzione. Provo a spiegarmi:
il codice macchina generato da un compilatore (es. C o C++) NON è 
assolutamente biunivoco con il sorgente, tant'è vero che è praticamente 
impossibile "decompilare".
viceversa i linguaggi moderni (quelli che passano da bytecode, pcode, 
macchine virtuali, "linguaggi intermedi"  e tutte le altre varianti), 
hanno più o meno tutti la caratteristica che a partire dal "compilato" è 
possibile risalire al sorgente.
Ecco, secondo me quella che una volta era la differenza tra compilati e 
interpretati, oggi è da leggere in questo modo.
GM


Non sono d'accordo. Il vero discriminante e' la possibilita' di
modificare il programma quando e' in esecuzione. Lisp e Python stanno
da una parte, mentre Java, C# e C++ stanno dall'altra.
Ciao,
Nicola

 
Ok, invece nella mia testa C++ sta da una parte (la prima metà),
Java e C# dall'altra (la seconda metà),
e ... Lisp e Python dall'altra ancora (oops, la terza metà :) )
In effetti fare solo DUE categorie non è poi così facile...

 da una parte, mentre Java, C# e C++ stanno dall'altra.
Niente vieta di modificare il codice di un compilato C++. Se lo fa il 
programma stesso si può parlare di codice automodificante, altrimenti 
di debugger con questa possibilità (cosa che dovrebbe fare l'IDE MS 
anche se non ho mai usato questa feature).
Magari in python è più facile che in C++, questo sì.


 Magari in python è più facile che in C++, questo sì.
Certo. La differenza pero' sta nel fatto che nel caso di linguaggi
come Lisp e Python gli strumenti per farlo te li fornisce il
linguaggio stesso.
Ciao,
Nicola

 
non è poi neanche così facile:
calcola che il loader dovrebbe mettere il codice in un segmento 
accessibile in sola lettura... anche perchè credo che normalmente mappi 
in memoria direttamente il file (parlo per win)
E poi ultimamente stanno uscendo features di sicurezzqa degli SO e delle 
CPU che impediscano di mandare in esecuzione aree dati...
Per non parlare degli antivirus/firewall che si accorgono quando cambia 
qualcosa
Insomma, per gli smanettoni la vita è sempre più difficile

 linguaggio stesso.
Anche il C# se è per questo. Poi in C/C++ penso sia qualcosa di 
relativamente cretino compilare del codice al volo in un shared object 
o una dll, caricarla al volo, eseguire il codice, scaricare l'oggetto. 
Sotto un'installazione Linux un compilatore lo trovi di solito. Sotto 
windows lo potresti addirittura mettere nel file delle risorse.
Sotto windows io sono solito mettere file eseguibili nelle risorse, e 
lanciarli se mi servono. Sia in C# che in C++.
La distinzioni tra un linguaggio e l'altro possono essere sottili a ben 
guardare.


 in sola lettura...
Ipotesi 1:
Allochi una nuova pagina di memoria, chiedi al S.O. che abbia diritti 
di esecuzione, ci metti il codice compilato, fai un jump lì.
Ipotesi 2:
Banale, si aggira il problema. Crei un nuovo processo/dll/shared object 
al volo, lo carichi e lo esegui.
Esperienza personale:
Per risolvere un problema su un processo di terze parti mi è capitato 
di metterci una pezza iniettandoci del codice "dentro" ed eseguendolo. 
Visto che il processo usava tecniche anti debug, ne ho usate altre. Il 
mio oggetto era, anzi è, scritto in C++. Funziona da almeno un paio di 
anni. Per esperienza personale quindi direi che si può modificare del 
codice in esecuzione, a prescindere dal linguaggio usato per generare 
il codice. Mai avuto problemi con l'antivirus in quell'applicazione 
particolare. Certo, non sono tecniche banalissime.


 commerciali :-)
Veramente i tool commerciali li rimpiange chi li ha usati, se 
effettivamente hanno qualche caratteristica indispensabile in +.
Sinceramente del VisualC6 (che ho usato per anni) non rimpiango NULLA, 
ho un editor migliore (gvim), un debugger piu` flessibile che mi 
permette di far tutto con la tastiera (gdb), un sistema di make a ME 
piu` congeniale e su cui ho un miglior controllo (in certi casi il 
calcolo delle dipendenze puo` non essere banale, in particolare quando 
ci sono preprocessori di mezzo).
Forse c'e' qualche caratteristica che potrei rimpiangere su VS2005/2008? 
Come faccio a rimpiangere qualcosa che non ho mai usato?
E' possibile creare applicazioni commerciali (anzi diciamo di qualita`, 
commerciale spesso significa il contrario di recente....) con i tool 
citati in questo thread, non vedo perche` in questa fase sia necessario 
consigliare visual studio.
Se l'OP avesse scritto:
- Non mi trovo con il debugger di Code::Blocks, cosa posso fare?
- L'editor di DevC++ non mi piace, c'e' di meglio?
Allora il tuo suggerimento sarebbe stato piu` che adeguato :)
--
Bye,
  Gabry

 Forse c'e' qualche caratteristica che potrei rimpiangere su VS2005/2008?
Se è normale scrivere programmi anche in dotnet e/o si fa un uso molto 
forte di MSDN e/o si vuole usare un debugger remoto semplice da usare, 
allora dovrebbe risultare comodo VS. Per altro MSDN si può installare a 
parte, o si può accedere a quello online. Di solito dall'ufficio uso 
quello installato sul PC per motivi di reattività, mentre le 
rarissime-issime-issime volte che ho lavorato da casa ho usato quello 
online senza troppo problemi (prestazioni a parte).
Io mi trovo bene con VS, però devo dire che sotto Linux l'ho rimpianto 
fino a che non ho trovato KDevelop, con cui mi trovo bene. Usare i tool 
a riga di comando non fa per me. In ditta però più di una persona è 
felice usando WIM, lanciando le compilazioni "a mano" attraverso una 
sessione telnet, e così via. Hanno installato VS sulle loro macchine in 
osservanza alle politiche aziendale, ma non usano molto l'IDE.
No, non c'è niente in VS che lo rende insostituibile, secondo me, anche 
se fare il paragone con VC 6 è abbastanza ingeneroso. Non sono nemmeno 
lontani parenti quanto usabilità, e quanto a potenzialità/usabilità del 
debugger. Oltre a questo VC 6 gestiva male i template.


 lanciarli se mi servono. Sia in C# che in C++.
Cribbio ... non ci avevo mai pensato.
Siccome ne hai esperienza diretta, ti chiedo una cosa 
(attinente al più volte discusso problema del codice 
automodificante) :
Modificare il file sotteso a un dato eseguibile in 
esecuzione (cioè quello che è stato caricato in memoria) mi 
pare sia difficile (è molto che non riprovo a farlo, ma 
l'ultima volta non l'ho spuntata contro il messaggio di file 
già aperto, o forse era in sola lettura, non ricordo).
Ti chiedo : per il file delle risorse, vale la stessa 
protezione dalla scrittura ? Viene integrato nell'EXE 
obbligatoriamente o può essere lasciato fuori, standalone, e 
in tal caso, lo puoi sovrascrivere dall'exe in esecuzione a 
farci i giochetti che hai scritto : cioè nasconderci 
eseguibili di supporto da caricare alla bisogna ?
Non so se sono riuscito a spiegarmi bene
(in caso, cercherò di chiarire meglio)
ciao
Soviet


 scrittura ?
Voglio sperare di si, bisogna guardare la documentazione comunque.
Nel mio caso faccio tutto per rendere semplice l'installazione e per  
per "aggirare" la licenza GPL del gzip. Quando mi serve *lo estraggo* 
dalle risorse, poi uso la copia estratta. Il suo uso è essenzialmente 
comprimere dei file testuali di log.
Nel mio codice non ho codice GPL, e non corro il pericolo che qualche 
installatore se lo dimentichi, o qualche utente furbo me lo cancelli 
cancellandomi completamente la cartella dei log (cosa che faccio spesso 
in verità).
Avessi trovato una libreria C/C++ che mi comprimesse i file in formato 
Zip o Gzip, disponibile con i sorgenti, che costasse molto poco o 
niente, non GPL, non avrei messo in piedi questo meccanismo.


 niente, non GPL, non avrei messo in piedi questo meccanismo.
http://www.zlib.net/
potrebbe andare bene?

 da una parte, mentre Java, C# e C++ stanno dall'altra.
Mi piace questa distinzione. Anche se aggiungerei 'modificare in modo
naturale'.
Poi comunque ci sono problemi.
In Objective-C posso caricare una 'categoria' che puň andare a cambiare
il programma. Tuttavia questa categoria deve essere stata compilata,
quindi probabilmente la distinzione č buona va solo resa piů precisa.
BTW, Objective-C č tipizzato dinamicamente.


 oppure devo copiare i files a mano?
Eh. Come dire...


 Magari in python è più facile che in C++, questo sì.
Oltre che più facile è proprio *parte* del linguaggio.
Un'implementazione di Python che non lo permettesse *non* sarebbe
un'implementazione conforme di Python.


 comprimere dei file testuali di log.
Ok, e sin qui sembra che il codice sia "costante", non 
automodificante. Ma in un altro punto del thread mi pareva 
di ricordare che avessi usato la parola codice iniettato.
Non ho capito se iniettavi qualcosa in memoria (prima o dopo 
il lancio in esecuzione) e quindi in modo temporaneo, o se 
iniettavi i tuoi eseguibili embedded nel file di risorse su 
disco in maniera permanente.
Se non mette in crisi le tue strategie professionali, mi 
interesserebbe qualche dettaglio in merito. Tipo chiami 
qualche api specifica, altre cose del genere.
ciao, e grazie cmq a prescindere se puoi approfondire o meno 
(capisco che si tratta del tuo "pane" ;-))
Soviet_Mario


 Eh. Come dire...
????
E.

 una dll, caricarla al volo, eseguire il codice, scaricare l'oggetto. 
Sì, è una cosa che feci a suo tempo in un programma di tipo numerico. 
L'utente scriveva una funzione matematica con la sintassi del C, io poi 
la trasformavo in una sorgente C, la compilavo e la caricavo 
dinamicamente. L'alternativa sarebbe stata fare un parser matematico, 
più complicato e più lento.
E.

 codice in esecuzione, 
L'inizializzazione delle variabili statiche, in C, viene fatta alla 
prima chiamata della funzione. Mi pare che il sistema usato per 
implementare questa funzionalità sia proprio quello di modificare il 
codice della funzione durante la prima chiamata, in modo che dalla 
seconda in poi la variabile non venga più inizializzata.
E.

Secondo l'OP stiamo andando parecchio OT... ;-)
Mi sto perdendo...

 potrebbe andare bene?
Cavolo, per colpa del mio viziaccio di non leggere bene le cose non mi 
ero accorto della licenza. Grazie mille!
Ci devo pensare però. Sul cluster mi fa comodo che siano processi 
diversi da quelli principali a fare le compressioni. Sono processi a 
bassa priorità, e non interferiscono troppo con l'attività sotto 
carico. Se facessi la compressione dai programmi principali e non 
usassi i thread non potrei fare analisi durante la compressione. Se 
usassi i thread dovrei gestire il caso in cui ho un crash o una 
richiesta di chiusura del processo durante le compressioni.
Però potrebbe farmi comodo se decidessi un giorno di inviare in rete 
dati compressi.


 della memoria.
Sulla memoria già caricata, non necessariamente su quella creata a 
run-time. Il trucco è tutto lì.


 un'implementazione conforme di Python.
Mi viene da pensare a codice python che viene compilato direttamente in 
codice macchina. Non conforme al regio decreto pythonico, certo, però 
lo stesso codice, lo stesso linguaggio, permetterebbe o meno *qualcosa* 
a seconda dell'implementazione dell'ambiente di sviluppo. Certo la 
versione compilabile direttamente del linguaggio probabilmente sarebbe 
sovrapponibile a livello di linguaggio con il python ufficiale, però 
... chi se ne frega.
Il codice automodificante è un dettaglio implementativo, secondo me. 
Niente vieta di avere un C++ interpretato, o un C++ che genera pcode. 
Mi sa anzi che C++ compilato "in maniera" dotnet rientra in questo 
secondo caso. Quindi automodificante forse senza neanche troppo 
sbattersi. Forse. L'argomento mi interessa poco in verità.


 codice iniettato.
Sono cose diverse che uso per motivi diversi.
Premessa, io odio il codice automodificante, tranne in due casi. Il 
perché lo odi si spiega con un comune neologismo: non debuggabile.
Le due eccezioni sono 
http://upx.sourceforge.net/
e criptare l'eseguibile a fine protettivi. Il secondo caso si bypassa 
facile, però bisogna sapere come, e deve valerne la pena.
Quando metto un eseguibile nel file delle risorse lo faccio per tirarlo 
fuori ed eseguirlo, stop. Nessun codice automodificante. Oltre ai 
thread uso i task, se necessario. Tutto qui. E' solo un meccanismo per 
avere certezza che certo codice compilato esista sulla macchina di 
produzione.
Il caso dell'inezione di codice lo faccio per modificare il 
comportamento di un programma di terze parti. Si può fare, ma qui mi 
fermo. Non perché sia preoccupato dell'OT (in tempo di puri messaggi IT 
questo NG era abbastanza un mortorio n.d.p.), ma perché complicato da 
spiegare. Sotto windows puoi partire da qui:
http://msdn2.microsoft.com/en-us/library/ms682437.aspx
https://quequero.org/store/program/ntos_pe.htm


 
https://quequero.org/store/program/ntos_pe.htm
grazie, appena ho tempo vedo se ne capisco qualcosa
ciao
Soviet_Mario

 due eccezioni sono 
http://upx.sourceforge.net/
Non mi pare che in questo caso si possa veramente parlare di codice
automodificante.
O almeno, *io* per codice automodificante intendo qualcosa che
modifica se stesso, non qualcosa che genera codice. Secondo la tua
definizione, anche i vari JIT risulterebbero codice automodificante.
Di codice automodificante vero e proprio non ne vedo dai tempi del
386, e anche li' era per fare cose abbastanza esoteriche (un
rotozoomer particolarmente veloce, ad esempio).Sul 6502 era quasi
necessario, in alcuni casi...
--
Marco
 
-- 
I'm using an evaluation license of nemo since 228 days.
You should really try it!
http://www.malcom-mac.com/nemo

386, e anche li' era per fare cose abbastanza esoteriche
Bho, l'unico codice automodificante "puro" che mi viene in mente sono i 
virus polimorfici con le loro tecniche per evitare le schedature degli 
anti virus ( 
http://en.wikipedia.org/wiki/Dark_Avenger
  ). Tecnica 
sopraffina, ma mi sono sempre chiesto perché uno deve perdere tempo a 
scrivere virus. O lo stipendiava un governo, o una ditta di antivirus.


 Allora il tuo suggerimento sarebbe stato piu` che adeguato :)
Il mio suggerimento mi sembra assolutamente adeguato, visto che l'OP
chiede consigli su quale ambiente utilizzare.

 fai :-)
O con le MFC, che per quanto brutte, sono pur sempre LE librerie per 
windows, e sono economiche rispetto altre alternative con licenza 
commerciale (penso a QT, che io adoro, ma che sono improponibili per un 
piccolo sviluppatore indipendente e squattrinato).

 da una parte, mentre Java, C# e C++ stanno dall'altra.
E anche qui il confine è molto flebile, leggo ora della possibilità di 
creare dei dynamic assembly, cioè creare pezzi di codice IDL da eseguire 
durante il runtime...
Senza nulla togliere alla tua definizione, che a me pare la più calzante.

 naturale'.
Sapevo che ci saremmo intesi ;-)
Ciao,
Nicola

 da una parte, mentre Java, C# e C++ stanno dall'altra.
Non capisco cosa intendi per "modificare il programma". Pensi alle 
funzioni "lambda" o altro?
Nel lisp puro non si possono neanche modificare i dati, o sbaglio?
E.

niente, non GPL, non avrei messo in piedi questo meccanismo.
L'open source è bello per questo. Scrivila tu e la comunità te ne sarà
grata. 
(Speravo di trovare occasione di girare a qualcuno la risposta
ricevuta anni fa, quando cercavo un driver sotto Linux per la mia
scheda grafica).




Anche in Java puoi generare classi nuove, ma non si possano ricaricare
classi gia' caricate con istanze presenti. Con i delegates di C#,
pero', puoi inventarti qualcosa che sembri una classe, ma i cui metodi
cambiano... a questo punto, crei un assembly al volo, deleghi il
metodo e vinci. Quasi.
--*PaN!*
 
-- 
I'm using an evaluation license of nemo since 233 days.


 moltissimo.
VS7 (che e' il 2002, non il 2003) va cancellato dalla faccia della
terra.VS7.1 e' il 2003, ed ha un senso :)


 scheda grafica).
Ho messo in pubblico dominio un trasformatore da XML in RTF. Scritto in 
dotnet mi serve per colorare del XML che carico dentro un controllo 
rich text box. C'è pure qualche bugs che non correggerò mai perché non 
ho voglia di studiare il problema. Giustamente la cosa non interessa 
nessuno.
Quindi ci andrei piano ad affermare che la comunità mi sarebbe grata 
per del mio codice. Forse mi è grata proprio perché non rilascio codice 
:-)


 niente, non GPL, non avrei messo in piedi questo meccanismo.
queste cosa hanno che non va?
http://www.boost.org/doc/libs/1_35_0/libs/iostreams/doc/home.html
http://zlib.net/
Mauro

 
http://www.boost.org/doc/libs/1_35_0/libs/iostreams/doc/home.html
Divertente. Ho appena ricompilato del mio codice per usare le 1.35.0 e 
malgrado ciò non mi sono mai accorto che c'erano librerie di 
compressione dentro boost. In realtà non mi sono mai accorto della 
presenza di questo _capitolo_.
L'ho messo nella coda delle cose da studiare.


occuparmi nel mio tempo libero.
Probabilmente non hai capito che era una battuta ;-)

 Probabilmente non hai capito che era una battuta ;-)
Una parte del mio cervello l'aveva sospettata, l'altra parte era 
concentrata sul debugger. Porta pazienza, sono giornate difficile 
queste.
Vengo qui sul NG per staccare per un attimo la spina, ma evidentemente 
la stacco troppo :-)


 possibile risalire al sorgente.
Uhm, direi che non regge. Prendi per esempio un compilato pesantemente
ottimizzato generato da un compilatore OCaml. E' compilato in codice
nativo e pesantemente ottimizzato. A OCaml non risalirai *mai* (fra
l'altro a sboccio i funzionali sono relativamente difficili da
ricorstruire a prescindere proprio perchè molte strutture logiche del
linguaggio sono ben diverse da quelle del compilato sottostante.
Tuttavia OCaml viene anche interpretato o bytecompilato su una macchina
virtuale (e li tornare al sorgente dovrebbe essere più facile).
Il problema è che la questione stessa è malposta. Volere associare un
aggettivo che riguarda un implementazione (compilato/interpretato) ad un
linguaggio (ente matematico 'astratto') fallirà sempre. Non è difficile
costruire (o trovare) controesempi.
Appena hai un linguaggio con implementazioni sia a compilazione
ottimizzata in codice nativo sia con macchina virtuale (interpretazione
pura o compilazione a bytecode e interpretazione di questo), qualunque
tipo di distinzione viene a cadere.
-- 
cc = callcc {|cc| cc.call cc}; cc.call cc

 terra.VS7.1 e' il 2003, ed ha un senso :)
Infatti non si trova neanche menzione del 2002 :) pensa te.


Che visione sovietica del mondo! Non e' che se di una cosa non si
parla, non e' mai esistita. Qui da noi c'e' ancora qualche progetto
realizzato con VS 7 e mai convertito.
Ciao,
Nicola