Plasma Language References

Copyright (C) Plasma Team
Distributed under CC BY-SA 4.0
Updated: May 2018
Source: on github

References to 3rd-party papers and software that we are using or that may be helpful at some point.

Papers, Books & other ideas

Closures

My own blog articles, the second one discusses the two above papers:

Continuations

Implementation Strategies for First-class continuations

http://lampwww.epfl.ch/teaching/archive/advanced_compiler/2006/assignments/part5/continuations.pdf

GC References

The Garbage Collection Handbook

http://www.amazon.com/Garbage-Collection-Handbook-Management-Algorithms/dp/1420082795/ref=sr_1_1?s=books&ie=UTF8&qid=1437385704&sr=1-1&keywords=garbage+collection

Potentially useful references from this book
Richard Jones' GC Page

http://www.cs.kent.ac.uk/people/staff/rej/gc.html

Richard Jones' GC Bibiliography

http://www.cs.kent.ac.uk/people/staff/rej/gcbib/gcbib.html

Memory Management Reference

http://www.memorymanagement.org/

Data structures for GC

  • TLSF - a data structure for fast, constant time allocation.

Type systems

  • 1ML is an ML language with the module language and value language unified into one language (I think) I need to read more.

  • Modular Implicits is an extension to OCaml to add ad-hoc polymorphism to the language. This is similar to my vague ideas about implicit interfaces, and I will probably use this in some way.

  • https://www.koterpillar.com/talks/instances-for-everyone/#18 Alexy’s talk about deriving things like Eq, Ord etc in Haskell/GHC. Contains further links at the end.

Optimiation and code gneeration

Concurrency and parallelism

Text handling

Unicode.org

https://unicode.org/ Unicode standardisation happens here. I’ve found the Unicode glossary especially useful, the Unicode database may also be helpful.

The UTF-8 Manifesto

https://utf8everywhere.org/ Not a library, but a description of some best practices and calls out some worst-practices also.

Libraries

Message Passing

Nanomsg

http://nanomsg.org/

Nanomsg is a C library for message passing. It exposes a BSD sockets style API.

Profiling

SHIM

https://github.com/ShimProfiler/SHIM SHIM is a tool for high-resolution sampling of CPU performance counters. It may be more useful as a basis of our own implementation than useful as-is.

Text handling

libunistring

libunistring is the Unicode library with the clearest documentation. It might not do everything that we eventually want but it looks like the best place to start.

Tools

Build systems

Autosetup

http://msteveb.github.io/autosetup/ Autosetup is an alternative to autoconf, it is written in Tcl.

ninja

https://ninja-build.org Ninja is a build system (like make) but more principled. It requires build files to (almost) fully describe the dependency graph (no implicit rules/wildcards). This makes things more predictable and faster - but the build files are usually generated. The plzbuild tool writes ninja build files and calls to ninja to perform the actual build.

Tup

http://gittup.org/tup/index.html Tup is an alternative to Make. It looks like it avoids a lot of Make’s problems.

Testing

Hyperfine

https://github.com/sharkdp/hyperfine Hyperfine is a benchmarking tool.

TAP

https://testanything.org/ Test anything protocol a format and set of libraries for test output. Allowing a test suite to interact with CI.

Git/Project hosting

gitlab

Software.

gitgud.io

Gitlab hosted service.

gogs.io

Git oriented project hosting written in Go.

C Static analysis

splint

http://www.splint.org/

Formats

We use the TOML file format for Plasma BUILD.plz files.

Algorithms

PRNGs

A table of some PRNGs.

Related programming languages

Plasma is implemented in Mercury.

Plasma is inspired by many other languages, some of them are:

  • Mercury is a logic/functional language that I also work on. I developed an auto-parallelisation system for Mercury and plan to implement one for Plasma. After 7 years contributing to Mercury I’m sure other aspects of it will also influence Plasma.

  • Hope influenced Plasma indirectly. Hope is the first language with abstract data types.

  • OCaml's parametric modules are the inspiration for Plasma’s interfaces.

Several other imperative/declarative languages like Plasma include:

Disclosure: Mars, Wybe and Pawns are all developed by colleagues of mine.

Other parallel languages:

  • SISAL is an applicative single-assignment language, like Plasma it has declarative semantics and an imperative-ish style. It supported auto-parallelisation based on loops and streams and rivaled Fortran form performance.

  • Futhark is an array based language (like APL) for GPGPU programming. I don’t know much about it at the moment but will be reading their papers and following their work.

  • http://halide-lang.org/ A Data-parallel eDSL embedded in C++

  • http://parasail-lang.org/ Looks like an implicitly-parallel language.

  • Alan is a almost Turing-complete language with array loops and auto parallelism.