Permalink
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
163 lines (115 sloc) 5.25 KB
Plasma Language References
==========================
Paul Bone <paul@plasmalang.org>
v0.1, May 2018: Perpetual draft.
Copyright (C) 2015-2018, Plasma Team
License: CC BY-SA 4.0
References to 3rd-party papers and software that we are using or that may be
helpful at some point.
link:https://github.com/PlasmaLang/plasma/tree/master/docs/references.txt[Contribute to this page]
== Papers and Books
=== Closures
* https://pdfs.semanticscholar.org/28b6/d269ebee933c378e539f1c378740d409330d.pdf[Luca Cardelli: Compiling a Functional Language]
* https://www.cs.indiana.edu/~dyb/pubs/closureopt.pdf[Andrew Keep, Alex Hearn, R. Kent Dybvig: Optimising Closures in O(0) time]
* http://flint.cs.yale.edu/flint/publications/escc.html[Zhong Shao, Andrew
Appel: Efficient and Safe for space closure conversion]
My own blog articles, the second one discusses the two above papers:
* https://paul.bone.id.au/2017/12/03/compiling-closures/[Compiling closures]
* https://paul.bone.id.au/2017/12/10/compiling-closures2/[More on closures]
=== 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::
* Appel 1989b, Goldberg 1991 about pointer finding
* Looks like Appel has several good papers about GC
* Tarditi Compressing stack maps.
http://research.microsoft.com/pubs/68937/ismm-2000b.pdf
* Doligez and Leroy 1993 and other papers pp107
http://gallium.inria.fr/~xleroy/publi/concurrent-gc.pdf
* Halsteed 1985 concurrent copying
* Marlow 2008
* Train collector
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/
=== Type systems
* https://www.mpi-sws.org/~rossberg/1ml/[1ML] is an ML language with the
module language and value language unified into one language (I think) I
need to read more.
* http://arxiv.org/pdf/1512.01895.pdf[Modular Implicits] is an extension to
OCaml to add ad-hoc polymorphism to the language. This is similar to my
vague ideas about implicit
link:plasma_ref.html#_interfaces[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
* http://www.agner.org/optimize/ Software optimization resources
https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/compilingml.pdf
Compiling a Functional Language.
== 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.
== Tools
=== Build systems
Autosetup::
http://msteveb.github.io/autosetup/
Autosetup is an alternative to autoconf, it is written in Tcl.
Tup::
http://gittup.org/tup/index.html
Tup is an alternative to Make. It looks like it avoids a lot of Make's
problems.
=== 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/
== Algorithms
=== PRNGs
A table of some http://www.pcg-random.org/[PRNGs].
== Related programming languages
Plasma is implemented in https://mercurylang.org[Mercury].
Plasma is inspired by many other languages, some of them are:
* http://www2.cmp.uea.ac.uk/~jrwg/Sisal/00.Contents.html[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.
* https://mercurylang.org[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.
* https://en.wikipedia.org/wiki/Hope_%28programming_language%29[Hope]
influenced Plasma indirectly. Hope is the first language with abstract
data types.
* http://ocaml.org[OCaml]'s parametric modules are the inspiration for
Plasma's interfaces.
* http://futhark-lang.org[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.
Several other imperative/declarative languages like Plasma include:
* http://www2.cmp.uea.ac.uk/~jrwg/Sisal/00.Contents.html[SISAL]
* http://mars-lang.appspot.com/[Mars]
* http://people.eng.unimelb.edu.au/schachte/papers/wybeintro.pdf[Wybe]
* http://people.eng.unimelb.edu.au/lee/src/pawns/[Pawns]
Disclosure: Mars, Wybe and Pawns are all developed by colleagues of mine.