proj-oot-old-150618-ootToReads

see also [1]

toreads unsorted

link Try adding a language with proof solving capabilities. ATS, Agda, Idris, Coq spring to mind.

PL textbooks and intros and courses

the stuff in [2]: 'Collections of comparisons of programming languages'

PL design / big picture

uncategorized papers

lists

designing and building language tutorials

language implementation

http://www.cs.indiana.edu/~dyb/pubs/nano-jfp.pdf A Nanopass Framework for Compiler Education [PDF] by Sarkar, Waddell, and Dybvig * https://github.com/akeep/nanopass-framework https://github.com/akeep/nanopass-framework/blob/master/doc/user-guide.pdf?raw=true * http://lambda-the-ultimate.org/node/1589

target languages / minimal languages / bytecode implementations

data Lam :: * -> * where Lift :: a -> Lam a Tup :: Lam a -> Lam b -> Lam (a, b) Lam :: (Lam a -> Lam b) -> Lam (a -> b) App :: Lam (a -> b) -> Lam a -> Lam b Fix :: Lam (a -> a) -> Lam a "

graphs

haskelly incld' category theory

pythonic

c ish / c y / cy

rusty

lispy

  1. The base environment for an Ur-Lisp written in Ruby @env = { :label => proc {
(name,val), _@env[name] = eval(val, @env) },
 :car   => lambda { |(list), _| list[0] },
 :cdr   => lambda { |(list), _| list.drop 1 },
 :cons  => lambda { |(e,cell), _| [e] + cell },
 :eq    => lambda { |(l,r),ctx| eval(l, ctx) == eval(r, ctx) },
 :if    => proc { |(c,t,e),ctx| eval(c, ctx) ? eval(t, ctx) : eval(e, ctx) },
 :atom  => lambda { |(s), _| (s.is_a? Symbol) or (s.is_a? Numeric) },
 :quote => proc { |sexpr, _| sexpr[0] } }"

J

continuations

concurrency (and parallelism, and distributed systems)

paradigms

metaprogramming

macros

DSLs

evaluation strategy

call-by-text and fexprs

types

provers

math

OOP

frameworks and libs

major languages , applications

other languages

math: Maple Mathcad Maxima Sage

quotes / move to book

learn to code , and ipython notebooks

high integrity

dgemm 19 hours ago

Is there a high level overview somewhere I can read? Don't even know what to google here.

reply

throwawayf2o 18 hours ago

In general, the answer typically involves formal specification and formal methods that check the code against these specifications, combined with testing and coding standards that result in analysable code.

More references:

https://www.cs.umd.edu/~mvz/cmsc630/clarke96formal.pdf

http://research.microsoft.com/en-us/um/people/lamport/tla/fo...

reply

pjmlp 12 hours ago

Search for high integrity software.

For example, with MISRA it may be C, but feels like Ada.

http://www.misra.org.uk/

Or Spark similarly for Ada

http://www.spark-2014.org/

reply

tormeh 18 hours ago

You might want to look into coding standards for C and special languages like Ada (like C, but less writeable, more readable with strong types) and Esterel (deterministic multithread scheduling). Seriously, Esterel is probably the coolest thing you'll read about this week.

There's also various specification languages for multithreaded behaviour, which allows you to analyse your programs behaviour using software tools, for example SPIN[0].

0: http://en.wikipedia.org/wiki/SPIN_model_checker

reply

roma1n 3 hours ago

Yup. How a DO-178-like integrity level is not mandatory for medical devices is troubling.

reply

errors

blogs

See also

See also [[ootToReadsAlreadyCopiedToPlBook?]].

See also [[ootToReadsFrameworks?]].

Di Franco-ish

Misc

BayleShanks RecentChanges Bayle Shanks's website
Comments on proj-oot-old-150618-ootToReads This page is read-only View other revisions Administration
Last edited 2015-06-19 04:28 UTC by BayleShanks