Newsgroup: it.comp.programmare
Titolo: Quale ambiente per iniziare con il C++?

Hi all!
Avrei intenzione finalmente di iniziare a programmare in C++ applicazioni
per Windows.
Quale ambiente mi consigliate?
Visual C++ della Microsoft o Borland C++?
Ci sono differenze sostanziali?
Grazie in anticipo...
Ciao, Alfonso.

c++ builder meglio all'inizio.
visual c++ dopo.
-- 
Valter Mazzola -  Software/Databases for Enterprise Web Internet Sites
PHP, Java Servlets, Applets, Jsp, ASP, PERL, Mod_Perl, Apache, IIS,SQL
* 
http://SitiDinamici.com/SuperTraffico
 
http://italia.LinSwap.com/?n
 
* 
http://www.winXPfind.com

 Quale ambiente mi consigliate?
Nessuno: un buon editor, un compilatore (il Borland C 4.5 e' gratuito)
ed un buon manuale (tipo il "Programming Windows" del Petzold).
Dopo un po' di tempo, quando hai capito cosa cavolo stai facendo, puoi
cominciare a pensare agli "ambienti".
Davide

Io + che col C++Builder ti consiglierei di iniziare con qualcosina di
facile facile da dos.. tipo con un vecchio borland C++. E' più
semplice e più pulito da usare...
byez
Polling
__________________
WebMaster di Xol.it 
Risorse per programmatori. 
http://www.xol.it

 ha scritto nel messaggio
news:a8grn8$s307g$2...@ID-18487.news.dfncis.de...

Grazie a tutti per i consigli!
Dove posso trovare il Borland C++ 4.5?
Grazie, Alfonso.

 Dove posso trovare il Borland C++ 4.5?
Credo di averlo trovato sul sito della Borland (come era ovvio)!
Ma si tratta della versione 4.5? Spero di si, in quanto avrei anche un bel
manuale approposito.
Ciao, Alfonso.

semplice e più pulito da usare...
io direi di incominciare con il _nuovo_ Borland C++ Compiler
5 che trovi sul sito della borland
--
Lawrence Oluyede
rhy...@myself.com

ed un buon manuale (tipo il "Programming Windows" del Petzold).
1 - Borland C se non erro compila solo C...non C++ :)
2 - il Petzold non č per nulla un libro per principianti del
C (dato che usa quel linguaggio) e tantomeno del C++
Ad ogni modo la combinazione migliore č:
BorlandC++Compiler (o Dev-C++) + "Thinking in C++" (o il
libro di Stanley Lippman)
--
Lawrence Oluyede
rhy...@myself.com

Nessuno: un buon editor, un compilatore (il Borland C 4.5 e' gratuito)
Borland C++ Builder Compiler 5.5
http://www.borland.com/bcppbuilder/freecompiler/
A mio avviso, comunque, e' bene iniziare con ambienti di
programmazione RAD (vedi C++ Builder con supporto VCL/CLX),
per poi capire gli "internals" fondati sulle API.
-- 
Andrea Laforgia (
walkie...@libero.it
)
"Usenet is a strange place" [Dennis Ritchie]

 Visual C++ della Microsoft o Borland C++?
se permetti un consiglio, per ora lascia perdere la programmazione sotto 
Windows. Nota che non ti sto dicendo di passare a linux o che altro: 
semplicemente prima di fare tanti bei bottoncini colorati sarebbe meglio 
imparare per bene il linguaggio che vuoi usare, nel tuo caso il C++: 
prima passa qualche tempo a fare programmi "console" o a "riga di 
comando": una volta imparato bene il linguaggio ti puoi concentrare 
sulla interfaccia grafica.
Per quel che riguarda i libri ti consiglio di leggerti le faq di 
it.comp.lang.c++, disponibili su 
cpp.programmazione.it
.
ciao Anto
-- 
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.73, higher than 99% of all previous test takers.
C Language: 3.79, higher than 92% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it

 per poi capire gli "internals" fondati sulle API.
Assolutamente, prima è *necessario* studiare il linguaggio, poi si pensa 
ai RAD o alle API.
Maurizio

 manuale approposito.
mah... io ricordavo che era la ver. 5.5 gratuita... la 4.5 dovrebbe 
essere vecchiotta se non vado errato.
Maurizio

ai RAD o alle API.
E' possibile studiare il linguaggio anche con un ambiente di
programmazione RAD.  Non c'e' alcuna implicazione
implicazione sull'apprendimento del linguaggio in se'.
L'uso delle API e' indipendente dal linguaggio e viceversa.


 L'uso delle API e' indipendente dal linguaggio e viceversa.
IMHO no. L'ambiente RAD sposta l'attenzione sull'interfaccia con 
l'utente, chi inizia ad imparare a programmare invece dovrebbe 
strafregarsene.
Ho visto persone imparare a programmare con VB e con Delphi: risultati 
pessimi a livello di programmazione (non di concretezza del software: 
insomma i programmi li facevano e anche utili), hanno dovuto tutti 
disimparare l'abitudine che avevano di far si che fosse l'IDE a lavorare 
per loro.
Io consiglierei sempre il "console mode" per cominciare. ;) (occhio che 
anche alcuni ambienti RAD permettono di programmare per la modalità 
console, però in questo modo perdi i vantaggi del RAD, quindi non si può 
dire che stiamo usando un RAD in quel caso)
Maurizio

Io consiglierei sempre il "console mode" per cominciare. ;)
A mio avviso, il fatto che programmare in "console mode" sia
meglio che programmare direttamente con finestre e bottoni,
e' una mera illusione.  Ribadisco: dal punto di vista
dell'apprendimento del linguaggio in se', non c'e' alcuna
implicazione.  


Scusate se mi intrometto.
Io non possiedo alcun tipo di background scolastico di tipo informatico.
Infatti ho frequentato un istituto elettrotecnico, ed ai miei tempi (primi
anni 80) il computer era relegato in qualche ufficio.
Ho iniziato col Delphi, per carita' uno dei migliori (secondo me) ambienti
di programmazione, che pero' ti vizia in quanto e' sufficente aprire l'IDE e
compilare per trovarsi con un applicazione Windows funzionante. Questo puo'
far erroneamente pensare che sia sufficente passare una unit vuota ad un
compilatore per ottenere un eseguibile che visualizza una finestra :-).
Ultimamente ho provato ad utilizzare un compilatore semplice (giusto per
provare) per costruire una semplice applicazione Windows di prova e mi sono
ritrovato di fronte a cose mai viste:
WinMain > che e' ?!
RegisterClass > devo registrare la classe? E una volta registrata che
succede mi ci fanno pagare le tasse? :-))
Mi sono reso conto di non aver imparato a programmare il sistema, cioe' a
fare in modo che il sistema faccia quello che voglio, ma ho semplicemente
imparato ad usare uno strumento (Delphi) quasi come una segretaria impara ad
usare Word per scrivere le lettere ma senza avere la piu' pallida idea di
come questo funzioni :-((.
Insomma penso che non farebbe male imparare i "dettagli a basso livello",
giusto per capire come funzionano le cose dietro le quinte. Poi,
successivamente, si passera' ai RAD che permettono di concentrarsi solo
sulla "logica" del programma senza pensare ai dettagli tecnici. In questo
modo si apprezzera' ancora di piu' la potenza dei RAD.
Ovviamente tutto quanto detto sopra contornato da un bell' IMHO.
Ciao, Marco.

e' una mera illusione.
Secondo me la differenza è dovuta al fatto che se si iniziano subito a
fare finestre e bottoncini si devono impare contemporaneamente un
linguaggio e una framework/api, cioè due cose contemporaneamente
mentre se prima si tenta di imparare il linguaggio e basta bisogna
imparare solo una cosa.
Comunque l'ambiente RAD in sé non penso abbia effetti negativi.
-- 
Marco Barisione (ICQ 84277092)

imparare solo una cosa.
Ribadisco: il linguaggio si impara anche con un ambiente
RAD.  Le cose da conoscere, per far funzionare
un'applicazione di base sono veramente minime.


modo si apprezzera' ancora di piu' la potenza dei RAD.
Ribadisco: e' il contrario.  
Si inizia prima dalle cose facili e poi si passa a quelle
piu' complicate.


 al programmatore<ZAP>
Il fatto e': questi strumenti, risolvono problemi (eliminato il
"grossi") al *programmatore* o li "risolvono" al wannabe-programmatore ?
Poi ti trovi la gente che scrive sul curriculum "linguaggi: Visual C++",
gli domandi che cosa e' un puntatore e ti guarda come se venissi da marte...
Ricordo tutt'ora una lettera che lessi su una rivista (Microsoft)
in risposta ad un'articolo relativo agli algoritmi, la lettera cominciava
con "sono un programmatore, ho scritto molti programmi, alcuni
usano algoritmi, altri no..."... questo qui' e' un programmatore ?
Prima viene il linguaggio, poi l'ambiente.
Davide

 piu' complicate.
Si in effetti forse imbattersi subito nei dettagli complicati puo'
scoraggiare chi inizia che pensa: "ma guarda il codice che mi tocca scrivere
solo per fare apparire una semplice finestra".
Ciao, Marco.

 standard) in C++ Builder.
Aspetta, allora forse non ho ben seguito il thread. Mi sembrava che si 
stesse parlando di imparare un linguaggio+imparare a programmare. Per 
quanto concerne la prima sono d'accordo con te.
Maurizio

 
Sono d'accordo. Ma avere a disposizione un potente tool da imparare č 
piů semplice che fregarsene dell'interfaccia con l'utente e programmare 
usando solo le caratteristiche standard del linguaggio?
Maurizio

 
salve a tutti, mi chiamo Leonardo, sono uno studente di informatica, ed 
anche se mi sono iscritto da poco al NG vorrei dire lo stesso la mia 
sulla questione.
Personalmente trovo che ci sia da fare qualche distinzione non solo tra 
RAD e console mode, ma anche tra i vari ambienti RAD in commercio. Ad 
esempio non credo cioè possibile mettere allo stesso livello un progetto 
creato creato con in C++ Builder ed uno in Visual Basic; in primo luogo 
per la diversità sostanziale dei due linguaggi e dell'approccio che si 
ha con ognuno di questi.
Credo che a livello superficiale i due ambineti possono sembrare 
somiglianti; la creazione di form, l'aggiunta dei componenti visuali e 
così via; in questo senso potremmo creare programmi non molto differenti 
  tra essi. Ma scendendo a livello codice si vede la differenza vera e 
propria: C++ richiede a mio parere una conoscenza più approfondita 
rispetto Visual Basic, che trovo molto intuitivo (io stesso passando dal 
C++ a VB mi sono meravigliato di quanto fosse meno imegantivo 
quest'ultimo). Molte delle persone che iniziano la loro attività in VB 
non sempre hanno basi di programmazione sufficienti per dedicarsi a 
progetti molto impegnativi, ma si affidano alla speranza che qualche 
proprietà degli oggetti descritta nell'omonima tabella faccia al caso loro.
con questo non voglio sminuire vb, dato che nonostante tutto devo 
riconoscerne una buona usabilità. Ma preferisco pensare che una persona 
veramente interessata alla programmazione debba prima rendersi conto 
cosa ci sia dietro i pulsanti e le caselle di testo che inserisce con 
due click sul form. altrimenti si rischia, specie alle prime armi, di 
pensare alla programmazione OOP come un mero esercizio di disegno, con 
aggiunta di 50 righe di codice di cui 20 già aggiunte dal programma stesso.
credo che qualche esperienza in console mode sia molto utile, se non 
fondamentale. C'è molta differenza tra scrivere printf("ciao mondo!"); , 
cout<<"ciao mondo!"; o MsgBox "ciao mondo!" . Le prime due si avvicinano 
molto più al funzionamento vero e proprio della macchina, mentre  la 
terza nasconde molte più operazioni che adrebbero prima chiarite almeno 
un po'.

Prima viene il linguaggio, poi l'ambiente.
Un'affermazione, la tua, che non ha alcun senso.
Un linguaggio non lo puoi imparare se non hai un ambiente,
quindi, al limite, le due cose si imparano
contemporaneamente.  Non conviene imparare ad usare un
ambiente basato su testo sotto Windows, perche' toccherebbe
passare, prima o poi, ad un ambiente + o - visuale.
Tanto vale, iniziare subito con un ambiente RAD, la cui
conoscenza e' riciclabile anche a livello professionale.


con quelle caratteristiche ecc.
Come sto ripetendo dall'inizio: non serve conoscere da
subito questi dettagli.  E' chiaro che e' meglio sapere che
cosa succede dietro le quinte, ma ogni ambiente RAD che si
rispetti non ti impedisce di approfondire le tue conoscenze.
Un programmatore che deve sbattersi da subito tra l'uso
delle API e l'uso del linguaggio, non puo' che venirne fuori
con una certa confusione.  I programmatori alle prime armi
sono piu' stimolati ad imparare se riescono, da subito, a
compiere qualcosa di buono, ma se prima di vedere a video
una finestra devono imparare tutto il meccanismo
retrostante...


usando solo le caratteristiche standard del linguaggio?
Si', non solo piu' semplice, ma anche piu' produttivo.


quanto concerne la prima sono d'accordo con te.
Si sta parlando di programmazione per Windows e di imparare
il C++ nel contesto della programmazione per Windows e non
c'e' alcun motivo per preferire un ambiente non-RAD ad uno
RAD.


un po'.
L'apprendimento della OOP e la costruzione di un'interfaccia
grafica sono due cose assolutamente distinte.  
E' assolutamente sbagliato, a mio avviso, pensare che si
debba partire sempre prima dalle cose di piu' basso livello,
perche' altrimenti diciamo pure che e' meglio imparare a
fare finestrelle e bottoncini in assembly (si puo' cosi'
scoprire qual' e' il "funzionamento vero e proprio della
macchina").  Non serve sapere da subito qual e' il
"funzionamento vero e proprio della macchina".  Ribadisco il
mio pensiero: prima di impara a fare le cose piu' semplici e
poi si approfondiscono le conoscenze.  Cerca di convincere
un tuo collega che vuole imparare a programmare per Windows
che e' bene partire da:
// pluto.cpp : Defines the entry point for the application.
//
#include "stdafx.h"
#include "resource.h"
#define MAX_LOADSTRING 100
// Global Variables:
HINSTANCE hInst;
// current instance
TCHAR szTitle[MAX_LOADSTRING];
// The title bar text
TCHAR szWindowClass[MAX_LOADSTRING];
// The title bar text
// Foward declarations of functions included in this code
module:
ATOM				MyRegisterClass(HINSTANCE
hInstance);
BOOL				InitInstance(HINSTANCE,
int);
LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK	About(HWND, UINT, WPARAM, LPARAM);
int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
 	// TODO: Place code here.
	MSG msg;
	HACCEL hAccelTable;
	// Initialize global strings
	LoadString(hInstance, IDS_APP_TITLE, szTitle,
MAX_LOADSTRING);
	LoadString(hInstance, IDC_PLUTO, szWindowClass,
MAX_LOADSTRING);
	MyRegisterClass(hInstance);
	// Perform application initialization:
	if (!InitInstance (hInstance, nCmdShow)) 
	{
		return FALSE;
	}
	hAccelTable = LoadAccelerators(hInstance,
(LPCTSTR)IDC_PLUTO);
	// Main message loop:
	while (GetMessage(&msg, NULL, 0, 0)) 
	{
		if (!TranslateAccelerator(msg.hwnd,
hAccelTable, &msg)) 
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}
	return msg.wParam;
}
//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
//  COMMENTS:
//
//    This function and its usage is only necessary if you
want this code
//    to be compatible with Win32 systems prior to the
'RegisterClassEx'
//    function that was added to Windows 95. It is important
to call this function
//    so that the application will get 'well formed' small
icons associated
//    with it.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
	WNDCLASSEX wcex;
	wcex.cbSize = sizeof(WNDCLASSEX); 
	wcex.style			= CS_HREDRAW |
CS_VREDRAW;
	wcex.lpfnWndProc	= (WNDPROC)WndProc;
	wcex.cbClsExtra		= 0;
	wcex.cbWndExtra		= 0;
	wcex.hInstance		= hInstance;
	wcex.hIcon			=
LoadIcon(hInstance, (LPCTSTR)IDI_PLUTO);
	wcex.hCursor		= LoadCursor(NULL,
IDC_ARROW);
	wcex.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
	wcex.lpszMenuName	= (LPCSTR)IDC_PLUTO;
	wcex.lpszClassName	= szWindowClass;
	wcex.hIconSm		= LoadIcon(wcex.hInstance,
(LPCTSTR)IDI_SMALL);
	return RegisterClassEx(&wcex);
}
//
//   FUNCTION: InitInstance(HANDLE, int)
//
//   PURPOSE: Saves instance handle and creates main window
//
//   COMMENTS:
//
//        In this function, we save the instance handle in a
global variable and
//        create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;
   hInst = hInstance; // Store instance handle in our global
variable
   hWnd = CreateWindow(szWindowClass, szTitle,
WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL,
hInstance, NULL);
   if (!hWnd)
   {
      return FALSE;
   }
   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);
   return TRUE;
}
//
//  FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND	- process the application menu
//  WM_PAINT	- Paint the main window
//  WM_DESTROY	- post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM
wParam, LPARAM lParam)
{
	int wmId, wmEvent;
	PAINTSTRUCT ps;
	HDC hdc;
	TCHAR szHello[MAX_LOADSTRING];
	LoadString(hInst, IDS_HELLO, szHello,
MAX_LOADSTRING);
	switch (message) 
	{
		case WM_COMMAND:
			wmId    = LOWORD(wParam); 
			wmEvent = HIWORD(wParam); 
			// Parse the menu selections:
			switch (wmId)
			{
				case IDM_ABOUT:
				   DialogBox(hInst,
(LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
				   break;
				case IDM_EXIT:
				   DestroyWindow(hWnd);
				   break;
				default:
				   return
DefWindowProc(hWnd, message, wParam, lParam);
			}
			break;
		case WM_PAINT:
			hdc = BeginPaint(hWnd, &ps);
			// TODO: Add any drawing code
here...
			RECT rt;
			GetClientRect(hWnd, &rt);
			DrawText(hdc, szHello,
strlen(szHello), &rt, DT_CENTER);
			EndPaint(hWnd, &ps);
			break;
		case WM_DESTROY:
			PostQuitMessage(0);
			break;
		default:
			return DefWindowProc(hWnd, message,
wParam, lParam);
   }
   return 0;
}
// Mesage handler for about box.
LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM
wParam, LPARAM lParam)
{
	switch (message)
	{
		case WM_INITDIALOG:
				return TRUE;
		case WM_COMMAND:
			if (LOWORD(wParam) == IDOK ||
LOWORD(wParam) == IDCANCEL) 
			{
				EndDialog(hDlg,
LOWORD(wParam));
				return TRUE;
			}
			break;
	}
    return FALSE;
}
e non piuttosto dal piu' semplice:
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
USERES("Project1.res");
USEFORM("Unit1.cpp", Form1);
//---------------------------------------------------------------------------
WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
        try
        {
                 Application->Initialize();
                 Application->CreateForm(__classid(TForm1),
                                         &Form1);
                 Application->Run();
        }
        catch (Exception &exception)
        {
                 Application->ShowException(&exception);
        }
        return 0;
}
//---------------------------------------------------------------------------


 Un linguaggio non lo puoi imparare se non hai un ambiente,
Bum.  A 16 anni imparai il Lisp 1.5 da un ottimo libro.  Chi si poteva
permettere lussi come un computer, allora...?  Eppure il concetto di
algoritmo, struttura dati, programma, ecc ecc, li imparai benissimo,
e mi permetto di dire che imparai il Lisp nello stesso senso in cui
imparai piu` o meno alla stessa eta` le algebre astratte: un cruciale
arricchimento culturale, anche se nessuno mi permetteva di "eseguire"
checchessia se non nella mia mente.
Quando pochi anni dopo uscirono le prime calcolatrici programmabili
RPN (HP), e poi finalmente all'universita` trovai le schede perforate
e il Fortran, il Lisp che avevo imparato mi aiuto` molto, come per i
corsi di analisi mi aiuto` capire le algebre astratte, anche se si trattava
sempre di approcci assai piu` concreti di quelli molto concettuali che
avevo imparato (sui libri e per conto mio) quando ero al liceo.
"Non lo puoi imparare"... che esagerazione...!!!
Alex

 imparano contemporaneamente.
Al limite se non hai un compilatore/interprete (e anche lě č discutibile
come diceva Alex, ma poter mettere in pratica č IMHO importante).
Avere o meno un ambiente di sviluppo "integrato" non č particolarmente
utile, anzi distrae soprattutto se sei agli inizi. Per imparare un 
linguaggio di scripting ad esempio
tutto "l'ambiente" di cui puoi avere bisogno č Vi e un bel
#!/dovestalinterprete , ma non credo sia l'ambiente che intendi tu.

 comunque.
No, no e poi no. Mi dispiace ma non sarò mai d'accordo con te su questo 
punto. ;)
IMHO si dovrebbe prima imparare a programmare, quindi si passa a 
Windows: senza le conoscenze di base utilizzeremmo gli strumenti che ci 
offre il RAD in modo errato (io ho visto anche persone ordinare dei dati 
sfruttando la proprietà sort di una Combo List). Te mi dirai "è un 
errore del programmatore" al chè io ribatto "per forza! Non l'hai mai 
fatto diventare un programmatore!". Il fatto di scrivere programmi non 
implica, anche se sembra contraddittorio, essere programmatori.
Il tuo ragionamento è comunque giustissimo nel mondo del lavoro dove 
l'importante è essere produttivi.
Maurizio

Io sono d'accordo con Andrea! la vostra sinceramente mi sembra un po' una
guerra di religione! Ok se uno comincia con un buon VC++ qualche passaggio
gli viene nascosto. Voglio però ricordarvi una cosa, quando nella vostra
carriera di studenti vi hanno spiegato qualcosa, hanno cominciato subito con
una spiegazione esaustiva o prima ne hanno fatto un intro? alle elementari
voi per es studiate storia, mate ... in un certo modo, alle medie studiate
le stesse cose(specialmente storia) ma le fate più approfondite e alle
superiori andrete ancora più a fondo. Si parte sempre dalle cose semplici
per arrivare a quelle difficili!
Ora se voi sapete cosa sono Form, Label, Messaggi e tutte le altre
diavolerie della programmazione win allora quando vedrete del codice puro
senza ausilio di RAD saprete di cosa state parlando! provate ad aprire un
bel file .c o .cpp con notepad senza aver prima provato un po' a programmare
in Win aiutati da qualche RAD! è come cercare di imparare a nuotare
buttandosi in mezzo all'oceano! si parte dall'acqua bassa!!! (oggi sono in
vena di metafore) Poi non è che un RAD si inventi il programma, il compito
resta sempre al programmatore anche se è un po' accompagnato per mano. Chi
comincia con VB ha sicuramente una visione della programmazione un po'
limitata e semplicistica ma non gli è certo precluso e non sarà neanche più
difficile imparare cose un po' più avanzate.
Ciao
Wezzy
Ps
imparare il Lisp su un libro senza metterlo in pratica per anni è operazione
da veri eletti!ci vuole una forza di volontà e una capacità d'astrazione
rara, ma perchè dovremmo subire questo supplizio al giorno d'oggi?

rara, ma perchč dovremmo subire questo supplizio al giorno d'oggi?
perchč a questo modo si formerebbero degli ottimi
programmatori come Alex e non programmatori figli dei RAD
--
Lawrence Oluyede
rhy...@myself.com

 programmatori come Alex e non programmatori figli dei RAD
Troppo buoni, ma mi pare che si stia esagerando.  Io imparai Lisp
sul manuale perche` solo quello avevo: dubito che il fatto di non
poterlo provare su di una macchina sia intrinsecamente formativo!-)
Penso, al contrario, che le modalita` interattive e comunque i tempi
di turn-around brevissimi siano utili per tutti.
RAD e` un termine "sovraccarico".  Se si deve usare un linguaggio
ricco di ridondanza e boilerplate come il C++, certo un editor un po'
furbo che faciliti l'immissione ed il controllo delle parti ripetitive e
boilerplate puo` aiutare.  Tutta una serie di aspetti di editing come
la colorizzazione sintattica e i tooltip aiutano in qualsiasi linguaggio.
Questi aspetti di un "deployment rapido delle applicazioni" non fanno
certo danni!  Quando invece per "RAD" si intendono strumenti che
si _sostituiscono_ (o provano...) alla comprensione dei problemi e delle
tecnologie da parte del programmatore, come se ne vedono sia nel
mondo GUI sia in quello DB, allora, secondo me, le cose cambiano.
Purtroppo mi pare che molto di quel che si vende come RAD "cerchi"
in qualche modo di presentarsi in questa chiave.  E invece, "non c'e`
strada reale per la geometria": le cose bisogna capirle, per lavorarci
bene.  Uno strumento che cerca di rimpiazzare il comprendonio non
puo` mancare di intralciare l'applicazione del comprendonio stesso
quando quest'ultimo c'e`, e ritardarne lo sviluppo quando lo si sta
appunto acquisendo.  Le "scorciatoie" in produzione sono un'altra cosa,
purche` si _appoggino_ sul know-how del programmatore piuttosto
che non cercare di prenderne il posto.  Ma appunto per questo, queste
"scorciatoie buone" con l'apprendimento hanno poco a che fare.
Alex

mondo GUI sia in quello DB, allora, secondo me, le cose cambiano.
Hai ragione! Se intendiamo RAD per ciò che la'acronimo è
tool come VIM, UltraEdit, EditPlus e altre centinaia di
editor "a colori" di certo non fanno male...ma probabilmente
dato che per RAD si intende anche un ambiente come VB e
Delphi possono di certo far male....ma credo che la colpa in
primis sia del programmatore e poi dell'ambiente RAD.
Insomma prima bisogna imparare a programmare e poi imparare
ad utilizzare gli strumenti per facilitare la vita del
programmatore...ma non è detto che le cose non si possano
fare simultaneamente
--
Lawrence Oluyede
rhy...@myself.com


Su questo concordo pienamente!
Quello che sto sostenendo è che per imparare bene i concetti più
teorici-fondamentali(intendo proprio i primi passi ) vanno  benissimo
ambienti che ti aiutino molto, se pur nascondendo qualcosa, quando il
giovane e ardimentoso programmatore ha imparato sti benedetti concetti potrà
entrare nel merito e approfondire, provando a usare ambienti più complessi e
con meno aiuti o automatismi. Questo dal punto di vista didattico va
benissimo, è lo stesso procedimento che è stato adottato su di voi per
insegnarvi tutto ciò che sapete (o almeno che vi hanno insegnato a scuola).

Su questo concordo pienamente!
anche io ma quota nel modo giusto :)
--
Lawrence Oluyede
rhy...@myself.com

 insegnato a scuola).
Assolutamente no!  Forse alla VOSTRA generazione.  Alla MIA generazione,
a scuola, hanno insegnato ad esempio come si calcolano le radici quadrate
con carta e matita.  A mio parere, questa complicazione, peraltro di _puro_
interesse didattico, ci ha aiutato non poco a capire di cosa ci stavamo
occupando, rispetto alle generazioni per cui "calcolare la radice
quadrata" e` sinonimo di "toccare il tasto giusto sulla calcolatrice".
Lo stesso vale per le tabelle stampate di logaritmi e varie funzioni
trigonometriche, e persino i regoli calcolatori.
Una volta capiti e interiorizzati questi meccanismi, cioe` appunto DOPO
avere compiuto i primi passi, non importa piu` di tanto ritenerli, se
ci sono strumenti migliori.  *Nell'apprendimento*, invece, capire almeno
una volta i meccanismi fondamentali (per _poi_ lasciarli da parte per
passare a strumenti piu` comodi) e` decisamente preferibile.
Parlo di strumenti *concettuali*.  Non c'e` beneficio a fare usare (come
pure alle elementari a noi facevano usare) penne pennini ed inchiostro
invece della biro -- o Notepad invece di un editor decente.  Quelli
sono strumenti pragmatici, non concettuali.  Una calcolatrice (che fa i
conti al tuo posto) e un ambiente RAD (che genera codice al tuo posto)
sono invece strumenti magari comodissimi ma che scoraggiano dal capire
i meccanismi fondamentali nel momento migliore per capirli, cioe`
proprio nel corso dei "primi passi".
Alex