Lisp Dialect Research Articles

Exploring the Integration of Lisp into a Modern Reinforcement Learning Project Through the Use of Hy

This paper explores the usage of Lisp in a small modern Reinforcement Learning (RL) project. The Lisp dialect, Hy programming language, is used to incorporate the traditional libraries and packages in up-to-date workflows. This project is centered around the usage of NetHack for RL. The MiniHack sandbox framework and NetHack Learning Environment (NLE) are used to create custom training/testing environments and tasks. The MiniHack sandbox framework creates a simple level editor and creation interface for use in the training and evaluation process of the agent. NLE is chosen as the working environment. For the agent model, this project adopts Torchbeast’s PolyBeast, a PyTorch implementation of the IMPALA architecture. The usage of Hy within this project is forefront, and so it is implemented as much as possible to accomplish the tasks.

The SOF Programming Paradigm

Out of the four main programming paradigms, it is widely considered that functional programming is the most promising. The programming languages that implement the functional paradigm generally do so either in a pure manner, such as Haskell, or by providing a multi-paradigm programming solution, such as most Lisp dialects, in order to allow side effects, which are proscribed under the former (pure) model. Nevertheless, tracking the execution steps of such a functional program remains challenging for the programmer. In this paper, the author addresses this issue by proposing a novel programming paradigm that combines the imperative programming approach based on a sequence of instructions with the pure function approach of functional programming, the objective being to retain the advantages of both strategies. This proposal is named “sequence of functions” (SOF), and its applicability and novelty are shown hereinafter throughout various examples and experiments.

A history of Clojure

Clojure was designed to be a general-purpose, practical functional language, suitable for use by professionals wherever its host language, e.g., Java, would be. Initially designed in 2005 and released in 2007, Clojure is a dialect of Lisp, but is not a direct descendant of any prior Lisp. It complements programming with pure functions of immutable data with concurrency-safe state management constructs that support writing correct multithreaded programs without the complexity of mutex locks. Clojure is intentionally hosted, in that it compiles to and runs on the runtime of another language, such as the JVM. This is more than an implementation strategy; numerous features ensure that programs written in Clojure can leverage and interoperate with the libraries of the host language directly and efficiently. In spite of combining two (at the time) rather unpopular ideas, functional programming and Lisp, Clojure has since seen adoption in industries as diverse as finance, climate science, retail, databases, analytics, publishing, healthcare, advertising and genomics, and by consultancies and startups worldwide, much to the career-altering surprise of its author. Most of the ideas in Clojure were not novel, but their combination puts Clojure in a unique spot in language design (functional, hosted, Lisp). This paper recounts the motivation behind the initial development of Clojure and the rationale for various design decisions and language constructs. It then covers its evolution subsequent to release and adoption.

Evolution of Emacs Lisp

While Emacs proponents largely agree that it is the world’s greatest text editor, it is almost as much a Lisp machine disguised as an editor. Indeed, one of its chief appeals is that it is programmable via its own programming language. Emacs Lisp is a Lisp in the classic tradition. In this article, we present the history of this language over its more than 30 years of evolution. Its core has remained remarkably stable since its inception in 1985, in large part to preserve compatibility with the many third-party packages providing a multitude of extensions. Still, Emacs Lisp has evolved and continues to do so. Important aspects of Emacs Lisp have been shaped by concrete requirements of the editor it supports as well as implementation constraints. These requirements led to the choice of a Lisp dialect as Emacs’s language in the first place, specifically its simplicity and dynamic nature: Loading additional Emacs packages or changing the ones in place occurs frequently, and having to restart the editor in order to re-compile or re-link the code would be unacceptable. Fulfilling this requirement in a more static language would have been difficult at best. One of Lisp’s chief characteristics is its malleability through its uniform syntax and the use of macros. This has allowed the language to evolve much more rapidly and substantively than the evolution of its core would suggest, by letting Emacs packages provide new surface syntax alongside new functions. In particular, Emacs Lisp can be customized to look much like Common Lisp, and additional packages provide multiple-dispatch object systems, legible regular expressions, programmable pattern-matching constructs, generalized variables, and more. Still, the core has also evolved, albeit slowly. Most notably, it acquired support for lexical scoping. The timeline of Emacs Lisp development is closely tied to the projects and people who have shaped it over the years: We document Emacs Lisp history through its predecessors, Mocklisp and MacLisp, its early development up to the “Emacs schism” and the fork of Lucid Emacs, the development of XEmacs, and the subsequent rennaissance of Emacs development.

How the strengths of Lisp-family languages facilitate building complex and flexible bioinformatics applications.

We present a rationale for expanding the presence of the Lisp family of programming languages in bioinformatics and computational biology research. Put simply, Lisp-family languages enable programmers to more quickly write programs that run faster than in other languages. Languages such as Common Lisp, Scheme and Clojure facilitate the creation of powerful and flexible software that is required for complex and rapidly evolving domains like biology. We will point out several important key features that distinguish languages of the Lisp family from other programming languages, and we will explain how these features can aid researchers in becoming more productive and creating better code. We will also show how these features make these languages ideal tools for artificial intelligence and machine learning applications. We will specifically stress the advantages of domain-specific languages (DSLs): languages that are specialized to a particular area, and thus not only facilitate easier research problem formulation, but also aid in the establishment of standards and best programming practices as applied to the specific research field at hand. DSLs are particularly easy to build in Common Lisp, the most comprehensive Lisp dialect, which is commonly referred to as the ‘programmable programming language’. We are convinced that Lisp grants programmers unprecedented power to build increasingly sophisticated artificial intelligence systems that may ultimately transform machine learning and artificial intelligence research in bioinformatics and computational biology.

Teaching Functional Patterns through Robotic Applications

We present our approach to teaching functional programming to First Year Computer Science students at Middlesex University through projects in robotics. A holistic approach is taken to the curriculum, emphasising the connections between different subject areas. A key part of the students' learning is through practical projects that draw upon and integrate the taught material. To support these, we developed the Middlesex Robotic plaTfOrm (MIRTO), an open-source platform built using Raspberry Pi, Arduino, HUB-ee wheels and running Racket (a LISP dialect). In this paper we present the motivations for our choices and explain how a number of concepts of functional programming may be employed when programming robotic applications. We present some students' work with robotics projects: we consider the use of robotics projects to have been a success, both for their value in reinforcing students' understanding of programming concepts and for their value in motivating the students.

Development of the Simulation Software for Secondary Cooling Heat Transfer in Beam Blank Continuous Casting Process Based on FLUENT

A 2D mathematical Model for heat transfer during solidification in the secondary cooling was established on researching the process of beam blank continuous casting. Meanwhile, the boundary conditions of heat transfer was subdivided into four parts, which is the radiation, spray cooling, heat conduction through roller and water accumulated evaporation in secondary cooling zoon, and improved the results accuracy. Moreover, heat transfer simulation software was designed and developed by a 2D mathematical Model based on FLUENT. The secondary development language UDF (User Define Function) and Scheme (a dialect of LISP) of FLUENT were used during the development. The software provided a platform for researching on the solidification and optimization of a secondary cooling system for a caster machine of beam blank.

Revised6 Report on the Algorithmic Language Scheme

Programming languages should be designed not by piling feature on top of feature, but by removing the weaknesses and restrictions that make additional features appear necessary. Scheme demonstrates that a very small number of rules for forming expressions, with no restrictions on how they are composed, suffice to form a practical and efficient programming language that is flexible enough to support most of the major programming paradigms in use today.Scheme was one of the first programming languages to incorporate first-class procedures as in the lambda calculus, thereby proving the usefulness of static scope rules and block structure in a dynamically typed language. Scheme was the first major dialect of Lisp to distinguish procedures from lambda expressions and symbols, to use a single lexical environment for all variables, and to evaluate the operator position of a procedure call in the same way as an operand position. By relying entirely on procedure calls to express iteration, Scheme emphasized the fact that tail-recursive procedure calls are essentially gotos that pass arguments. Scheme was the first widely used programming language to embrace first-class escape procedures, from which all previously known sequential control structures can be synthesized. A subsequent version of Scheme introduced the concept of exact and inexact number objects, an extension of Common Lisp's generic arithmetic. More recently, Scheme became the first programming language to support hygienic macros, which permit the syntax of a block-structured language to be extended in a consistent and reliable manner.

The Promises of Functional Programming

Adopting a functional programming style could make your programs more robust, more compact, and more easily parallelizable. However, mastering it requires some effort. This article's purpose is to explain what functional programming is and how it differs from traditional imperative programming. The author also explains how functional programming helps with concurrent and parallel programming. The language I use in the examples is Clojure, a modern dialect of Lisp.

Essentials of programming languages

From the Publisher: Designed for the upper division Programming Languages course offered in computer science departments,this text focuses on the principles of the design and implementation of programming languages. The language SCHEME,a dialect of LISP,is used to demonstrate abstraction and representation.

Down with Emacs Lisp

It is possible to translate code written in Emacs Lisp or another Lisp dialect which uses dynamic scoping to a more modern programming language with lexical scoping while largely preserving structure and readability of the code. The biggest obstacle to such an idiomatic translation from Emacs Lisp is the translation of dynamic binding into suitable instances of lexical binding: Many binding constructs in real programs in fact exhibit identical behavior under both dynamic and lexical binding. An idiomatic translation needs to detect as many of these binding constructs as possible and convert them into lexical binding constructs in the target language to achieve readability and efficiency of the target code. The basic prerequisite for such an idiomatic translation is thus a dynamic scope analysis which associates variable occurrences with binding constructs. We present such an analysis. It is an application of the Nielson/Nielson framework for flow analysis to a semantics for dynamic binding akin to Moreau's. Its implementation handles a substantial portion of Emacs Lisp, has been applied to realistic Emacs Lisp code, and is highly accurate and reasonably efficient in practice.

A predicative and decidable characterization of the polynomial classes of languages

Characterizations of PTIME, PSPACE, the polynomial hierarchy and its elements are given, which are decidable (membership can be decided by syntactic inspection to the constructions), predicative (according to points of view by Leivant and others), and are obtained by means of increasing restrictions to course-of-values recursion on trees (represented in a dialect of Lisp).

An interactive multimedia textbook for introductory computer science

A multimedia implementation of an introductory computer science text based on the LISP dialect Scheme, is described. The text, Exploring Computer Science with Scheme [4], is designed for beginning students who may have no prior experience using computers. The goal is to create an environment that facilitates learning of the material and concepts in the text. The multimedia system includes hypertext abilities to jump through the text, search, and mark positions in the text. A personal notebook facility is provided that allows the user to enter notes while using the system or to copy sections of the text or Scheme environment directly into the notebook. The tool provides an animation feature that illustrates how various list and applicative functions work by modeling their internal actions. A Scheme listener is built into the tool to foster testing ideas and experimentation. Since the intended audience of the text includes people with no prior computing experience, the user interface is intuitive and full help features are provided.

BaLinda Lisp: Design and implementation

BaLinda Lisp is a parallel Lisp dialect employing a shared memory model of parallel processing together with a subset of the Linda tuple space operators. Also included in the design is speculative processing. The aim is to have shared memory multiprocessing with the tuple space acting as the main data structure through which synchronization is done. The result is a flexible programming language. In this paper, we shall describe the design philosophy of BaLinda Lisp, discuss its implementation on three multiprocessing platforms, give examples of programs written in BaLinda Lisp and discuss future work on the language.

Functional programming languages

Functional programming languages are a class of languages designed to reflect the way people think mathematically, rather than reflecting the underlying machine. Functional languages are based on the lambda calculus, a simple model of computation, and have a solid theoretical foundation that allows one to reason formally about the programs written in them. The most commonly used functional languages are Standard ML, Haskell, and “pure” Scheme (a dialect of LISP), which, although they differ in many ways, share most of the properties described here. For a complete description of these languages and of functional programming in general, see Bird and Wadler [1988], Paulson [1991], Sussman and Abelson [1985], Hudak et al. [1992], Milner et al. [1990], Artificial Intelligence Laboratory [1992], and Hudak [1989]. In contrast to the usual imperative languages (e.g., C, Fortran, and Ada), in which variables represent cells in memory that can be modified using the assignment operator 5 (or :5), functional languages view the use of the 5 operator as an expression of an equation. For example, if a functional program contains the declaration

Teaching computer science principles to liberal arts students using Scheme

The Scheme dialect of Lisp is being used as an expository notation in introductory courses for liberal arts students at Trinity University. Terminology from natural language identifying parts of speech, such as verb, noun, pronoun and adverb, is used to present Scheme syntax and semantics to non programmers. Simple working models of various computer science topics are described. Experiences from two Trinity computer science courses are presented.

Simply Scheme: introducing computer science

From the Publisher: This lively introduction to computer science and computer programming in Scheme is for non-computer science majors with a strong interest in the subject and for computer science majors who lack prior programming experience. The text allows the student to experience the computer as a tool for expressing ideas, not as a frustrating set of mathematical obstacles. This goal is supported by the use of Scheme, a modern dialect of Lisp, designed to emphasize symbolic programming.

Sweet harmony

A tight, transparent, and portable integration between C++ and LISP is desirable and feasible. This paper describes the C++ interface supplied with, a modern LISP dialect which extends the proposed ISLisp standard with a module system, a metaobject protocol, and an extensive set of libraries. The interface parses C++ header files and generates C++ stub interface files, as well as TALK modules which implement proxy classes and TALK foreign function definitions for C++ functions. The programmer then has nearly complete access to the functionality of a C++ library.

Does Scheme enhance an introductory programming course?

There is no consensus within the Computer Science community as to which programming language or languages ought to be used in introductory courses. In recent years a substantial contingent has proposed the use of Scheme, a dialect of Lisp, as a candidate for "Best First Language"; however, despite the articles touting success with this approach, there have been no empirical studies comparing the results of using Scheme versus other languages. This paper is a first step towards collecting data that might answer this question. We compare two pre-major courses at a four-year college, one taught using a structured version of Basic, the other taught using Scheme. A survey was used to compare student attitudes towards computer science and programming at the end of the course. While the survey was too small to provide statistically significant answers, there were indications that Scheme may in fact do a better job of capturing and holding students' interest in Computer Science.

APROL

This paper describes the design of a hybrid language which combines the features of an array processing language and lisp dialect in a consistent and useful manner. This language, APROL (Array PROcessing Lisp) is derived from the J dialect of APL and the Scheme dialect of Lisp. The base syntactic structure is taken from Scheme, while the array processing features are based on the J programming language. A prototype implementation has been made and some experiences with this implementation are described. This implementation uses J as an imbedded array processing engine in a Scheme intrepreter/compiler.The language as specified provides a set of data types and manipulation tools which is more diverse than found in either Scheme or J. APROL allows the programmer to apply array processing functions to lists of arrays in the Scheme style and list processing functions to arrays of lists in typical J style. The result is a language which not only brings array processing capabilities to Scheme, but also significantly extends the functionality of the Scheme language.