Il giorno sabato 6 settembre 2014 00:45:46 UTC+2, G. ha scritto:
Uè, qua ci vuole una settimana per rispondere ad un messaggio così! :)
> > Bella sfida... se uno ha seguito un po' la vicenda negli ultimi anni non è che
> > si affiderebbe a VSI alla cieca. Cioè... *TU* lo faresti? Affidare un tuo nuovo
> > progetto alla piattaforma VSI+VMS?
>
> Attualmente no, perché anche se esiste VSI siamo ancora in una fase in cui è
> come se non esistesse, quindi le garanzie di HP non sono sufficienti. In un
> futuro chissà. Non sappiamo come potrà andare, anche se possiamo fare qualche
> ipotesi. Magari chiudono in fretta, magari sopravvivono per 20 anni come ha
> fatto Mentec, magari sfondano (nei limiti del possibile e delle proporzioni).
Mentec ha catalizzato un interesse molto forte in un settore in cui reali alternative non c'erano.
Tant'è che ma General Electric del Canada ricerca programmatori PDP11 fino al 2050.
Cioè non esistevano sistemi operativi RealTime per x86, o se esistevano non hanno avuto fortuna, o non erano comunque all'altezza.
Mentec non ha preso un cavallo mezzo morto, ma un purosangue un po' vecchiotto, con un parco clienti molto fidelizzato.
Per quello che si fa su VMS, oggi esistono alternative, e il parco clienti non so quanto sia così fidelizzato.
Voglio dire, la parentesi indiana del supporto era espressamente studiata per rovinare la reputazione di VMS.
Se ci fossero riusciti anche solo a metà...
> Se diventasse una soluzione possibile e rispondente alle mie necessità, perché
> no? Del resto c'è stato un tempo in cui Linux era solo un gadget da nerd e
> nessuno si sarebbe sognato di sceglierlo per qualcosa di serio: guarda ora com'è
> la situazione (e incidentalmente come stanno gli altri Unix)... :)
Linux è ancora nella sua parabola crescente, non si sa per quanto durerà questa fase ma ancora non è terminata.
Per VMS non si può proprio dire che sia nato adesso e con tante possibilità di crescere.
Quello che poteva fare lo ha fatto, il suo stato dell'arte lo ha già raggiunto, si può solo manterenere così com'è, magari lavorando sulle performance, non non credo sulle features.
> > Per fare un esempio che mi tange, ho molto codice scritto in un dialetto del
> > BASIC specifico (proprietario) di un software gestionale per il mercato
> > italiano. E' talmente raro che non figura neanche nella lista dei dialetti del
> > BASIC sulla Wikipedia :) Per essere un dialetto proprietario di un gestionale, è
> > anche troppo ben fatto: compila in bytecode (eseguibile solamente nel gestionale
> > che è la sua VM, per così dire) e ha un ottimo accesso alla base dati
> > proprietaria. Per il resto è pessimo: non strutturato, limitazioni all'accesso
> > alla memoria a 128k, e altre limitazioni peggiori. Quindi richiede al
> > programmatore 10 volte il tempo che ci vorrebbe a farlo con un altro strumento.
>
> Molto interessante (sul serio, non sono ironico). Ma dimmi un po', la VM su cosa
> gira (su quali sistemi operativi)? Ed è possibile scrivere programmi esterni
> alla VM che dialogano con i programmi Basic all'interno? E verso gli utenti che
> interfaccia ha? Da come l'hai descritto dev'essere un animale ben strano... :)
Dunque, è un gestionale che ha una ventina di anni o più, orientato alle PMI, che gira su Windows e su Linux (50%/50% del parco installato, i miei clienti sono tutti su Linux a parte le monutenze).
Inizialmente lavorava in telnet/ssh con interfaccia carattere, poi verso il 2000 il client è diventata un client leggero, potresti considerarlo un browser proprietario o un emulatore di terminale proprietario, che converte la matrice carattere in UI grafica.
I programmi che ho scritto in questo mezzo BASIC sono stampe che vanno oltre la logica di base del gestionale, oppure funzionalità aggiuntive.
E' possibile invocare l'esecuzione di questi programmi da linea di comando, e in questo modo girano in maniera "headless" con I/O su file.
> Cioè, tu cos'hai riscritto? Programmi che girano dentro la VM? Programmi esterni
> che funzionano senza la necessità della VM? Un po' e un po'?
>
> (Sì, ho capito che è una VM sui generis, ma l'ho chiamata così per semplicità.)
Per via dell'accesso alla base dati bisogna comunque che il programma giri sulla "VM", anche se qualcuno viene invocato da linea di comando (cioè, via cron).
Ho scritto delle stampe di analisi dati e altre stampe varie.
Il lavoro più grosso è un applicativo di produzione, perché il modulo disponibile per il programma è molto costoso e chi lo ha visto o usato lo considera molto farraginoso, quindi per me è stato necessario riscriverlo.
Un altro lavoro altrettanto voluminoso è un applicativo per la lavorazione delle carni, con tracciabilità.
Col mio programma si producono ottimi salumi in un noto salumificio vicino a Pesaro! :)
Entrambi gli applicativi lavorano nel client del gestionale, con un paio di procedure schedulate per la notte via cronjob per quanto riguarda le carni.
Entrambi questi due applicativi sono un mio grande cruccio.
Ho faticato molto a scriverli, ogni volta che ci devo mettere mano è faticosissimo (è un BASIC che non conosce programmazione strutturata... cioè si, un minimo, ma proprio minimo) e soprattutto se li avessi scritti con altri strumenti, sarei svincolato dal gestionale/VM per tutta una serie di vantaggi, sia tecnici, che commerciali.
Per questo, sto già riscrivendo la produzione, nel 2015, riscriverò la parte alimentare.
Per questo, ti dico con cognizione di causa, riscrivere con strumenti più nuovi è più facile che fare manutenzione sul vecchio.
Poi sicuramente esisteranno altri linguaggi migliori, su cui fare manutenzione sarà una passeggiata piacevole, ma la mia esperienza è questa...
> > Riscrivere... Un po' per volta prima di non avere alternative.
> > Chi ben comincia è a metà dell'opera! :)
>
> Sì, sempre partendo dall'assunto che qualunque cosa non giri su Unix sia morta.
Touché :)
Ma solo in parte.
Tu pensi che io ho in mente solo Linux, non è così.
> Dovresti farti un giretto su it.comp.as400 e luoghi simili (dove c'è gente molto
> più talebana di me, ma soprattutto molto più aggiornata sulle tecniche più
> recenti, web service compresi) e provare a dire che tu rifaresti tutto da capo
> (tra l'altro: in quale linguaggio? non ne abbiamo mai parlato) perché secondo te
> è tutta roba destinata a sparire più o meno entro breve. E poi aspettare... :D
Oh, si, ci ho discusso una volta di persona con un talebano degli AS400, per questo non voglio più parlare di AS400 :)
Il problema è che si, oggi si fa tutto su AS400, anche interfacce web, web services, ecc...
Ma *quando* il sistema è arrivato a fare questo?
E *quando* i programmatori hanno iniziato a sfruttare queste possibilità?
Voglio dire, vedo siti web di aziende del settore AS400 che pubblicizzano *oggi* come svecchiare gli applicativi dandogli una facciata web!
Comunque, nel frattempo, altri sistemi correvano molto veloce, e il gap è difficile da colmare.
Non basta compilare Apache2+PHP5 e farlo girare su System i per renderlo una piattaforma così appetibile.
> > Codice ancora in uso? Magari era codice vecchio già riscritto!
>
> Ritengo fosse codice ancora in uso, dato che era collegato agli utenti (cioè se
> facevi login con uno dei nomi utente originali ti ritrovavi dentro al menu
> principale dell'applicazione). Poi, visto che il tutto era dentro un vecchio VAX
> che avevamo recuperato, evidentemente lì non era più roba uso, ma non sappiamo
> se fu trasferita di peso su una macchina più nuova o se fu riscritta.
L'universo è grande! :)
> Quelle 1800 non sono procedure aggiuntive: sono parte integrante del pacchetto
> standard! E anche il secondo esempio che ho citato (quello quotato qui sopra)
> non è un pacchetto ad hoc per un'azienda specifica, ma è "semplicemente" un
> pacchetto italiano per società finanziarie e affini, utilizzato dai nomi più
> noti del settore (fra cui quelli che magari vedi nei centri commerciali quando
> compri qualcosa di costoso con un finanziamento). Poi non è detto che ognuna di
> queste società usi proprio tutte tutte le funzionalità, però volendo ci sono.
>
> E allo stesso modo quasi tutte le suddette società hanno le loro specifiche
> personalizzazioni, sia sotto forma di modifiche ai programmi standard, sia come
> programmi esterni chiamati dai programmi standard in punti e momenti precisi.
Ok, allora qui ci rimettiamo in linea.
1800 procedure per un pacchetto così non sono poche, probabilmente il giusto.
Il mio lavoro attuale consiste in 415 classi e 85 file vari (UI, reports) e fa solo magazzino e customer service, per cui 1800 procedure nel pacchetto standard di un sistema finanziario sono giuste, anzi siete stati parsimoniosi :)
Mi spaventava l'idea che, dato un pacchetto standard di N procedure, ci fossero 1800 personalizzazioni sopra quello! :)
> (Se vuoi dettagli più espliciti tipo nomi etc. te li do in privato, non qui.)
Se vuoi in privato ti faccio il nome del dialetto del BASIC :)
> > Si capisco l'esempio, almeno credo. Molti degli applicativi su cui ho messo mano
> > però richiedono al massimo dei cronjobs e qualche file shell.
>
> Forse non ho fatto gli esempi migliori, ma insomma, mi sembra banale dover dire
> che un pacchetto appena un po' complesso è comunque "tagliato addosso" a un
> certo sistema operativo. Anche cose sciocche come verificare l'esistenza di un
> file si fanno in modi diversissimi in base al sistema operativo sui si lavora.
Mmm...
Se lo scrivessi in Java, il metodo è lo stesso per qualunque sistema operativo.
Basta usare la stringa java.io.File.separator come separatore anziché presumere "/" o "\\"
Se proprio devo aggiungere qualcosa in testa al path in caso di Windows o altro, posso fare una serie di if-then-else controllando System.getProperty("
os.name")
Sono metodi standard in ogni classpath di tutte le JVM dalle specifiche anche più basse.
Ovviamente, basta che ci sia una JVM... ma quasi ovunque c'è, magari datata (come su VMS... 5.0...) però qualcosa c'è.
> Nelle 1800 procedure pensa a quante volte verrà creato un qualunque piccolo file
> temporaneo, con tutte le sue caratteristiche (quindi non un banale stream di
> byte, ma qualcosa di più simile a una tabella di database), il quale poi verrà
> riempito, utilizzato e infine svuotato o eliminato.
Anche creare un file temporaneo è una operazione che si astrae bene.
Sempre in Java, è una operazione "single line" :)
File temp = java.io.File.createTempFile("abc", ".temp");
"Creates an empty file in the default temporary-file directory"
Quindi la JVM sa quale è la directory temporanea, che eventualmente si può cambiare a runtime.
Ma è preferibile rimanere agnostici del S.O. e risparmiarsi ogni problema.
> Su sistemi diversi i file (le tabelle) si creano in modi diversi, quindi in un
> progetto di migrazione non solo si dovrebbero riscrivere tutte le 1800 procedure
> (ciascuna lunga anche varie decine se non centinaia di righe), ma pure tutte le
> descrizioni accessorie utilizzate da quelle procedure per creare i file: in
> fondo al messaggio ti allego un esempio di FDL (File Description Language) per
> VMS che crea un semplice file indicizzato con una sola chiave.
Vero, ma anche qui ci sono grandi possibilità di astrazione.
Bisognerebbe erigere un monumento enorme e indistruttibile nei secoli dei secoli, agli strumenti di persistenza degli oggetti.
Io sono particolarmente appassionato di JDO e in particolare dell'implementazione DataNucleus (open source,
http://www.datanucleus.org).
Scrivo le classi specificandole @PersistenceCapable(table="una-tabella-su-un-db-supportato")
Definisco quale campo è @Persistent o @NotPersistent
@PersistenceCapable(table="anagrafiche", detachable="true", identityType=IdentityType.APPLICATION)
@Version(strategy=VersionStrategy.VERSION_NUMBER)
public final class Anagrafiche {
@Persistent(primaryKey="true", valueStrategy=IdGeneratorStrategy.IDENTITY, nullValue=NullValue.EXCEPTION)
@Column(name="id")
@Unique
private long id;
public final long getId() {
return id;
}
public final void setId(long id) {
this.id = id;
}
@Persistent
@Column(name="nome")
private String nome;
public final String getNome() {
return nome;
}
public final void setNome(String nome) {
this.nome = nome;
}
...
}
Poi ad esempio posso persistere i dati così...
// PersistenceManagerFactory e PersistenceManager possono essere creati una volta sola e mantenuti
PersistenceManagerFactory pmf = JDOHelper.getPersistenceManagerFactory(props);
PersistenceManager pm = pmf.getPersistenceManager();
Anagrafica obj = new Anagrafica();
obj.setNome("Guybrush");
pm.makePersistent(obj); //
obj.id è valorizzato automaticamente con un seriale univoco, come specificato in Class
L'oggetto finisce nel DB, qualunque esso sia, uno JDBC capable, oppure XLS, XML, LDAP, ecc...
Se le tabelle non esistono... vengono create!!! :)
Tutto lo schema può essere migrato in automatico, cambiando nomi ai campi, aggiungendo colonne o rimuovendole, ecc...
Solo degrada le prestazioni e io preferisco farlo esplicitamente a mano, ma si fa anche in automatico.
> Hai presente il vecchio dBase III per DOS? Ecco, pensa a una cosa del genere, ma
> molto più potente, centralizzata e perfettamente integrata nel nocciolo del
> sistema operativo; non un prodotto a parte. I file FDL di VMS (o altri metodi
> altrove) servono per generare l'equivalente dei vecchi file .DBF di dBase III:
>
> $ CREATE <tuofile>.RMS /FDL=<tuofile>.FDL
Il metodo della "Persistenza degli oggetti" invece non è integrato con niente, non confligge con niente, non ha bisogno di tuning del SO (al limite dell'applicativo) ed è altamente portabile per sua natura.
> Avevo anche descritto i vari modi per ricevere i parametri con cui un programma
> viene chiamato, diversissimi fra i vari sistemi operativi (perché i sistemi
> operativi collaborano con i programmi in modi diversi per la raccolta parametri;
> Unix di fatto non collabora e il programma deve arrangiarsi da solo). Pensa a
> quante volte quei 1800 programmi (per non dire quegli altri 17mila) si chiamano
> e si passano e si restituiscono dei parametri. Ecco, ora porta tutto su un
> sistema che non ha lo stesso meccanismo, o che magari non ce l'ha affatto e che
> al massimo ti fornisce strutture primitive come argc e argv...
Si, quei 1800 programmi sono così da sempre e collaborano così da sempre...
Ma... passare ad un sistema di messaggistica?
Tipo MQ (anche quello di IBM :))
Oppure se i programmi trasportassero dati in POST via rete verso
http://server.remoto/un/web/service/
Se una volta programmi in linguaggi eterogenei dialogavano per command line, sullo stesso sistema, ora programmi eterogenei dialogano via web service su macchine anche su sistemi differenti (o anche verso la stessa macchina)
Per passare a tutt'altro settore, ti faccio questo esempio di REST API scritte veramente bene, anche ottimanete documentate.
Qualunque cosa stai scrivendo, ovunque giri, puoi esportare i dati su Wordpress mediante queste semplici chiamate web.
http://developer.wordpress.com/docs/api/
Tra l'altro, la documentazione mi sembra veramente ben fatta.
> > Per ottenere le caratteristiche di un device... il sistema operativo non
> > dovrebbe astrarre i device per l'uso agli umani? Se no a che serve? Tanto vale
> > scrivere l'applicativo per girare su "bare metal" :) E quali device? Stampanti?
> > Schede proprietari di acquisizione dati?
>
> Per esempio potrei aver bisogno di sapere se dentro una certa unità nastri c'è
> una cassetta piuttosto che un'altra, oppure potrei aver bisogno di sapere se sto
> dialogando con un terminale che può visualizzare 132 colonne invece di 80, o
> magari potrei voler sapere se su una certa stampante è stata caricata la carta
> normale anziché gli assegni, etc. etc. etc. Tutte operazioni di alto livello per
> le quali i device astraggono completamente l'hardware. Però appunto, in qualche
> modo bisogna interrogare il sistema e le sue astrazioni.
Mumble mumble...
Nastri... decisamente è una operazione a livello sistemistico, non a livello applicativo.
Permettimi, un applicativo, specialmente contabile, non deve neanche sapere dove finiscono i suoi dati, deve solo sapere che sono sempre disponibili.
Che ne vengano fatte delle copie, è la base della sicurezza dei dati.
E attualmente, con gli storage contemporanei, tutti i dati possono essere sempre disponibili, in repliche multiple, locali e remote.
Terminali... ok... i terminali... mi piacciono, ne ho una ventina in casa... ma... è ora di andare un po' avanti?
Carta nella stampante... ah questa è bella. :)
Allora ti prometto di cercare come posso farlo a livello astratto in Java.
Non ho le specifiche delle stampanti con doppia alimentazione carta+assegni, supporrò che si tratti di carta a4+a3 nelle mie ricerche.
Immagino che, alla peggio, si faccia una procedura C wrapped in Java class.
Ne avevo fatta una per leggere il seriale degli harddisk, era una piccola "protezione hardware".
Non garantisco che avrò la soluzione entro la prossima iterazione di questi messaggi, ma il problema mi è entrato in testa, e finché non lo risolvo non può uscire :)
Comunque questa problematica è una minima frazione di un sistema completo.
> Del resto anche fare 'cat /proc/<qualcosa>' è accedere a un'astrazione.
Credo sia il motivo per cui si inizia ad avere qualcosa di /proc anche sui BSD (l'ultima volta che ho avviato un NetBSD...)
> Per non dire delle astrazioni che fa VMS con gli application terminal virtuali:
> il programma crede di dialogare con un semplice "terminale" e invece sotto c'è
> una connessione TCP/IP (o LAT o DECnet) per la quale lui non deve assolutamente
> fare nulla di più che "aprire" il device e vedere se è pronto.
>
> La quale astrazione, tra l'altro, permette l'esecuzione dello stesso programma
> senza cambiare una virgola anche su trasporti diversissimi come TCP/IP vs. LAT.
Tirarsi il martello nei piedi così, nel 2014, è puro masochismo :)
Ma parto sempre dalla considerazione che i sistemi legacy, siano masochismo, per cui sono prevenuto.
Comunque il mondo sembra che sia andato avanti con TCP e non LAT :)
> > Il problema è sempre uscire dal sistema chiuso. Chi l'ha fatto prima è più
> > libero, gli altri dovranno liberarsi prima o poi.
>
> Sai, in questi giorni mi è capitato di pensare un po' a sta faccenda del sistema
> chiuso vs. sistema aperto, e sono abbastanza giunto alla conclusione, anche per
> esempio parlandone con altri su #retrocomputing (perché non vieni a trovarci?!),
Sarebbe bello... ma... il tempo... chissà forse una volta o due! :)
> che in realtà siano tutti sistemi chiusi e aperti nello stesso momento: già chi
> volesse migrare da uno Unix a un altro (penso anche solo a Linux e BSD) avrebbe
> un po' di lavoro da fare; chi poi volesse migrare fra altri sistemi (anche nel
> caso in cui si escluda Unix dall'affare) si troverebbe non poco in difficoltà.
> Quindi alla fine, visto che non c'è un vero e proprio leader indiscusso in tutti
> i settori, si tratta di tanti sistemi tutti più o meno incompatibili tra loro
> che si contendono vari mercati nei quali di volta in volta uno è leader e altri
> vanno un po' alla rincorsa, per un motivo o l'altro.
Come ti dicevo in precedenza, io credo che il S.O. diventerà un aspetto sempre più marginale in futuro.
1) L'applicativo client diventerà "il/un browser web"
2) Il server diventerà "quello che tiene i dati", qualunque sia il S.O., i server, i dischi, ecc...
E gli applicativi in mezzo.
Se hai degli applicativi scritti per sistemi molto astratti, sicuramente i punti 1 e 2 non sono un tuo problema.
Eliminare i problemi è per natura procurarsi un vantaggio :)
> > Un programma che usasse le READ e REWRITE del SO per ottenere dei record dati
> > dal SO deve essere un programma che gira in una shell. Capisco che scrivere un
> > programma in DCL non è come farlo in file batch del MSDOS, ma più simile ad un
> > programma BASH. Però... sarò stupido... ci sono sistemi migliori... anche fosse
> > solo per editing o debug... boh... evidentemente è un mio limite :)
>
> Più che altro mi sembra che tu abbia fatto una bella confusione. :P
Troppa teoria... preferisco i casi specifici... :)
> Nei programmi Basic della VM di cui dicevi, se tu volessi (per dire) leggere i
> dati di un cliente dall'anagrafica clienti, come faresti? useresti un'istruzione
> SQL oppure istruzioni Basic standard tipo READ o ancora altra roba non standard?
Roba non $tandard >:(
> Le istruzioni READ e REWRITE che dico io non sono "del sistema operativo", ma di
> almeno un paio di linguaggi di programmazione (Cobol e Fortran), perciò non
> hanno nulla a che fare con alcuna shell. Una differenza tra Unix e altri sistemi
> sta nel fatto che Unix di default non ti offre nulla di più di uno stream di
> byte, mentre altri (VMS, IBM, etc.) già nel filesystem hanno i concetti basilari
> di record e di indice, quindi è quasi come avere un database sempre disponibile:
> vedi a questo proposito il parallelo che facevo prima col venerabile dBase III.
Cobol e Fortran hanno compilatori cross-platform però.
Le librerie standard di READ e WRITE si occuperanno di chiedere al SO, che chiederà al filesystem, che chiederà al disco.
Non è che il programmatore deve fare tutto da solo :)
> (In C si userebbero fread(), fwrite(), fscanf(), fprintf(), etc. che però, di
> nuovo, non conoscono le astrazioni necessarie per manipolare record e indici.)
In C standard non credo ci siano, per quel che conosco io, solo con librerie esterne.
> Se migri a Unix un pacchetto che proviene da un sistema del genere, dovrai
> trovare un modo per fare le stesse cose senza quello specifico supporto da parte
> del sistema operativo, per esempio sostituendolo con un database SQL.
Se migro un pacchetto che legge e scrive i suoi dati direttamente su disco con fread() e fwrite() sto decisamente migrando qualcosa che va rifatto.
Senza dubbio, se accede ai dati così, o sono pochi pochi, oppure è il modo sbagliato.
Poi comunque fread() e fwrite() sono C standard, e il C puro è la cosa più cross-compilabile che esista.
> Io infatti scrivevo:
> | Dopodiché, parlando di dati si torna ai programmi: in VMS e nel mondo IBM c'è
> | il concetto di record già nel filesystem, in Unix no. Quindi ogni occorrenza
> | di un'istruzione READ o REWRITE a indici va sostituita con le equivalenti
> | istruzoni select o update SQL, le quali a loro volta richiedono un cursore,
> | quindi dovrai riguardarti praticamente ogni programma e aggiungere di sana
> | pianta tutto il codice necessario, compresa la valutazione dei codici di
> | ritorno tipo SQLCODE (e se c'è anche SQLSTATE) dopo ogni chiamata al database.
>
> Esempio in Cobol per leggere i dati del cliente AB1234:
>
> MOVE 'AB1234' TO CODICE-CLIENTE
> READ ANAGRAFICA INTO DATI-CLIENTE
> INVALID KEY
> DISPLAY 'Cliente non trovato'
> NOT INVALID KEY
> <qui elabora>
> END-READ.
> Oppure:
> MOVE 'AB1234' TO CODICE-CLIENTE
> READ ANAGRAFICA INTO DATI-CLIENTE
> IF FILE-STATUS = '00'
> <qui elabora>
> ELSE
> DISPLAY 'Errore lettura anagrafica: ', FILE-STATUS
> END-IF.
A gusto personale, il promo esempio è più raffinato :)
Ma la sensazione, è la stessa che mi da vedere il colosseo e i fori imperiali :)
O buona parte di casa mia, cioè tutta la parte dove tengo le retromacchine!
> ANAGRAFICA sarebbe il nome simbolico del file con l'anagrafica clienti, qualcosa
> di simile agli handle tipo '#1' del Basic. DATI-CLIENTE sarebbe il tracciato
> record del suddetto file e CODICE-CLIENTE sarebbe il campo chiave all'interno
> del tracciato, cioè uno dei tanti campi del medesimo.
>
> Un'ipotetica riscrittura per SQL (che però presuppone che "sotto" ci sia un
> database SQL e che il compilatore Cobol supporti in qualche modo le embedded
> query), e sottolineo riscrittura più che migrazione, potrebbe essere così:
>
> MOVE 'AB1234' TO CODICE-CLIENTE
> EXEC SQL
> SELECT <elenco campi>
> FROM <tabella angrafica>
> INTO <elenco variabili>
> WHERE CUST-CODE = :CODICE-CLIENTE
> END-EXEC
>
> EVALUATE SQLCODE
> WHEN < 0
> DISPLAY 'Errore: ', SQLCODE
> WHEN > 0
> DISPLAY 'Warning: ', SQLCODE
> WHEN OTHER
> <qui elabora>
> END-EVALUATE.
Si, per chi vuole ancora migrare verso SQL... legacy to legacy :)
Tu qui ipotizzi un percorso di migrazione passando per la base dati in SQL.
Io penso che la migrazione giusta sia mantenere inizialmente la base dati com'è, ma astrarre l'accesso ai dati mediante un connettore (RPC o web service che sia, anche se girasse in locale)
Una volta passati all'uso di un connettore, puoi migrare le parti che vuoi in maniera indipendente, per assurdo puoi tenere i dati come e dove sono e cambiare la piattaforma della logica applicativa.
Non conosco il COBOL e non so se implementare delle RPC o WS con il linguaggio standard sia fattibile.
Provo quindi a fare una ricerca su Google, e vedo che la strada dei Web Service comunque non sembra aliena al mondo IBM.
http://www.ibm.com/developerworks/systems/library/es-webservicesrpg/
> Al momento (?) GNU Cobol non supporta questo modo di procedere e usa la libreria
> Berkley DB di Oracle per fornire un accesso analogo a quello dei primi due
> esempi qui sopra, ma ancora non sufficiente per un vero uso pratico (tanto per
> dire: non supporta le cosiddette split keys e non c'è modo né di definire né di
> manipolare i dati al di fuori dei singoli programmi). È una mancanza paradossale
> perché costringe a servirsi di software di terze parti (es. Microfocus) che è
> proprietario, non del tutto standard, e molto costosamente a pagamento.
Se vivi in un ecosistema proprietario, lo hai scelto e ne paghi il prezzo... a Microfocus! :)
> Il file FDL di cui scrivevo prima serve per creare i file a indici a cui poi si
> accede come ho appena mostrato. In un'ipotetica migrazione, il file FDL si può
> anche analizzare ed elaborare con strumenti tipo awk, ma il problema rimane cosa
> fare delle informazioni che contiene, cioè come trasformarle in qualcosa di
> accessibile come un DB. Si potrebbe provare a trasformare ogni FDL in un CREATE
> TABLE, ma poi ci sarebbe da mettere pesantemente mano a tutti i programmi che
> utilizzavano il file per trasformarli in programmi SQL (vedi terzo esempio)...
Questo mix è complesso... Keep It Silly Stupid.
Astrarre l'accesso ai dati esponendo un web service e accedere ai dati consumando il web service è la strategia migliore.
Il client che accede al WS non sa, non deve sapere, ma soprattutto non gli interessa, in che modo vengano memorizzati i dati o recuperati dallo storage.
Gli interessa solo che i dati siano disponibili, il più velocemente possibile.
> Si fa tutto, eh. È sempre un problema di costi, sia in senso stretto (danaro)
> sia in senso lato (tempo e ritorno economico di un'operazione del genere) sia in
> senso tecnico (pensa a quanti bug si possono introdurre in 17mila (!) programmi
> Cobol riscritti a mano uno per uno come mostrato sopra).
>
> Considerando la complessità di certi programmi, credo che sia già una ipotesi
> impossibile quella di tradurre (leggi: rifare) un programma al giorno, ma
> facciamo finta che in media sia possibile (perché ci sono programmi più facili
> per i quali ci vuole meno tempo): 17mila programmi sono 17mila giorni, cioè 65
> anni (ipotizzando di lavorare cinque giorni la settimana, senza neppure una
> settimana di vacanza o di malattia). Se fai fare il lavoro a 10 persone gli anni
> diventano 6,5. Io per prudenza aumenterei la cifra di una buona metà perché i
> programmatori non lavorano come criceti nella ruota e in più c'è tutto il debug
> e il testing da fare; diciamo allora 9,75 anni. Se poi ci aggiungi che nel
> frattempo anche il software pre-migrazione continua ad evolvere e quindi gli
> devi "correre dietro", gli anni diventano più di 10 (e secondo me è una ipotesi
> molto più che rosea, quasi utopistica direi). Se poi fra i sorgenti c'è roba che
> contiene cose tipo EXEC CICS o EXEC DLI, allora ciao!
Riscrivere il vecchio, ok, ci vuole tempo.
Ma se scrivi qualcosa di nuovo, fallo con un sistema nuovo!
Che ne so, ogni nuovo report, con un sistema di reportistica nuovo, sicuramente orientato al web.
Le procedure più vecchie, quelle vecchie vecchie vecchie, andranno a morire prima o poi.
Voglio dire, se hai un programma di una finanziaria per calcolare un prestito come si faceva nel 2000, potresti anche rimuovere quel programma dal pacchetto prima o poi.
Un percorso di migrazione di un pacchetto così grande sicuramente deve partire da una analisi di quanto dell'esistente viene veramente utilizzato.
Dubito il 100% di 17k procedure/programmi.
Secondo applicahiamo le regole dell'analisi ABC al codice, dovrebbe essere:
A) 80% dell'uso viene fatto sul 20% delle procedure <--- prima necessità
B) 15% dell'uso viene fatto sul 30% delle procedure <--- secondo step
C) 5% dell'uso viene fatto sul restante 50% delle procedure <--- buttale via
> Quando arrivi dopo 10 anni ad aver rifatto tutto per Linux/Unix, nel frattempo
> chissà cosa c'è nel mondo, specie in quello di certa informatica che è sempre in
> evoluzione rapidissima (e tumultuosissima).
Vero, ma allo stesso tempo se non evolvi, resti ancora più indietro!
Ma poi, chi dice di riscrivere per Linux/Unix?
Io insisto sin dai primi messaggi, che il S.O. diventerà sempre più marginale nel tempo.
Potresti decidere di migrare ad esempio verso Amazon Elastic Cloud, Jelastic, Heroku, Google App Engine, IBM SoftLayer, HP Helion, Microsoft Azure... no, fai finta che questo non l'ho detto veramente :)
Oppure un sistema simile da fare girare su una propria server farm, come AppScale (compatibile Google App Engine), oppure OpenShift, OpenStack (è quello che vende anche HP dalla sua cloud), ecc...
> E questo vale per i soli sorgenti Cobol, che appunto da soli non servono a
> niente se non hanno i dati a cui accedere o i mezzi per interfacciarsi con gli
> utenti, dunque ci sono le altre decine di migliaia di sorgenti da prendere in
> considerazione. Puoi aggiungere altri programmatori al team principale, in modo
> da rimanere nei 10 anni, ma poi li devi anche pagare; la cosa incomincia a
> diventare un po' molto costosa se non sei l'IBM o quasi...
Voglio sperare che gli altri sorgenti siano più evolvibili in qualcosa di moderno...
> > > [Azienda che fa manutenzione su vecchi sistemi]
> Tu sei troppo sicuro delle tue idee. :P C'è chi li benedice perché costano meno
> dell'IBM e/o perché hanno roba che l'IBM dice di non tenere più (a meno che uno
> non abbia agganci molto in alto e/o sia pronto a sputare sangue dorato) e c'è
> chi dice che mai soldi furono meglio spesi (un atteggiamento un po' da copertina
> di Linus, ma tant'è)... Chi li maledice è una minoranza perché anche chi pensa
> che sia ora di cambiare si rivolge poi a loro per sostituire il vecchio S/36 con
> un AS/400, usato, ovviamente: vuoi che gente che ha ancora lì il 36 compri una
> macchina nuova? Figuriamoci! :)
Dicevano così anche di me quando facevo assistenza a terminali 3270 su macchine x86.
Eravamo più economici di altri perché in qualche fiera avevo messo mano su un cartone pieno di schede di emulazione 3270 ISA per 10 euro in tutto.
Mai soldi furono meglio spesi!
Così per qualche anno ho fatto buona assistenza, economica per il cliente, profiqua per me.
Poi hanno migrato tutto su ethernet, quindi il mio lavoro in quel mercato è diventato pari a zero.
Per fortuna non era il mio unico mercato!
> > Anche GNV è un po' un accrocchio :) Non credo (ma non posso verificarlo) che basti
> > prendere il codice e ricompilarlo su VMS ma anzi penso richieda pesanti patch.
>
> Decisamente esatto. Se cerchi fra i thread di comp.os.vms dovresti trovarne uno
> che descrive gli sfracelli che uno dei soliti frequentatori (non ricordo chi) ha
> dovuto fare per portare non so quale versione di wget su VMS. Il che non fa
> altro che confermare la mia tesi: se è difficile portare un solo programma che
> alla fine non fa altro che scrivere un po' su disco e sul terminale dell'utente
> e fare un po' di leggi/scrivi su un socket TCP, pensa cos'è portare un intero
> pacchetto complesso e ramificato che lavori intensamente con dati strutturati...
La mia tesi è che esiste tanto software utile, come wget.
Se wget non compila sul tuo sistema che fai?
Che alternative ci sono?
All'altezza di wget?
Oppure mi devo scrivere un tool analogo, da solo?
E quante altre librerie esistenti, funzionali, testate e pronte, mi resteranno precluse perché incompatibili?
Se wget o una qualche libreria può essere uno strumento marginale, sul fronte web server VMS non è messo meglio.
Vedo che l'ultima versione di Secure Web Server 2.2 (basata su Apache 2.0) per VMS è del febbraio 2011, con qualche patch a settembre 2012...
Primo, Apache 2.0 è al limite dell'obsoleto. Ook, funziona, questo basta, ma se così fosse non avrebbero sviluppato nuove versioni di Apache.
E poi sarà aggiornato per tutte le patch di sicurezza?
Di certo, se ho del software che gira su VMS ed eroga applicazioni o dati tramite SWS, farei bene a non dormire tranquillo...
Le mie alternative sono:
1) aspettare che VSI muova qualcosa (e c'è tanta roba da muovere), sempre che accada
2) muoversi verso altre soluzioni nello stesso tempo in cui VSI muova ipoteticamente qualcosa
Ai posteri l'ardua sentenza! :)
Ciao
gl