Newsgroup: it.comp.programmare
Titolo: GOAL & HAL/S

Ciao a tutti
La vedo dura cmq proviamo
Qualcuno di voi conosce i linguaggi di programmazione ad alto livello
GOAL e HAL/S
Il primo e utilizzato durante le seqenze di lancio dei missili
Il secondo per la gestione dei computer di bordo delle astronavi
Se qualcuno sa dove posso trovare documenti o magari anche l'inter鋯rete per
questi linguaggi me lo dica
Grazie Mille a tutti
Luca
----------------------------------------------------------------------------
------
Tutto quello che ho trovato su GOAL e questo
GOAL is a high-level language that uses the terminology of test engineers to
write tests and procedures to certify that a Shuttle vehicle is ready for
launch. When the first automated preflight checkout programs were written in
the mid-1960s, Marshall Space Flight Center originated ATOLL, a special
high-level language for use in preparing test procedures. GOAL superseded
that language in the early 1970s.
Fig. III-1 is a segment of a GOAL program used to safe various spacecraft
systems if a NOGO condition causes the final countdown to be suspended. Note
that names of data items held in common in the Launch Processing System
appear within brackets, <>, and data local to the program is named between
parentheses, (). Statements familiar to high-level programming language
users, such as READ, IF-THEN-ELSE, and LET, have similar functions in GOAL.
Additional statements, such as VERIFY, make it possible for the engineers to
test whether valves or switches are set properly or whether a value is
within a specified range. SET permits switches to be activated.
Although seemingly highly structured, GOAL allows engineers to frequently
repeat the most common error of their peers using FORTRAN: excessive
unconditional jumps such as the one on line 2030, making it difficult for
someone to read and modify the program. Whereas in older versions of FORTRAN
it was necessary to create structures such as those found between lines 2026
and 2039 to handle multiple statements in the THEN and ELSE blocks of a
selection structure, later versions of the language and GOAL itself (see
lines 1980 through 1988) permit multiple lines of code to be included within
the blocks. Therefore, the GOTO statements are often used less to create
structure than to provide a "quick fix" when the logic of the program needs
expanding.
--
內躬偕爻,虜,齯滌`偕爻,虜,齯滌`偕爻爻,虜,齯滌`偕爻,虜,內躬偕爻,虜,齯滌`偕爻,
Luca Carenzo
E-mail 
lu...@tin.it
 
peg...@bbs.olografix.org
Web 
www.alligator4x4.n3.net
ICQ# 81706942
Scout TAG Vercelli 5 (VC) (AGESCI) Novizio - Camoscio Instancabile
內躬偕爻,虜,齯滌`偕爻,虜,齯滌`偕爻爻,虜,齯滌`偕爻,虜,內躬偕爻,虜,齯滌`偕爻,

 questi linguaggi me lo dica
Ti dico quello che so io. Se poi la cosa ti serve per un motivo serio
posso provare a chiedere a della gente che conosco e che di mestiere
sviluppa (guarda caso) sistemi di bordo e di terra in ambito
aerospaziale. Però prima di farlo devi convincermi che c'è un motivo
serio, dato che ci tengo a non giocare certe carte se non per qualche
cosa che vale la pena. Comunque non è detto che possano poi aiutarmi/ci.
HAL/S
E' un linguaggio compilato. Primissime idee circa 35 anni fa (anni
sessanta, periodo Apollo), ma "vivo" soprattutto negli anni 70 (sviluppo
dello Shuttle). Le ultime pubblicazioni in cui se ne parla che io sappia
risalgono agli anni 70 o al massimo inizio anni 80. Praticamente è morto
ed è stato sostituito del tutto da ADA. La NASA ha più volte chiesto che
certi progetti fossero sviluppati in HAL/S, ma la richiesta è stata di
fatto respinta dai tecnici. In altre parole: loro volevano HAL/S per
motivi principalmente politici, all'atto tecnico/pratico ADA è meglio e
quindi la politica se la sono infilata. Non mi risulta che ci siano
progetti in corso che lo usano. Non mi risulta che ci siano neppure
progetti vecchi che lo hanno usato con due illustri eccezioni:
-) il sistem di bordo dello Shuttle
-) parte del sistema di volo di Galileo
Il programma degli Space Shuttle è piuttosto famoso. L'idea risale alla
fine degli anni 50 ma non fu studiata seriamente se non dopo i vari
Apollo. Il lancio ufficiale del progetto avvenne all'inizio degli anni
70 (presidente Nixon, se non mi sono fumato troppa roba). Il lancio del
primo veicolo lo ricordo: aprile 1981.
Galileo è un sistema composto da due oggetti: un orbiter e una sonda. La
missione fu progettata negli anni 80, il lancio avvenne alla fine degli
anni 80. La rotta prevedeva un viaggio verso la zona centrale del
sistema solare per sfruttare l'attrazione di venere come trampolino
verso la terra e quindi un doppio incontro con la terra. Come risultato
finale del balletto una accelerazione sufficiente a portare il tutto
fino a Giove (da raggiungere verso la metà degli anni 90, se non erro)
che era l'obbiettivo principale della missione (che ovviamente aveva
anche obbiettivi secondari relativi allo studio di Venere, della Terra,
della Luna e della fascia asteroidale. Galileo divenne famosa perchè
(per pura coincidenza) permise di osservare abbastanza bene lo schianto
di una cometa su Giove (a metà anni 90 se non erro, comunque parecchio
prima che Galileo raggiungesse Giove).
Non ho la minima idea di dove potresti trovare un compilatore per HAL/S
ne su che piattaforme girerebbe (suppongo non PC) e che piattaforme
supporterebbe come target dello sviluppo (certo non PC).
A che ti servirebbe? Sicuro che non ti convenga ADA?
GOAL
Non è un linguaggio di programmazione. E' un linguaggio per la specifica
di sistemi di TEST. E' stato sviluppato specificatamente per il progetto
Shuttle. E' ancora in uso. Non viene usato come dici tu durante le
sequenze di lancio dei missili ma specificatamente durante le sequenze
di pre-lancio degli Shuttle. Non ha che io sappia nessun altro utilizzo.
Lo scopo sarebbe quello di tradurre i documenti di specifica delle
sequenze di test (e soprattutto delle sequenze di test da eseguire in
risposta ad una situazione di NO-GO in fase di prelancio) in un sistema
che le esegue e di cui sia matematicamente possibile dimostrare che
quello che fa il sistema è quello che c'è scritto nelle specifiche dello
stesso. L'idea è di scrivere un linguaggio (GOAL, appunto) che fosse ad
un livello così alto che i sorgenti potessero essere gli stessi
documenti di specifica. Naturalmente non è proprio così ma quasi. In
pratica la base del linguaggio è lo stesso formalismo che era già in uso
fra gli ingegneri e che veniva usato nella stesura delle specifiche (la
base, il che significa che il documento di specifica non è esattamente
la stessa cosa del sorgente, ma quasi).
A che ti servirebbe? In pratica a meno che tu non debba lanciare uno
Shuttle non te ne fai nulla! In ogni caso non credo che esistano
interpreti del linguaggio se non quello sviluppato proprio per il
sistema della NASA (tra l'altro parte del sistema si trova a bordo dello
shuttle, per cui se non hai uno shuttle in garage comunque non lo puoi
far girare!!).
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

 -) il sistem di bordo dello Shuttle
Ma HAL/S  non era quello con cui hanno scritto il programma che gestiva il
computer dell apollo?
Per quanto riguarda GOAL invece sono piu interessato, da quanto mi hai detto
tu eè ancora in uso ( dai tempi dell apollo)
e si usa nella fase di pre-lancio per la  verifica che tutte le attivita
siano attive e funzionati
(Es. da lo status del sistema criogenico, nel caso qualcosa sia fuori range
da un NO GO per il volo giusto?)
E da quanto ho capito interagisce direttamente con il sistema informatico
dello shuttle e tutti i sensori che ha installati
Domanda, GOAL gestisce anche il conto alla rovescia?
Grazie di tutto
Luca CArenzo
Andrea Ferro <And...@UrkaDVD.it> wrote in message
iAAG7.610$ec5....@nreader1.kpnqwest.net...


GOAL SOFTWARE DEBUG GOODY BOOK
    UPDATED: 01/30/95
    I.    GOAL DEBUG AIDS           REFERENCE KSC-LPS-OP-033-1 FOR DETAILS
    A.  TO STOP A PROGRAM AT AN ISN OR STEP NUMBER PERFORM THE FOLLOWING
STEPS:
        1. HOME CMD KEY - PRESS
        2. PSTP,mainline rum  ,next level rum  ,XXX
            XXX = SYYY TO STOP AT A GIVEN STEP NUMBER
            XXX = YYY  TO STOP AT A GIVEN ISN
           EXAMPLES
            PSTP,SAS10,SAS18,S200
            PSTP,,,300
        3. XMIT CMD KEY - PRESS   (NOTE: EXECUTION STOPS BEFORE EXECUTING
THAT STEP)
    B.  TO CANCEL A PSTP PERFORM THE FOLLOWING STEPS:
        1. HOME CMD KEY - PRESS
        2. PSTP,mainline rum  ,next level rum  ,0
           EXAMPLES
            PSTP,SAS10,SAS18,0
            PSTP,,,0
        3. XMIT CMD KEY - PRESS
    C. TO HAVE A PROGRAM BRANCH TO AN ISN OR STEP NUMBER PERFORM THE
FOLLOWING STEPS:
       1. THE PROGRAM MUST BE IN THE STOP MODE. DO THIS BY PERFORMING PART A
          ABOVE OR BY PRESSING THE STOP/STEP KEY.
       2. GOTO,mainline rum  ,next level rum  ,XXX
           XXX = SYYY TO STOP AT A GIVEN STEP NUMBER
           XXX = YYY  TO STOP AT A GIVEN ISN
          EXAMPLES
           GOTO,SAS10,SAS18,S200
           GOTO,,,341
       3. XMIT CMD KEY - PRESS
       4. RESUME PGM KEY - PRESS
    D. TO STATUS AN INTERNAL VARIABLE IN A PROGRAM PERFORM THE FOLLOWING
STEPS:
       1. HOME CMD KEY - PRESS
       2. S IV,mainline rum  ,next level rum  ,internal name,row  ,col
            NOTE: ROW CAN BE SPECIFIED FOR LISTS OR TABLES. IF LEFT OFF THE
                  ENTIRE LIST OR TABLE COLUMN WILL BE DISPLAYED.
                  COLUMN MUST BE SPECIFIED FOR TABLES. IF ROW IS LEFT OFF
THE
                  ENTIRE COLUMN IS DISPLAYED.
          EXAMPLES
           S IV,SAS25,VWS14,POINT       (DISPLAYS THE VALUE OF POINT)
           S IV,,,VWS14,POINT           (          "                )
           S IV,,VAS59,GPCPWR,1        (DISPLAYS VALUE IN THE FIRST ENTRY OF
LIST)
           S IV,,,FAILTABLE,,2    (DISPLAYS VALUES OF THE ENTIRE SECOND
COLUMN)
       3. XMIT CMD KEY - PRESS
            NOTE: DATA IS DISPLAYED TO PAGE-A, NEXT AVAILABLE LINE.
    E. TO CHANGE AN INTERNAL VARIABLE IN A PROGRAM PERFORM THE FOLLOWING
STEPS:
       1. HOME CMD KEY - PRESS
       2. C IV,mainline rum  ,next level rum  ,internal name,row  ,col
value
            NOTE: ROW CAN BE SPECIFIED FOR LISTS OR TABLES. IF LEFT OFF THE
                  ENTIRE LIST OR TABLE COLUMN WILL BE ASSIGNED THE VALUE
SPECIFIED.
                  COLUMN MUST BE SPECIFIED FOR TABLES. IF ROW IS LEFT OFF
THE
                  ENTIRE COLUMN IS ASSIGNED THE VALUE SPECIFIED.
          EXAMPLES
           C IV,SAS25,VWS14,PRINT OFF
           C IV,,VAS97,MAJFSP  1A
           C IV,,,MODE,3 ON
       3. XMIT CMD KEY - PRESS
    F. TO GET A TRACE OF A PROGRAM PERFORM THE FOLLOWING STEPS:
       1. HOME CMD KEY - PRESS
       2. A TR,pgm rum  ,,,location
          EXAMPLES
           A TR,,ALL,P         (WILL PRINT ALL STMNTS EXECUTED TO THE PDR
AND P/P)
           A TR,SKB05          (WILL RECORD STMNTS EXECUTED TO PDR FOR
RETRIEVAL)
           A TR                (WILL RECORD STMNTS EXECUTED IN THAT
CONCURRENCY.
                                MUST PERFORM $SPGLT TO GET A PRINTOUT.)
                                INCLUDING LOWER LEVEL PGMS THAT ARE CALLED.
MUST
                                PERFORM $SPGLT TO GET A PRINTOUT.)
       3. XMIT CMD KEY - PRESS
    G. TO STOP A TRACE OF A PROGRAM PERFORM THE FOLLOWING STEPS:
       1. HOME CMD KEY - PRESS
       2. I TR,pgm rum          (',pgm rum  ' IS OPTIONAL. WILL ONLY TERM
THE TRACE
                                 RUNNING IN THAT CONCURRENCY IF OMMITTED.)
       3. XMIT CMD KEY - PRESS
    H. TO GET A STATUS OF A PROGRAM PERFORM THE FOLLOWING STEPS:
       1. HOME CMD KEY - PRESS
       2. $STAT      - GIVES YOU A STATUS OF THE PROGRAM IN THAT CONCURRENCY
          $STAT,,,M  - GIVES YOU A STATUS OF ALL CONCURRENCIES RUNNING
       3. PERF PGM KEY - PRESS
    I. TO RETRIEVE A GOAL TRACE PERFORM THE FOLLOWING STEPS:
       1.  HOME CMD KEY - PRESS
       2.  $SPRDR $SPGLT
       3.  PERF PGM KEY - PRESS
       4.  MOVE CURSOR TO SGT = AND ENTER START GMT (ddd:hhmm/ss.msmsms)
       5.  XMIT RESP KEY - PRESS
       6.  MOVE CURSOR TO EGT = AND ENTER END GMT   (ddd:hhmm/ss.msmsms)
       7.  XMIT RESP KEY - PRESS
       8.  MOVE CURSOR TO CPU = AND ENTER CONSOLE   (CPU = 'C11' , 'C12' ,
ETC)
       9.  XMIT RESP KEY - PRESS
       10. MOVE CURSOR TO CON = AND ENTER CONCURRENCY  (OPTIONAL '1' - '6'
OR 'ALL')
       11. XMIT RESP KEY - PRESS
       12. MOVE CURSOR TO PGM = AND ENTER PROGRAM      (OPTIONAL)
       13. XMIT RESP KEY - PRESS

 Domanda, GOAL gestisce anche il conto alla rovescia?
Direttamente no di sicuro. Ripeto: GOAL è un sistema di specifica e
coordinamento dei test. Non è un sistema per sviluppare i circuiti o i
SW che fanno i test ma uno che li fa funzionare. Quindi indirettamente
agisce sicuramente sul sistema che gestisce il conto, ma non è la stessa
cosa che dire che lui gestisce il conto. Inoltre il conto alla rovescia
credo sia ancora quasi manuale. Mi pare che si fermi in automatico solo
ad alcuni valori se ci sono dei NO-GO pendenti di (ad un dato valore di
conto un certo insieme di cose deve essere risolto a OK-GO altrimenti si
ferma). Inoltre credo si fermi automatico se c'è un passaggio da OK-GO a
NO-GO di un sottoinsieme che doveva essere pronto entro un tempo
superiore a quello attuale.
Nota però che ci sono casi in cui uno stato di NO-GO che non è ancora
critico (nel senso che è previsto debba risolvere in OK-GO entro,
diciamo, la successiva mezz'ora) porta ad uno stop manuale del conto
alla rovescia (perchè i tecnici dicono semplicemente che non ce la
faranno entro mezzora). Questo dovrebbe di fatto essere il caso più
frequente di stop del conto.
Nota anche che ci sono problemi (ovviamente secondari) che se si
presentano a -10 minuti provocano un NO-GO ma che se si presentano a -20
secondi non implicano un passaggio a NO-GO.
In altre parole: le mie info sono molto frammentarie, comunque il tutto
è un casino pazzesco e infine non mi pare che la cosa sia importante se
non per curiosità morbose (a meno che non lavori a Huston, ma in questo
caso sai anche le risposte o a chi chiedere!!).
Ultima cosa: quando relichi (quoti) non lasciare tutto il messaggio
originale in fondo alla tua replica. Soprattutto se è lungo.


 puoi dare una delucidazione)
E' un colossale linguaggio di programmazione (credevate che il C++ fosse 
troppo complesso? vi sbagliavate) con (attenzione chè probabilmente le 
sto sparando grosse, se esagero qualcuno mi abbatta): 1) supporto nativo 
(a livello di linguaggio, nemmeno di librerie) per la gestione di task 
concorrenti e per la comunicazione inter-processo, 2) type-safety 
(comunque aggirabile in una quantità di modi diversi), 3) programmazione 
ad oggetti, e 4) più costrutti sintattici di quanti una mente umana ne 
possa ricordare. Esistono compilatori per tutti i maggiori sistemi 
operativi. Per qualche ragione che mi è sempre sfuggita, è 
particolarmente amato dall'esercito americano

 wrote in message
news:Xns9155BC63B1C...@127.0.0.1...

ROTFL
La tua descrizione fa ridere ma è sostanzialmente corretta.
Riguardo al motivo per cui piace all'esercito (e non solo) credo che
basti questo: a parità di esperienza, sviluppando un sistema complesso,
un programmatore ADA, rispetto ad un programamtore C/C++, commette circa
il 70% di errori in meno. E più aumenta l'esperienza meglio è (un
programmatore ADA con 10 anni di esperienza commette oltre il 90% di
errori in meno di un programmatore C/C++ con la stessa esperienza).
Statisctiche, ovviamente, perchè esistono programmatori ADA che
sbagliano una riga su due e programmatori C++ che non sbagliano poi
molto. Ma alla fine, dato il costo di un sistema d'arma moderno, sapere
che il SW di bordo lo hanno sviluppato in ADA e non in C++ rende
tranquilli (o meglio, meno nervosi).


errori in meno di un programmatore C/C++ con la stessa esperienza).
E perché non si è diffuso anche al di fuori dell'esercito in campi in
cui potrebbe comunque interessare una certa sicurezza?
-- 
                    Marco Barisione (ICQ 84277092)
Se sei interessato alla creazione di it.comp.lang (per i linguaggi di
programmazione senza un gruppo apposito e per i confronti fra i
linguaggi) partecipa alla discussione sul manifesto su it.news.gruppi.

 cui potrebbe comunque interessare una certa sicurezza?
Si è diffuso, infatti. Non solo in ambito militare e aerospaziale ma
anche in ambito medico e di sistemi di life-support.
La diffusione è limitata principalmente da questi fattori:
1) ci sono pochi che lo conoscono bene
2) appena impari a conoscerlo bene, ti assumono con un ottimo stipendio
in ambienti militar-aerospaziali il che rende la 1 perpetua
3) fino a pochi anni fa (non so, forse ancora) un compilatore Ada
costava un occhio della testa e quindi non era (è?) alla portata di
molte aziende (per non parlare di privati).
