Hailstorm : A Statically-Typed, Purely Functional Language for IoT Applications

• URL: http://arxiv.org/abs/2105.13468v1
• Date: Thu, 27 May 2021 22:09:15 GMT
• Title: Hailstorm : A Statically-Typed, Purely Functional Language for IoT Applications
• Abstract summary: We present Hailstorm, a statically-typed, purely functional programming language. It supports features like higher-order functions, tail-recursion, and automatic memory management. We have evaluated Hailstorm by writing standard examples and running examples on the GRiSP embedded systems board.
• Score: 0.0
• License: http://creativecommons.org/licenses/by-nc-nd/4.0/
• Abstract: With the growing ubiquity of Internet of Things(IoT), more complex logic is being programmed on resource-constrained IoT devices, almost exclusively using the C programming language. While C provides low-level control over memory, it lacks a number of high-level programming abstractions such as higher-order functions, polymorphism, strong static typing, memory safety, and automatic memory management. We present Hailstorm, a statically-typed, purely functional programming language that attempts to address the above problem. It is a high-level programming language with a strict typing discipline. It supports features like higher-order functions, tail-recursion, and automatic memory management, to program IoT devices in a declarative manner. Applications running on these devices tend to be heavily dominated by I/O. Hailstorm tracks side effects likeI/O in its type system using resource types. This choice allowed us to explore the design of a purely functional standalone language, in an area where it is more common to embed a functional core in an imperative shell. The language borrows the combinators of arrowized FRP, but has discrete-time semantics. The design of the full set of combinators is work in progress, driven by examples. So far, we have evaluated Hailstorm by writing standard examples from the literature (earthquake detection, a railway crossing system and various other clocked systems), and also running examples on the GRiSP embedded systems board, through generation of Erlang.

Related papers

• Multi-Mode Debugging for FRP-Based Embedded Systems [0.0]
  Emfrp is a functional reactive programming language designed for small-scale embedded systems.<n>In practice, Emfrp programs are compiled into C and combined with platform-dependent input/output components written in C or C++.<n>This paper presents a multi-mode debug framework for Emfrp-based embedded applications.
  arXiv  Detail & Related papers  (2026-08-04T22:51:25Z)
• ATLAS: Automated Tree-based Language Analysis System for C and C++ source programs [1.0499611180329804]
  This paper introduces ATLAS, a Python-based Command-Line Interface (CLI) that generates statement-level Control Flow Graphs (CFG) and type-aware Data Flow Graphs (DFG)<n>ATLAS provides a practical foundation for improving downstream Software Engineering (SE) and machine-learning-based program understanding.
  arXiv  Detail & Related papers  (2025-12-14T01:11:11Z)
• Type-Constrained Code Generation with Language Models [51.03439021895432]
  Large language models (LLMs) produce uncompilable output because their next-token inference procedure does not model formal aspects of code. We introduce a type-constrained decoding approach that leverages type systems to guide code generation. Our approach reduces compilation errors by more than half and increases functional correctness in code synthesis, translation, and repair tasks.
  arXiv  Detail & Related papers  (2025-04-12T15:03:00Z)
• Context-Sensitive Abstract Interpretation of Dynamic Languages [0.0]
  There is a vast gap in the quality of IDE tooling between static languages like Java and dynamic languages like Python or JavaScript. Modern frameworks and libraries in these languages heavily use their dynamic capabilities to achieve the best ergonomics and readability. We propose an algorithm that can bridge this gap by statically analyzing dynamic metaprogramming and runtime in programs.
  arXiv  Detail & Related papers  (2024-01-31T17:45:05Z)
• SGLang: Efficient Execution of Structured Language Model Programs [38.7354780030876]
  We introduce SGLang, a system for efficient execution of complex language model programs. The runtime execution with novel optimizations like Radix for KVLang and compressed finite state machines for faster structured output decoding. Experiments that SG cache up to 6.4x higher throughput compared to state-of-the-art inference on various large language multi-modal models.
  arXiv  Detail & Related papers  (2023-12-12T09:34:27Z)
• Language Models are Universal Embedders [48.12992614723464]
  We show that pre-trained transformer decoders can embed universally when finetuned on limited English data. Our models achieve competitive performance on different embedding tasks by minimal training data. These results provide evidence of a promising path towards building powerful unified embedders.
  arXiv  Detail & Related papers  (2023-10-12T11:25:46Z)
• Instruct2Act: Mapping Multi-modality Instructions to Robotic Actions with Large Language Model [63.66204449776262]
  Instruct2Act is a framework that maps multi-modal instructions to sequential actions for robotic manipulation tasks. Our approach is adjustable and flexible in accommodating various instruction modalities and input types. Our zero-shot method outperformed many state-of-the-art learning-based policies in several tasks.
  arXiv  Detail & Related papers  (2023-05-18T17:59:49Z)
• PADL: Language-Directed Physics-Based Character Control [66.517142635815]
  We present PADL, which allows users to issue natural language commands for specifying high-level tasks and low-level skills that a character should perform. We show that our framework can be applied to effectively direct a simulated humanoid character to perform a diverse array of complex motor skills.
  arXiv  Detail & Related papers  (2023-01-31T18:59:22Z)
• QParallel: Explicit Parallelism for Programming Quantum Computers [62.10004571940546]
  We present a language extension for parallel quantum programming. QParallel removes ambiguities concerning parallelism in current quantum programming languages. We introduce a tool that guides programmers in the placement of parallel regions by identifying the subroutines that profit most from parallelization.
  arXiv  Detail & Related papers  (2022-10-07T16:35:16Z)
• Pre-Trained Language Models for Interactive Decision-Making [72.77825666035203]
  We describe a framework for imitation learning in which goals and observations are represented as a sequence of embeddings. We demonstrate that this framework enables effective generalization across different environments. For test tasks involving novel goals or novel scenes, initializing policies with language models improves task completion rates by 43.6%.
  arXiv  Detail & Related papers  (2022-02-03T18:55:52Z)
• Higher-Order Concurrency for Microcontrollers [0.0]
  microcontroller programs are typically written in a mixture of C and assembly using concurrent language extensions. We address this challenge by introducing $textttSenseVM$. Our VM is made portable via a low-level $textitbridge$ interface, built atop the embedded OS - Zephyr.
  arXiv  Detail & Related papers  (2021-08-17T15:11:03Z)
• Leveraging Language to Learn Program Abstractions and Search Heuristics [66.28391181268645]
  We introduce LAPS (Language for Abstraction and Program Search), a technique for using natural language annotations to guide joint learning of libraries and neurally-guided search models for synthesis. When integrated into a state-of-the-art library learning system (DreamCoder), LAPS produces higher-quality libraries and improves search efficiency and generalization.
  arXiv  Detail & Related papers  (2021-06-18T15:08:47Z)
• LazyTensor: combining eager execution with domain-specific compilers [0.0]
  LazyTensor is a technique to target domain compilers without sacrificing define-by-run ergonomics. Initially developed to support PyTorch on Cloud TPUs, along with a substantially shared implementation technique, has been used by Swift for specific accelerators.
  arXiv  Detail & Related papers  (2021-02-26T02:22:16Z)
• SCELMo: Source Code Embeddings from Language Models [33.673421734844474]
  We introduce a new set of deep contextualized word representations for computer programs based on language models. We show that even a low-dimensional embedding trained on a relatively small corpus of programs can improve a state-of-the-art machine learning system for bug detection.
  arXiv  Detail & Related papers  (2020-04-28T00:06:25Z)

This list is automatically generated from the titles and abstracts of the papers in this site.

This site does not guarantee the quality of this site (including all information) and is not responsible for any consequences.