Newsgroup: it.comp.lang.vo-clipper
Titolo: Organizzazione del lavoro

Ciao a tutti.
Ho il problema di dovermi organizzare un progetto in questi termini:
Ho una versione "base" di un programma e moltissime  personalizzazioni
diverse richiestemi da vari clienti.
Secondo Voi č meglio :
1) costruire un progetto per ogni personalizzazione (riportandomi quindi
anche tutto il codice comune con la versione base)
2) pensare alla compilazione condizionale ? (con la conseguenza di avere
una sfilza di #IFDEF / #ENDIF che non finisce piů).
Nel primo caso inoltre, se trovo un bug nel progetto base,  dovrei
andare a correggerlo anche su tutte le "enne" personalizzazioni fatte !
:o(
Insomma....č un casino.
Purtroppo non c'č qualcosa che assomigli al Rmake di Clipper anche
perchč ogni Project č blindato e non se ne possano gestire due o piů
contemporaneamente andando a pescare i moduli da una parte (vers. base)
e dall'altra (personalizzazioni)...
Come avete risolto  il problema ?
Buon lavoro.

 Buon lavoro.
L'ideale sarebbe avere un collaboratore il quale si occupi solamente
della normalizzazione del software!
Scherzi a parte la programmazione ad oggetti dovrebbe in un certo senso
obbligarti a scrivere bene il codice, nel senso di scrivere un codice
normalizzato che vada bene per ogni diversa versione in quanto la classe
o la definisci universale o tanto vale non programmare ad oggetti.
Io ti posso spiegare brevemente come ho risolto il tuo problema con il
Clipper 5.2 per clienti lontani da Padova (città dove abito e lavoro).
Ho creato un programma il quale va a leggere per qualsiasi cosa: 
form 		- definizione campi , picture, colore, riga, colonna 
databrowser	- colonne, campi, picture, colori, funzioni varie, ricalcoli
stampe		- posizione dei campi nel modulo di stampa
filtri di stampa e relazioni 
in file esterni che sono piccolissimi, velocissimi da leggere e
soprattutto velocissimi da spedire via modem 
al cliente con co/session, o via internet.
Questa strategia l'ho perseguita in quanto condizionato dalle
prestazioni dell'hardware dell'epoca (1990) e e (ad es. i modem se
viaggiavano a 1200 erano bravi!)
Prova a spedire un exe da 500 KB a quella velocità. Io invece
trasmettevo e trasmetto tutt'oggi solo pochi memo files come li chiamo
io:
.TES Testata
.REL relazioni
.VID videata
.SEL finsetra di scorrimento
.FIL filtro i stampa
.STA stampa
.MNU menu
etc. etc.
Il nucleo del programma contiene delle classi:
GES_TES    (Gestione archivio)
Selezione (finestra di scorrimento)
Edita     ( Scheda di editazione)
Dettaglio ( Editazione dettaglio)
STA_DOC   (Stampa documenti)
CAL_FAT   (Ricalcolo completo per ogni tipo di fatture, documenti,
ordini etc.)
Purtroppo ho sempre trovato una grande difficoltà a spiegare ad altri
softwaristi questa tecnica e a farla apprezzare, i miei clienti comunque
sono contenti del servizio che ho sempre dato e ancora oggi mi chiedono
implementazioni dei loro vecchi programmi.
Penso che passando al VO adotterò la stessa tecnica in quanto mi trovo
già tutto pronto per migrare dal DOS a WINDOWS.
L'unica cosa che non userò di questa tecnica sono le FORM in quanto
crearle come ti offre VO di fare è molto valido.
Se hai altre cose da chiedere non fai che contattarmi. CIAO!.
Marco Boschi
mbo...@hardservice.it


Visto che lavori con un linguaggio a oggetti, forse e' il caso di
pensare a oggetti.
Dovrei sapere meglio cosa intendi per 'personalizzazioni',. Comunque,
in generali puoi pensare a due soluzioni:
1. creare delle classi di base (es.: Cliente con i dati base come
codice, ragione sociale, indirizzo, ecc), e quindi creare delle
sottoclassi per le versioni personalizzate;
2. Creare l'applicazione base con le funzioni uguali per tutti, e poi
delle DLL separate con le sole personalizzazioni. In questo secondo
caso, usando la tecnica di caricamento dinamico delle DLL
(loadLibrary), puoi avere un unico eseguibile dando a ogni utente la
propria DLL 8che si chiamera' sempre nello stesso modo)
Sper di averti dato qualche idea
Ciao
Fabio
-----------------------------
Fabio Cresta
EDP Consultant & VO/Jasmine developer ITALY
President of Clipper/Visual Objects/Jasmine User Group Italy
e-mail: 
fcr...@tin.it
 
fcr...@windevs.com
web: 
http://www.windevs.com
------------------------------

Fabio, non ho la piu pallida idea di come si faccia a gestire una caricamento
dinamico di una dll  perchč non ho nessun esempio a supporto!!
Una volta caricata la dll con loadlibrary in una variabile di tipo PTR come
faccio a gestirmi classi e funzioni in essa contenute ???
Ciao e grazie


Ciao e grazie
Non e' una cosa spiegabile in due righe, comun que ci provo.
La LoadLibrary restituisce un puntatore alla DLL.
La prima cosa da fare (oobligatoria) e' chiamare una qualsiasi
funzione internal alla DLL (Nota: funzione, NON metodo). Io uso una
funzione Dummy che fa un return nil.
La chiamata a una funzione si fa con:
// Pointer alla DLL
ptrDll := LoadLibray("pippo.dll")
// pointer alla funzione nella DLL
FuncPtr := getProcAddress(ptrDLL, "Dummy)
// chiama la funzione.
Pcall(FuncPtr, <elenco parametri>))
Ovviamente le ultime due istruzioni sono quelle da usare tutte le
volte che devi chiara una Funzione nella DLL.
Per instanziare una classe, invece, si usa la funzione createInstance:
oClass := CreateInstance(#MyClass, <paramteri del metodso init)
da qui in poi si procede normalmente.
Spero ti serva almeno per fare delle prove
Ciao
