Hume (llenguatge de programació)
| Tipus | llenguatge de programació  |
|---|---|
| Data de creació | 2000 |
| Paradigma de programació | programació funcional |
Hume (Higher-order Unified Meta-Environment, ‘meta-entorn unificat d'ordre superior’) és un llenguatge de programació funcional i tipificació forta per a sistemes amb recursos limitats que incorpora elements per assegurar l'execució acotada en temps i espai.[1]
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.
Tanmateix é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).
Característiques
[modifica]
Hume incorpora concurrència per pas de missatges amb sincronització per encaix de patrons, de manera semblant al Join calculus de JoCaml.[2]
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.[3]
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.
Capes del Hume
[modifica]Segons el Hume Report,[4] 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àquina 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]Exemple per a l'intèrpret:
{- 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 llenguatges 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ó:
./hume fibo-i.hume
dona 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]- ↑ Eekelen, Marko van. Trends in Functional Programming (en anglès). Intellect, 2007. ISBN 978-1-84150-176-5.
- ↑ Join calculus tutorial
- ↑ Traduint el Hume a Java(anglès)
- ↑ document Hume Report de definició del llenguatge Arxivat 2009-02-28 a Wayback Machine. (anglès)
Enllaços externs
[modifica]- Hammond/Michaelson/Sun - Programant Sistemes Reactius en Hume (anglès)
- Univ. Heriot-Watt - El projecte Hume (anglès) Web amb les darreres versions del compilador de Hume
- K.Hammond - Is It Time for Real-Time Functional Programming? (anglès)
