Hume (llenguatge de programació)

De Viquipèdia
Dreceres ràpides: navegació, cerca

Hume (Higher-order Unified Meta-Environment) és un llenguatge de programació funcional i tipificació forta per a sistemes amb recursos limitats que incorpora en el llenguatge elements per assegurar l'execució acotada en temps i espai.

Hume incorpora concurrència per pas de missatges amb sincronització per encaix de patrons, de manera semblant al Join calculus de JoCaml.[1]

Cada autòmat (clàusula box) presenta una seqüència d'encaixos de patrons sobre una tupla de canals d'entrada. En comptes d'especificar els canals i valors com en altres implementacions del Join calculus, s'especifica un encaix de valors per tota la tupla d'entrada, indicant amb un asterisc els canals ignorats (no consumits).

A cada encaix, amb disponibilitat síncrona dels canals, s'associa un procés que retorna una tupla de sortida de missatges opcionals, especificant asterisc per als no generats.

La instrucció wire (cablejat) descriu els canals destinataris dels missatges de la tupla de sortida, així com la procedència dels missatges i inicialització de la tupla de canals d'entrada.

L'estat d'un autòmat queda en els canals realimentats amb sortides pròpies. L'estat del sistema és el del conjunt de bústies dels canals.

El planificador es basa en un bucle infinit d'avaluació d'autòmats blocant els que no puguin col·locar missatges de sortida a bústies ocupades.[2]

Incorpora excepcions a nivell d'autòmat i global per acotar els cicles en temps (de moment només va a l'intèrpret) i en espai (només al compilador) de l'allotjament dinàmic (HeapOverflow) i de sobreiximent de la pila (StackOverflow), a banda de poder definir excepcions pròpies.

Incorpora un llenguatge d'expressions funcional amb la sintaxi del Haskell però semàntica estricta (avaluació primerenca i ordenada dels operands) (">> Like Standard ML, Hume expressions follow a strict evaluation order"), amb suport de funcions d'ordre superior.

Incorpora un metallenguatge de macros/plantilles que permet generar rèpliques dels autòmats i de les connexions.

Hume ha estat desenvolupat a la Universitat de Saint Andrews, Escòcia. Amb el nom volen retre homenatge a David Hume filòsof escocès famós pel seu escepticisme que requeria reiterades proves i bons fonaments per arribar a donar crèdit a les formulacions.

Tantmateix és un treball en-procés, amb parts importants (temporitzadors, excepcions) pendents d'implementar en el compilador, malgrat que funcionin en part en l'intèrpret (més endarrerit en altres aspectes i pres com a demostrador de conceptes).

Capes del Hume[modifica | modifica el codi]

Segons el "Hume Report",[3] s'identifiquen una sèrie de nivells:

HW-Hume
una capa de descripció del maquinari capaç de descriure circuits, siguin síncrons o asíncrons, amb encaixos de patrons per a tuples de bits.
FSM-Hume
(FSM:màq. d'estats finits) un llenguatge hard/soft -- HW-Hume més funcions de primer ordre, més condicionals i definicions locals.
Template-Hume
un llenguatge per a la programació expressada en plantilles. -- FSM-Hume més funcions de primer ordre predefinides, polimorfisme i estructures de dades inductives sense incloure funcions definides per l'usuari.
PR-Hume
Template-Hume més funcions i estructures de dades definides per l'usuari.
Full-Hume
Un llenguatge Turing-complet: PR-Hume més recursió sense restriccions a funcions i estructures definides per l'usuari.

Exemples[modifica | modifica el codi]

Exemple per a l'intèrpret[modifica | modifica el codi]

 {- fitxer fibo-i.hume
 -}
 
 -- declaracions
 
 type Int = int 32 ;
 
 exception EIncreible :: (Int, string) ;
 exception EArgumentIlegal :: string ;
 
 -- funcions i símbols (avaluació primerenca)
 
 fibo :: Int -> Int ;
 
 fibo 0 = 1;
 fibo 1 = 1;
 fibo n = if n < 0 then raise EArgumentIlegal ("fibo: argument negatiu: " ++ (n as string))
  else fibo (n-1) + fibo (n-2);
 
 -- fibo acotat en temps
 
 bfibo :: Int -> Int ;
 bfibo n = (fibo n) within 10ms ; -- restricció a 10 ms. dispara Timeout () (només va a l'intèrpret)
 
 -- autòmat -- l'estat és a les bústies realimentades
 
 box fib
 in (n::integer, flag_in::integer) -- bústies d'entrada
 out (nextn::integer, flag_out::integer, result::(integer, integer, string)) -- sortides
 -- within 500KB (400KB) -- acotacions del munt d'allotjament de mem. dinàmica (ang: heap)
  -- i entre parent. de la pila (sols per la versió compilador)
 --  -- dispararien excepcions HeapOverflow, StackOverflow
 handles Timeout, EIncreible, EArgumentIlegal -- declaració excep. processades
 
 match -- (guardes -> accions) a l'estil dels llenguates CSP
 -- * : opcionalitat (sortides ignorades o entrades no consumides)
 
 -- ''patró_del_tipus_de_la_clàusula_in'' -> ''expressió_del_tipus_de_la_clàusula_out''
 
 (n, 0) -> if n >= 99 then raise EIncreible (n, " ates") -- atès (de atényer) vull dir (no admet accents)
  else (n+1, 0, (n, bfibo n, "\n"))
 | (n, 1) -> (n, 0, (n, *, " disparat Timeout\n"))
 | (n, 2) -> (n, 0, (n, *, " disparat Increible\n"))
 
 handle -- gestió d'excepcions (a l'intèrpret ; el compilador només imprimeix el nom de l'excepció)
 
 -- ''patró_de_l_excepció'' -> ''expressió_del_tipus_de_la_clàusula_out''
 
 Timeout () -> ( 0, 1, (*, *, "Atrapat temporitzacio, reiniciem n a 0\n"))
 | EIncreible (n, msg) -> (0, 2, (*, *, "Increible: " ++ (n as string) ++ msg ++ ", reiniciem n a 0\n"))
 | EArgumentIlegal msg -> (0, 0, (*, *, "ArgumentIlegal: " ++ msg ++ "\n"))
 ;
 
 -- connexions (cablejat de sortides a bústies d'entrada)
 
 stream output to "std_out";
 
 wire fib -- especificació d'orígens i destinacions
  -- qualificant els canals amb el nom del procés
 
 -- tupla corresp. a la clàusula ''in'' amb procedència dels canals d'entrada
 
 (fib.nextn initially 0, fib.flag_out initially 0)
 
 -- tupla corresp. a la clàusula ''out'' amb canals de destinació dels missatges de sortida
 
 (fib.n, fib.flag_in, output)
 ;

Interpretació[modifica | modifica el codi]

./hume fibo-i.hume

dóna com a resultat

0 1
1 1
2 2
3 3
4 5
5 8
6 13
7 21
8 34
9 55
10 89
11 144
12 233
Atrapat temporitzacio, reiniciem n a 0
0 disparat Timeout
0 1
1 1
2 2
3 3

Referències[modifica | modifica el codi]

  1. Join calculus tutorial
  2. Traduint el Hume a Java(anglès)
  3. document Hume Report de definició del llenguatge (anglès)

Enllaços externs[modifica | modifica el codi]