proj-oot-ootToReads

see also [1]

higher priority / dont forget about these

urbit

introductions

toreads unsorted

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

compilers

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 "

db queries

graphs

haskelly incld' category theory

Morte and Om

vms

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

functional

metaprogramming

macros

theory

DSLs

evaluation strategy

call-by-text and fexprs

types

"These systems are usually a few steps back from "full blown" higher-order dependent type theory proof assistants, a la Isabelle, Coq, Lean or such; though in some cases the type systems inch into the same territory. The design problem hinges on the annotation burden being low enough that the user doesn't give up in frustration...If you want to play in this space, you ought to study at least Sage, Stardust, Whiley, Frama-C, SPARK-2014, Dafny, F*, ATS, Xanadu, Idris, Zombie-Trellys, Dependent Haskell, and Liquid Haskell."

provers

high assurance and small core stuff from nickpsecurity

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

probabalistic programming

blogs

See also

See also [[ootToReadsAlreadyCopiedToPlBook?]].

See also [[ootToReadsFrameworks?]].

scala

smalltalk

logic

Low-level

concurrency

dataframes

R

dmbarbour's awelon

Overview (read that already). Trying to make programming easy for non-programmers by (Smalltalk-style?) 'IDE is the UI' (influences: Squeak Smalltalk, ToonTalk?, LambdaMOO?, Morphic, Croquet, Emacs, and HyperCard?). Thinks that Smalltalk failed because lack of recent advances in programming language design made it too hard to reuse code. Key innovations include: a streaming bytecode (and user input = streaming code, so that "user's input history can then be mined to develop user-macros, tools, and functions based on example"), "long-running behaviors and policies as accessible objects" (i don't yet understand this) via linear types (i don't yet understand how this relates) and Reactive Demand Programming (haven't read yet). There is a core language, ABC, Awelon Byte Code, and a language above that, AO (and is there a language above that?) and another language/shell script-ish thing above it, Claw. dmbarbour is a Haskell-y guy who is on LTU alot; he clearly has forgotten more about PLT than i'll ever know. To make awelon bytecode streamable (which apparently implies that you can forget old bytecode after executing it), there are no backwards jumps; instead, loops are done by fixpoint combinators, which i dont understand, but should learn.

data structures

concurrent/distributed

Lists of to-reads

parsing and grammar

modules

semantics

interop

dbs

bitc

reread http://www.coyotos.org/pipermail/bitc-dev/2012-March/003300.html http://www.coyotos.org/pipermail/bitc-dev/2012-April/003315.html http://lambda-the-ultimate.org/node/4490 bitc is still alive!: http://comments.gmane.org/gmane.os.coyotos.bitc.devel/4745 https://www.bitc-lang.org/node/9

capabilities

I/O

more on epoll vs kqueue vs iocp (ppl prefer iocp or kqueue):

VMs

Contracts preconditions etc for safety

Erlang and Elixir

Design tools

"Long term, we have to get to the point where we ship languages -- and implementations -- with strong, proven foundations. There are promising moves in this direction, both in designed-for-language-designer tools like K framework or Redex, and in the general set of libraries and projects being undertaken in general proof assistants like Isabelle and Coq."

Oot Assembly-related

Core languages

For OotB

i guess i'm still feeling fairly eager to get-implementin' on an Oot Bytecode interpreter, even though there are many unanswered questions at the Oot Core level, and even though i haven't learned all of the other contender languages yet. What else is likely to make such a big difference to Oot Bytecode that beginning implementation now would be a waste of time? All i can think of is that i should:

Transpiling

OSs

Program transformation

Prolog

normal forms

3-lisp

clockless circuits

eve

design

scripting

https://hackage.haskell.org/package/turtle-1.3.3/docs/Turtle-Tutorial.html

quantum computing

QC: Quil

QC: IBM-Q and QASM

QC: Q#

QC: Liquid (F#)

QC: other

QCL (C-like) QML (Haskell-like) Quipper (Haskell) ProjectQ? (C++/Python)

Misc

> #(contingent #(interval 3.0255 3.0322)

                (shadow super))What's so special about this? Well, the fall-time has been updated to a more narrow interval... but that last part (shadow and super) are the symbols of the other cells which propagated the information of this updated state. Pretty cool! And no fancy natural language parsing involved. "  https://github.com/ekmett/propagators 

IPC:

data

tobemined

for OVM

misc/todo

noir_lord 60 days ago [-]

What a beautifully written article with informative links.

http://lucacardelli.name/Papers/TypefulProg.pdf is now next on my list when I finish reading A Philosophy of Software Design (which is brilliant if you haven't seen it).

nickpsecurity 59 days ago [-]

Cardelli's Modula-3, a C++ alternative, also illustrates excellent balance of simplicity, programming in large, compile time, and run time. Expanding on that carefully like with macros, a borrow checker, and LLVM integration would have made for a simpler, safer, systems language. Give it a C-like syntax with C compatibility, too, for adoption.

https://en.m.wikipedia.org/wiki/Modula-3

pjmlp 59 days ago [-]

You mean C# I guess. :)

Actually with .NET Native, the GC improvements in .NET 4.6 (TryStartNoGCRegion?() and other companion methods), and the C# 7.x improvements taken from Midori, it is quite close.

nickpsecurity 59 days ago [-]

C# looked a lot more complex than Modula-3 when I last looked at it. The book was thick. They definitely did nice things in C#. I just don't know it's fair to equate it with the simplicity vs get shit done vs small runtime of Modula-3.

I am up for you elaborating a bit on the second sentence since it sounds interesting. Not doing .NET, I don't know what any of those are except the middle one which sounds like SYSTEM/UNSAFE sections.

pjmlp 59 days ago [-]

It is more complex, but Modula-3 isn't that tiny either, around Algol 68/Ada 83 "tiny".

They integrated the improvements from M#/System C# (Midori) into C#.

Namely return ref, ref for local variables, stack allocation for arrays in safe code, spans (slices) across all memory types, allocation free pipelines.

---