Hume (lenguaje de programación)

Hume es un lenguaje de programación funcional desarrollado en la Universidad de St Andrews y la Universidad Heriot-Watt en Escocia desde el año 2000. Su nombre es un acrónimo que significa "Entorno Unificado de Metaorden Superior" y un homenaje al filósofo del siglo XVIII David Hume . Está diseñado para sistemas embebidos de computación en tiempo real , con el objetivo de crear un diseño altamente abstracto que, a la vez, permita la extracción precisa de los costos de ejecución en tiempo y espacio. Esto garantiza que los programas ejecuten requisitos de tiempo y espacio limitados.

Hume combina ideas de programación funcional con ideas de autómatas de estados finitos . Los autómatas se utilizan para estructurar programas comunicantes en una serie de "cajas", donde cada caja asigna entradas a salidas de forma puramente funcional mediante la coincidencia de patrones de alto nivel. Su estructura se basa en una serie de niveles, cada uno de los cuales expone diferentes propiedades de la máquina.

Modelo de diseño

El diseño del lenguaje Hume busca mantener las propiedades y características esenciales requeridas por el dominio de los sistemas embebidos (especialmente para la gestión transparente del tiempo y el espacio), al tiempo que incorpora el mayor nivel de abstracción de programa posible. Su objetivo es abarcar aplicaciones que van desde microcontroladores sencillos hasta sistemas complejos en tiempo real, como los teléfonos inteligentes . Este ambicioso objetivo requiere la incorporación tanto de conceptos de bajo nivel, como el manejo de interrupciones , como de alto nivel, como la abstracción de estructuras de datos , entre otros. Dichos sistemas se programan de maneras muy diversas, pero el diseño del lenguaje debe adaptarse a estos requisitos tan variados.

Hume es un lenguaje de tres capas: una capa externa (estática) de declaración/ metaprogramación , una capa intermedia de coordinación que describe la disposición estática de los procesos dinámicos y los dispositivos asociados, y una capa interna que describe cada proceso como una asignación (dinámica) de patrones a expresiones. La capa interna no tiene estado y es puramente funcional.

En lugar de intentar aplicar la tecnología de modelado de costos y prueba de corrección a un marco de lenguaje existente, ya sea directamente o alterando un lenguaje más general (como con, por ejemplo, RTSJ ), el enfoque adoptado por los diseñadores de Hume es diseñar Hume de tal manera que se puedan construir modelos y pruebas formales con certeza. Hume está estructurado como una serie de niveles de lenguaje superpuestos, donde cada nivel agrega expresividad a la semántica de la expresión, pero o bien pierde alguna propiedad deseable o aumenta la dificultad técnica de proporcionar modelos formales de corrección/costo. ^{[ 1 ]}

Características

Las versiones del intérprete y del compilador difieren un poco.

El intérprete (demostrador de conceptos) admite excepciones por tiempo de espera y excepciones personalizadas.
El compilador admite limitaciones en el costo de la pila y el montón, pero las excepciones solo imprimen el nombre de la excepción.

El sistema de coordinación conecta las cajas siguiendo un estilo de programación de flujo de datos .

El lenguaje de expresiones es similar a Haskell .

El sistema de concurrencia de paso de mensajes recuerda los patrones de unión de JoCaml o los acordes de Do sostenido polifónicos , pero con todos los canales asíncronos.

El sistema incluye un planificador integrado que comprueba continuamente la coincidencia de patrones en todos los equipos, poniendo en espera aquellos que no pueden copiar las salidas a destinos de entrada ocupados.

Ejemplos

Máquina expendedora

data Coins = Nickel | Dime | Fake ; data Drinks = Coffee | Tea ; data Buttons = BCoffee | BTea | BCancel ;tipo Int = int 32 ;excepción EFakeCoin :: ( Int , string ) ;mostrar v = v como cadena ; caja café en ( moneda :: Monedas , botón :: Botones , valor :: Entero ) -- canales de entrada salida ( salida_bebida :: cadena , valor ' :: Entero , salida_reembolso :: cadena , mostrar :: cadena ) -- salidas con nombreDentro de 500 KB ( 400 B ) -- límite de costo del montón máximo (pila máxima) maneja EFakeCoin , TimeOut , HeapOverflow , StackOverflowcoincidencia -- * comodines para salidas no rellenas y entradas no consumidas ( mi_moneda , * , v ) {- ''equivalente a patrón de unión'': coin(mi_moneda) & value(v) -} -> let v ' = incrementCredit mi_moneda v en ( * , v ' , * , show v ' ) -- límite de tiempo (''dentro de x unidad de tiempo'') genera TimeOut () | ( * , BCoffee , v ) {- ''equivalente a patrón de unión'': button(BCoffee) & value(v) -} -> ( vender Café 10 v ) dentro de 30 s | ( * , BTea , v ) -> ( vender Té 5 v ) dentro de 30 s | ( * , BCancel , v ) -> let refund u = "Reembolso " ++ show u ++ " \n " en ( * , 0 , refund v , * )maneja EFakeCoin ( v , msg ) -> ( * , v , * , msg ) | TimeOut () -> ( * , * , * , "quizás el contenido se haya agotado, ¡llame al servicio!" ) | HeapOverflow () -> ( * , * , * , "error: se ha excedido el límite del montón" ) | StackOverflow () -> ( * , * , * , "error: se ha excedido el límite de la pila" ) ;incrementCredit coin v = case coin of Nickel -> v + 5 Dime -> v + 10 Fake -> raise EFakeCoin ( v , "moneda rechazada" ) ; vend drink cost v = if v >= cost then ( serve drink , v - cost , * , "tu bebida" ) else ( * , v , * , "falta dinero de " ++ show ( cost - v )) ; serve drink = case drink of Coffee -> "Café \n " Tea -> "Té \n " ; box control in ( c :: char ) out ( coin :: Coins , button :: Buttons ) match 'n' -> ( Nickel , * ) | 'd' -> ( Dime , * ) | 'f' -> ( Fake , * ) | 'c' -> ( * , BCoffee ) | 't' -> ( * , BTea ) | 'x' -> ( * , BCancel ) | _ -> ( * , * ) ; transmitir console_outp a "std_out" ; transmitir console_inp desde "std_in" ;-- flujo de datos cable café -- entradas (orígenes del canal) ( control . moneda , control . botón , café . valor ' inicialmente 0 ) -- -- destinos de salida ( consola_outp , café . valor , consola_outp , consola_outp ) ; cable control ( consola_inp ) ( café . moneda , café . botón ) ;

Referencias

^ Eekelen, Marko Van (2007). Tendencias en programación funcional . Libros de intelecto. pag. 198.ISBN 978-1-84150-176-5.

Lecturas adicionales

Patai, Gergely; Hanak, Peter (2007). "Programación funcional integrada en Hume" (PDF) . Archivado del original (PDF) el 23 de diciembre de 2016.

Enlaces externos

El sitio web del lenguaje de programación Hume
El Proyecto Hume en la Universidad Heriot-Watt
El proyecto EmBounded certifica el código con recursos limitados en Hume.
Hume y Multicore

[1] Eekelen, Marko Van (2007). Tendencias en programación funcional . Libros de intelecto. pag. 198.ISBN 978-1-84150-176-5.

[ 1 ]