proj-oot-ootToReads

see also [1]

higher priority / dont forget about these

• Niklaus Wirth's "Good Ideas, Through the Looking Glass"
• metaprogramming that i need to understand better: Zig comptime, what's wrong with c++ templates, staged compilation
• https://matklad.github.io/2020/04/13/simple-but-powerful-pratt-parsing.html
• https://matklad.github.io/2023/05/21/resilient-ll-parsing-tutorial.html
• read the section from ootDataNotes6.txt starting around line 211, which points to and is going to excerpt from older notes about the generalized graphs data structure idea that i should reread
• Lisp and J both claim to be good languages for prototyping. Look into what makes them good for that.

General

• https://www.digitalmars.com/articles/b90.html
  • https://news.ycombinator.com/item?id=23053773
• http://wingolog.org/archives/2020/03/25/firefoxs-low-latency-webassembly-compiler
• https://michaelfeathers.silvrback.com/10-papers-every-developer-should-read-at-least-twice
  • some ppl dont like 'A Laboratory For Teaching Object-Oriented Thinking'
• Out of the Tar Pit 2005, a paper on Functional Reactive Programming
• Wise Computing: Towards Endowing System Development with True Wisdom
• https://www.cs.princeton.edu/~appel/modern/ rec. by https://news.ycombinator.com/item?id=21513497
• https://applied-langua.ge/posts/lisp-curse-redemption-arc.html
• https://hirrolot.github.io/posts/compiler-development-rust-or-ocaml.html
• https://matklad.github.io/2023/08/06/fantastic-learning-resources.html
  • http://openclassroom.stanford.edu/MainFolder/CoursePage.php?course=Compilers
  • https://www.coursera.org/learn/programming-languages
  • https://www.tedinski.com/archive/
  • https://matklad.github.io/links.html

urbit

• http://urbit.org (new Hoon stuff)
• https://urbit.org/docs/hoon/
• https://urbit.org/docs/byte/
• http://micnus-tarwyl-haltem-linhut--dilhul-talbes-wolnyx-lasbud.urbit.org/docs/hoon/

introductions

• LtU Getting Started

interop

• https://duktape.org/guide.html#gettingstarted
• https://peps.python.org/pep-0733/

toreads unsorted

• http://stackoverflow.com/questions/961942/what-is-the-worst-programming-language-you-ever-worked-with
• http://wiki.di.uminho.pt/twiki/pub/Education/MFES1112/Material/Logic-lesson5.pdf
• http://www.cs.man.ac.uk/~pjj/cs211/ho/ho.html
• http%3A%2F%2Fwww.cis.upenn.edu%2F~bcpierce%2Fpapers%2Fcrchandbook.ps
• http://code.google.com/p/qbql/
• http://www.cse.scu.edu/~rdaniels/html/courses/Coen171/Powerpoint.htm
• http://www.cis.upenn.edu/~bcpierce/courses/670Fall04/GreatWorksInPL.shtml
• http://research.microsoft.com/en-us/projects/specsharp/
• http://www.inf.ethz.ch/personal/wirth/Articles/Oberon.html oberon-07 (Wirth likes it better than his other languages Pascal, Modula-2, and better than Java and C#; however a bunch of other people like Modula-3: http://stackoverflow.com/questions/422461/is-anyone-programming-in-oberon )
• Dyna ( http://www.dyna.org/ )
• read http://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.29.4790
• http://en.wikipedia.org/wiki/Parallax_Propeller#Built_in_SPIN_byte_code_interpreter
  • http://web.archive.org/web/20131109164117/http://www.pyret.org/
• http://www.bencollier.info/content/finding-minimum-set-languages-learn-all-programming-paradigms
  • yetfeo 7 hours ago

• https://github.com/Gozala/wisp
• https://github.com/damelang/nile
• http://www.q-lang.io/ and https://news.ycombinator.com/item?id=7333354
• ada
• Ada arose from a DoD?-sponsored contest to meet a detailed requirements document. The requirements document is notable in that it excludes some features as well as demanding others: http://www.dwheeler.com/steelman/steelman.htm
• metalua
• metaocaml
• http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.127.5320 Organizing programs without classes
• languages on top of map reduce: https://en.wikipedia.org/wiki/Sawzall_%28programming_language%29 , https://en.wikipedia.org/wiki/Pig_%28programming_tool%29 , https://en.wikipedia.org/wiki/Apache_Hive , https://en.wikipedia.org/wiki/Cloudera_Impala , JAQL , Cascading , Cascalog , scalding, lingual
• D's ranges: http://www.informit.com/articles/printerfriendly.aspx?p=1407357
• toread stuff about D devel: http://www.llucax.com.ar/blog/blog/post/6cac01e1 http://while-nan.blogspot.com/2007/08/future-of-d-is-aaargh-my-eyes.html http://www.jfbillingsley.com/blog/?p=53 "The Present of D" http://web.archive.org/web/20110919093918/http://www.billbaxter.com/techblog/?p=14
• http://web.archive.org/web/20011217114145/http://home.pacbell.net/ouster/scripting.htm paper on scripting languages by the creator of TCL
• http://research.microsoft.com/en-us/um/people/simonpj/papers/haskell-retrospective/Haskell-Erlang-Jun09.pdf
• http://research.microsoft.com/en-us/um/people/simonpj/papers/haskell-retrospective/ECOOP-July09.pdf
• https://en.wikipedia.org/wiki/%C3%98MQ
• http://cs.adelaide.edu.au/~dwyer/TR95-10.html#LIBRA17
• https://www.google.com/search?client=ubuntu&channel=fs&q=LIBRA+relational&ie=utf-8&oe=utf-8#channel=fs&q=LIBRA+relational+programming
• "If you think JavaScript? is one of the most Scheme-like languages out there, then you’re missing out on the fact that Forth is really minimal, Dart has great scoping, Lua does tail call elimination, Haskell and Ruby have continuations, C# has dynamic typing, Io is homoiconic, Go has closures, Scala has macros, and Clojure seriously dislikes mutation." -- http://journal.stuffwithstuff.com/2013/07/18/javascript-isnt-scheme/
• Look at Python PEPs and similar for other languages
• Look at http://code.hazzens.com/d3tut/lesson_1.html
• http://cis.poly.edu/cs614/NewdirectionsSaman1206.pdf
• mb look at http://strategoxt.org/Stratego/StrategoLanguage , Antlr, parboiled
• for that matter, learn Datomic
• read http://web.archive.org/web/20110605015801/http://homepages.cwi.nl/~ralf/gpce06/paper.pdf
• random list of primitives: http://hackage.haskell.org/packages/archive/ddc-core-tetra/0.3.2.1/doc/html/DDC-Core-Tetra.html
• http://purelang.bitbucket.org/
• Look at http://lambda-the-ultimate.org/node/3, http://lambda-the-ultimate.org/node/5, http://lambda-the-ultimate.org/node/7, http://merd.sourceforge.net/pixel/language-study/, plot http://lambda-the-ultimate.org/node/3253, dylan,
• reread http://blog.ianbicking.org/ruby-python-power.html
• read http://www.ibm.com/developerworks/java/library/wa-clojure/index.html
• mb http://www.irit.fr/~Martin.Strecker/Publications/diss-strecker.pdf
• http://www.andres-loeh.de/LambdaPi/LambdaPi.pdf
• from http://en.wikipedia.org/wiki/Generalized_algebraic_data_type#Higher-order_abstract_syntax: "
• ohmu: http://portal.acm.org/citation.cfm?id=949350
• ontic: http://ttic.uchicago.edu/~dmcallester/ontic-spec.ps
• http://txl.ca/
• http://matt.might.net/articles/best-programming-languages/
• http://talks.golang.org/2012/splash.article
• read Hoare: Hints for Programming Language Design, Wegner: Programming Languages - The First 25 Years, Wirth: On the Design of Programming Languages, Nauer: Report on the Algorithmic Language ALGOL 60
• probably dont read http://www.springer.com/computer/theoretical+computer+science/book/978-3-540-65410-0 (Principles of Program Analysis) and http://www.amazon.com/Formal-Semantics-Programming-Languages-Winskel/dp/0262731037#reader_0262731037 , but consider reading them
• mb read http://www.program-transformation.org/
• http://en.wikipedia.org/wiki/Delimited_continuation
• https://www.google.com/search?client=ubuntu&channel=fs&q=delimited+contniuation&ie=utf-8&oe=utf-8
• http://www.scala-lang.org/node/2096
• http://stackoverflow.com/a/1464175/171761
• http://stackoverflow.com/questions/8849185/formal-definition-of-scala-continuations
• https://www.google.com/search?client=ubuntu&channel=fs&q=clojure+scala++first-class+continutations&ie=utf-8&oe=utf-8
• https://www.google.com/search?client=ubuntu&channel=fs&q=clojure+scala++first-class+continutations&ie=utf-8&oe=utf-8#hl=en&client=ubuntu&hs=6AG&tbo=d&channel=fs&spell=1&q=clojure+scala+%22first-class+continuations%22&sa=X&ei=4SoDUa2GN7DG0AHk2YDQCA&ved=0CC8QvwUoAA&bav=on.2,or.r_gc.r_pw.r_cp.r_qf.&bvm=bv.41524429,d.dmQ&fp=8e0d657e9b9006fd&biw=1340&bih=1984
• https://www.google.com/search?client=ubuntu&channel=fs&q=clojure+scala++first-class+continutations&ie=utf-8&oe=utf-8#hl=en&client=ubuntu&hs=UBG&tbo=d&channel=fs&sclient=psy-ab&q=clojure+scala+%22first-class%22+%22composable+continuations%22&oq=clojure+scala+%22first-class%22+%22composable+continuations%22&gs_l=serp.3...18875.22700.2.23078.15.14.0.0.0.7.251.2600.0j9j5.14.0.les%3B..0.0...1c.1.y709EEeKEAs&pbx=1&bav=on.2,or.r_gc.r_pw.r_cp.r_qf.&bvm=bv.41524429,d.dmQ&fp=8e0d657e9b9006fd&biw=1340&bih=1984
• https://www.google.com/search?client=ubuntu&channel=fs&q=clojure+scala++first-class+continutations&ie=utf-8&oe=utf-8#hl=en&client=ubuntu&hs=cra&tbo=d&channel=fs&spell=1&q=clojure+scala+%22first-class%22+%22delimited+continuations%22&sa=X&ei=LCsDUYf6IOPA0AGYvIGoBg&ved=0CC8QvwUoAA&bav=on.2,or.r_gc.r_pw.r_cp.r_qf.&bvm=bv.41524429,d.dmQ&fp=8e0d657e9b9006fd&biw=1340&bih=1984
• "(Incidentally, monads and delimited continuations have equivalent expressive power: you can represent "computations that use continuation effects" as a monad, and if you replace your side-effecting primitives with appropriate continuation-invoking routines you can turn code that causes side effects into code that returns a monadic representation of those side effects. But that is a story for another day.) "
• http://lambda-the-ultimate.org/node/3700
• http://patterngazer.blogspot.com/2011_07_01_archive.html
• https://www.google.com/search?client=ubuntu&channel=fs&q=clojure+first-class+continutations&ie=utf-8&oe=utf-8#hl=en&client=ubuntu&hs=69F&tbo=d&channel=fs&spell=1&q=clojure+first-class+continuations&sa=X&ei=oyoDUZbXGKje0gGMv4HgBw&ved=0CC8QvwUoAA&bav=on.2,or.r_gc.r_pw.r_cp.r_qf.&bvm=bv.41524429,d.dmQ&fp=8e0d657e9b9006fd&biw=1340&bih=1984
• http://www.scala-lang.org/node/104
• http://en.wikipedia.org/wiki/Type_inference
• http://en.wikipedia.org/wiki/Hindley%E2%80%93Milner
• http://en.wikipedia.org/wiki/Hindley%E2%80%93Milner#Principal_type
• http://en.wikipedia.org/wiki/Principal_type and http://trevorjim.com/papers/principal-typings.ps.gz
• http://www.haskell.org/haskellwiki/GADT
• http://stackoverflow.com/questions/5653678/union-types-and-intersection-types
• Learn about common type system algebraic things; HM typing, System F, etc, union types, intersection types, negation types.
• Learn about the Curry–Howard? correspondence, e.g. why functions are implication, conjunction is a product type, etc
• http://www.haskell.org/ghc/docs/latest/html/users_guide/type-families.html
• http://en.wikipedia.org/wiki/Glasgow_Haskell_Compiler#Type_system_extensions
• http://stackoverflow.com/questions/3787960/what-makes-haskells-type-system-more-powerful-than-other-languages-type-syst
• https://github.com/leonidas/codeblog/blob/master/2011/2011-12-27-template-haskell.md
• http://news.ycombinator.com/item?id=3857667
• http://lambda-the-ultimate.org/node/492
• reread http://www.paulgraham.com/popular.html , http://www.paulgraham.com/langdes.html , http://www.paulgraham.com/taste.html , http://paulgraham.com/hundred.html
• http://www.cs.uu.nl/wiki/pub/Center/CompilerConstructionInHaskell/C11-AG-icfp2012.pdf
• http://en.wikipedia.org/wiki/Subtypes
• http://blog.lab49.com/archives/2954 including the comments
• http://en.wikipedia.org/wiki/Prototype-based_programming
• google search for what makes type systems typing systems hard to use difficult complicated complex easy to learn use, simplifying haskell's type system
• http://weblog.plexobject.com/?p=1634
• mb read [BOOK] Hints on programming language design CAR Hoare - 1983 - Springer
• " “Design and evolution of C++“ is a pretty good read)"
• http://cs.adelaide.edu.au/~dwyer/TR95-10_TOC.html
• http://en.wikipedia.org/wiki/Probabilistic_relational_programming_language
• The Evolution of Lua http://www.tecgraf.puc-rio.br/~lhf/ftp/doc/hopl.pdf and other Lua papers at http://www.lua.org/docs.html
• the making of erlang: http://www.sics.se/~joe/thesis/armstrong_thesis_2003.pdf
• http://research.microsoft.com/en-us/um/people/simonpj/papers/haskell-retrospective/index.htm
• http://research.microsoft.com/en-us/um/people/simonpj/papers/history-of-haskell/
• typeclasses, also with a useful intro to how the compiler implements typeclasses http://research.microsoft.com/en-us/um/people/simonpj/papers/haskell-retrospective/ECOOP-July09.pdf
• vs erlang http://research.microsoft.com/en-us/um/people/simonpj/papers/haskell-retrospective/Haskell-Erlang-Jun09.pdf
• http://alarmingdevelopment.org/?p=797#more-797 : SNOBOL, Spreadsheets, HyperCard?, Delphi, Visual Basic
• Effective Java (recc. by http://www.nomachetejuggling.com/2011/12/15/scala-first-impressions/)
• Josh Suereth’s Scala in Depth (recc by http://www.nomachetejuggling.com/2012/10/26/scala-second-impressions/)
• http://golang.org/doc/effective_go.html
• https://talks.golang.org/2012/splash.article
• http://www.chrisseaton.com/katahdin/katahdin.pdf#page=5&zoom=auto,0,657
• http://tratt.net/laurie/research/pubs/html/tratt__experiences_with_an_icon_like_expression_evaluation_system/
• http://lambda-the-ultimate.org/node/4808 (and note the comment with the PatBang? extension)
• great read: http://www.coyotos.org/pipermail/bitc-dev/2012-March/003300.html
  • should also read the rest of the thread, starting with Eli Gottlieb's post: http://www.coyotos.org/pipermail/bitc-dev/2012-March/thread.html
  • and then the promised post on issues with type classes: http://www.coyotos.org/pipermail/bitc-dev/2012-April/thread.html
• http://research.microsoft.com/en-us/um/people/simonpj/papers/haskell-retrospective/HaskellRetrospective-2.pdf
• http://lambda-the-ultimate.org/node/3837
• mb: common lisp book: http://www.cs.cmu.edu/~dst/LispBook/book.pdf
• http://c2.com/cgi/wiki?DelegationIsInheritance
• mb http://lambda-the-ultimate.org/node/4186#comment-64250
• mb http://pages.cs.wisc.edu/~bolo/shipyard/3ins4th.html
• mb http://home.pipeline.com/~hbaker1/ForthStack.html
• mb http://tunes.org/~iepos/joy.html
• http://vpri.org/html/work/ifnct.htm
• http://moronlab.blogspot.com/2010/01/urbit-functional-programming-from.html
• http://lambda-the-ultimate.org/node/3855
• http://www.madore.org/~david/programs/unlambda/ "the most purely SK-based language I know of." -- http://lambda-the-ultimate.org/node/3855#comment-57782
• mb https://en.wikipedia.org/wiki/AMPL
• mb Alan Kay and co's Nile
• http://www.vpri.org/pdf/tr2007008_steps.pdf
• http://www.viewpointsresearch.org/pdf/m2007007a_revolution.pdf
• http://lambda-the-ultimate.org/node/4490
• learn about region typing (effect and region typing)
• http://docs.scala-lang.org/tutorials/tour/annotations.html
• read that stuff by Luca Cardelli: http://scholar.google.com/scholar?hl=en&q=Luca+Cardelli&btnG=&as_sdt=1%2C5&as_sdtp=
• http://www.softpanorama.org/Lang/index.shtml
• http://www.p-cos.net/lisp/guide.html
• http://pdf.aminer.org/001/077/747/a_simple_and_unifying_approach_to_subjective_objects.pdf
• http://www.p-cos.net/links.html
• SAIL, “Stanford Artificial Intelligence Language,” an amazing design which among other insights convinced me once and for all that one cannot seriously deal with data structures without the benefit of an automatic serialization mechanism -- http://bertrandmeyer.com/2011/11/07/john-mccarthy/
• http://joequery.me/code/programming-language-design-issues/
• http://isea.nitk.ac.in/PMISprojects/reports/LanguagesReport.pdf
• topic maps
• Reflective Techniques in Extensible Languages By Jonathan Riehl
• Boo and Ometa: http://dotnet-forum.de/blogs/rainerschuster/archive/2010/11/30/packrat-parsing-o-meta-where-arz-thou.aspx
• http://en.wikibooks.org/wiki/Introduction_to_Programming_Languages
• http://www.drdobbs.com/cpp/the-beta-programming-language/184409089
• http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.32.1076
• https://en.wikipedia.org/wiki/Sing_sharp
• MMU: http://www.embedded-bits.co.uk/2011/mmutheory/ http://www.embedded-bits.co.uk/2011/mmucode/
• http://siek.blogspot.com/2012/07/big-step-diverging-or-stuck.html
• http://siek.blogspot.com/2012/07/linking-isnt-substitution-separately.html
• http://siek.blogspot.com/2012/07/my-new-favorite-abstract-machine-ecd-on.html
• http://siek.blogspot.com/2013/05/type-safety-in-three-easy-lemmas.html
• http://www.llvmpy.org/llvmpy-doc/dev/doc/kaleidoscope/
• http://www.stephendiehl.com/llvm/
• http://www.braveclojure.com/do-things/
• https://www.google.com/search?client=ubuntu&channel=fs&q=reversible+computing+isa&ie=utf-8&oe=utf-8#channel=fs&q=reversible+computing+%22instruction+set%22&safe=active
• http://matt.might.net/articles/bash-by-example/
• http://morepypy.blogspot.com/2011/04/tutorial-writing-interpreter-with-pypy.html
• https://en.wikipedia.org/wiki/Type_introspection
• http://www.infoq.com/presentations/oop-language-context
• http://www.buildyourownlisp.com/contents
• fleet, async cpu design: http://arc.cecs.pdx.edu/publications
• http://www.amazon.com/The-Readable-Code-Theory-Practice/dp/0596802293
• http://blog.paralleluniverse.co/2014/05/01/modern-java/
  • http://blog.paralleluniverse.co/2014/05/08/modern-java-pt2/
  • http://blog.paralleluniverse.co/2014/05/15/modern-java-pt3/
  • https://news.ycombinator.com/item?id=7750146 and the other HN stories for the previous two
• http://jlongster.com/Removing-User-Interface-Complexity,-or-Why-React-is-Awesome
• http://www.lighttable.com/2014/05/16/pain-we-forgot/
• one guy's suggestions for python: http://web.archive.org/web/20140428200015/http://c2.com/cgi/wiki?PythonThreeThousand
• http://docs.python-guide.org/en/latest/writing/style/
• http://rosettacode.org/wiki/Help:Similar_Sites
• https://github.com/ethereum/wiki/wiki/%5BEnglish%5D-Ethereum-TOC
• http://www.dabeaz.com/coroutines/
• http://stackoverflow.com/questions/9708902/in-practice-what-are-the-main-uses-for-the-new-yield-from-syntax-in-python-3
• https://news.ycombinator.com/item?id=7803593
• http://www.slideshare.net/palvaro/icde2014-slideshare-33117763
• http://prog21.dadgum.com/14.html
• http://graydon2.dreamwidth.org/5785.html
• http://www.vpri.org/vp_wiki/index.php/Main_Page
• http://en.wikipedia.org/wiki/Squeak#Uses
• http://en.wikipedia.org/wiki/Squeak#See_also
• http://c2.com/cgi/wiki?LiveProgramming
• http://web.archive.org/web/*/https://www.kickstarter.com/projects/214379695/micro-python-python-for-microcontrollers
• the comments on the updates on http://web.archive.org/web/*/http://micropython.org/ e.g. https://www.kickstarter.com/projects/214379695/micro-python-python-for-microcontrollers/posts/679050/comments
• The Architecture of Symbolic Computers http://dl.acm.org/citation.cfm?id=542141
• http://www.cs.cmu.edu/~crary/819-f09/Backus78.pdf (read already, but cite in book)
• also cite The Connection Machine
• http://paulgraham.com/ilc03.html
• https://www.google.com/search?q=lenses+haskell
• http://www.seas.upenn.edu/~harmony/
• discussion around generic functions in protocols in Swift, and the difference between generics and type parameters (but see: https://news.ycombinator.com/item?id=7896161 ) (see also http://schani.wordpress.com/2014/06/11/associated-types-considered-weird/ and https://groups.google.com/forum/#!topic/swift-language/3PtydRXR0ao) and http://www.artima.com/weblogs/viewpost.jsp?thread=270195 and http://www.artima.com/forums/flat.jsp?forum=106&thread=270195
• https://github.com/petkaantonov/bluebird/wiki/Optimization-killers
• https://kentonv.github.io/capnproto/news/2014-06-17-capnproto-flatbuffers-sbe.html
• https://www.tbray.org/ongoing/When/201x/2014/06/20/Hating-Java-in-2014
• http://www.randomhacks.net/2005/12/03/why-ruby-is-an-acceptable-lisp/
• http://blog.fogus.me/2012/01/25/lisp-in-40-lines-of-ruby/
• http://fogus.me/fun/ , http://blog.fogus.me/ , http://www.fogus.me/talks/ , http://www.joyofclojure.com/
• http://en.wikipedia.org/wiki/Delimited_continuation
• http://gnuu.org/2009/03/21/demystifying-continuations-in-ruby/
• http://parametricity.net/dropbox/yield.subc.pdf
• diff b/t streams and lazy lists? http://existentialtype.wordpress.com/2011/04/24/the-real-point-of-laziness/
• http://en.m.wikibooks.org/wiki/Haskell/Applicative_Functors
• http://www.haskell.org/arrows/
• http://smellegantcode.wordpress.com/2010/02/21/rubys-yield/
• http://common-lisp.net/project/clazy/
• https://gist.github.com/staltz/868e7e9bc2a7b8c1f754 https://news.ycombinator.com/item?id=7964873
• https://github.com/shinh/sedlisp
• http://blog.andyet.com/2014/06/25/introducing-ampersand-js/
• http://www.infoq.com/presentations/Simple-Made-Easy
• https://www.google.com/search?client=ubuntu&channel=fs&q=writing+a+c+compiler&ie=utf-8&oe=utf-8
• more languages: https://www.google.com/search?client=ubuntu&channel=fs&q=Dan+Amelang%27s+Nile%2FGezira&ie=utf-8&oe=utf-8 , K, Awelon Bytecode,
• http://blog.cognitect.com/blog/2014/7/22/transit
  • https://news.ycombinator.com/item?id=8069346
  • 1. Protobuf 2. Avro 3. Thrift 4. MsgPack? 5. CORBA 6. ASN.1 7. Cap'n Proto 8. FlatBuffer?
  • http://json-ld.org/learn.html
• compare CEP and FRP. https://www.google.com/search?client=ubuntu&channel=fs&q=frp+cep&ie=utf-8&oe=utf-8#channel=fs&q=frp+cep+complex+event+processing+reactive&spell=1 . Current results include http://soft.vub.ac.be/REM13/papers/rem20130_submission_5.pdf , http://www.researchgate.net/publication/258225611_Ways_to_React_Comparing_Reactive_Languages_and_Complex_Event_Processing , http://msdn.microsoft.com/en-us/data/gg577609.aspx , http://reactive-extensions.github.io/RxJS/ , http://www.csw.inf.fu-berlin.de/debs2012/index.php/tutorials.html , http://www.infoq.com/interviews/ennis-events
• http://en.wikipedia.org/wiki/Functional_reactive_programming and http://www.haskell.org/haskellwiki/Functional_Reactive_Programming
• http://en.wikipedia.org/wiki/Complex_event_processing
• https://www.cs.utexas.edu/users/EWD/transcriptions/MCreps/MR34.html
• http://faculty.salisbury.edu/~xswang/research/papers/serelated/no-silver-bullet.pdf
• https://www.google.com/search?client=ubuntu&channel=fs&q=functional+reactive+programming+trading&ie=utf-8&oe=utf-8
• http://apfelmus.nfshost.com/blog/2011/05/06-frp-why-functors.html
• http://blog.startifact.com/posts/older/a-history-of-python-packaging.html
• http://dirtsimple.org/2011/08/wsgi-web-frameworks-and-requests.html
• https://python-packaging-user-guide.readthedocs.org/en/new_toc/history.html
• philip eby's trellis https://groups.google.com/forum/m/#!msg/comp.lang.lisp/BxnhKMEdfDw/q1banw9G1ngJ
• btw whats pj eby doing now?
  • the main one to read is this: http://www.eby-sarna.com/pipermail/peak/2007-June/002710.html
  • PyProtocols? (dead, but liked, at least by one guy), PEAK-Rules (and ABCs) http://www.eby-sarna.com/pipermail/peak/2011-March/003417.html
  • originally a fork of PJ Eby's Trellis: https://pypi.python.org/pypi/Reaction/0.2.2 https://groups.google.com/forum/m/#!forum/better-python http://www.eby-sarna.com/pipermail/peak/2009-July/thread.html
  • i havent yet looked thru the PEAK mailing list archives between 2007/06 and 2009/07
• "Just yesterday at work I had a good real-life use case for generic functions which deserved a blog post...Unfortunately, nobody in the Python world uses them (with the exception of P. J. Eby)..The aim of this blog post is to explain why a mixin solution is inferior to a generic functions solution." http://www.artima.com/weblogs/viewpost.jsp?thread=237764
• intros to graphics programming
  • https://github.com/stackgl/shader-school
  • http://pixelshaders.com/proposal/
• https://github.com/facebook/flux
• http://synthcode.com/blog/2009/06/Small_is_Beautiful
• http://stackoverflow.com/questions/1913621/is-there-a-simple-compiler-for-a-small-language
• http://stackoverflow.com/questions/2349468/starting-off-a-simple-the-simplest-perhaps-c-compiler
• http://prog21.dadgum.com/30.html
• http://www.reddit.com/r/programming/comments/lirke/simple_made_easy_by_rich_hickey_video/
• https://news.ycombinator.com/item?id=8186008 and http://lucumr.pocoo.org/2014/8/16/the-python-i-would-like-to-see/
• http://gleichmann.wordpress.com/2011/01/09/functional-scala-turning-methods-into-functions/
• http://open.umn.edu/opentextbooks/BookDetail.aspx?bookId=83
• https://news.ycombinator.com/item?id=8201191
• http://www.idsia.ch/~juergen/oopsweb/node41.html , http://www.idsia.ch/~juergen/oopsweb/oopsweb.html
• http://clubweb.interbaun.com/~rc/Timbre/
• http://alistair.cockburn.us/ASD+book+extract%3A+%22Naur,+Ehn,+Musashi%22
• http://www.cs.umd.edu/class/spring2003/cmsc838p/Design/criteria.pdf
• lathe and penknife: http://arclanguage.org/user?id=rocketnia
• http://www.tech-thoughts-blog.com/2013/06/first-steps-with-hy.html
• http://rocketnia.wordpress.com/
• http://wingolog.org/archives/2011/08/30/the-gnu-extension-language -- has some macro examples, and then a call-with-yield example, that i don't understand yet -- mb i should read On Lisp and/or SICP first
• http://www.ccs.neu.edu/scheme/pubs/pldi93-sitaram.pdf 1993 paper by Dorai Sitaram, Handling Control.
• section 3 ('language') of the paper Simon Marlow and Simon Peyton Jones, How to make a fast curry: push/enter vs eval/apply because that's what http://www.haskell.org/haskellwiki/Ministg implements (see also section 4 if clarification is needed)
• http://www.cs.cornell.edu/courses/CS2112/2012sp/lectures/lec27-12sp.pdf
• read the TOREAD hn comment section in rust.txt, which has some comments from https://news.ycombinator.com/item?id=8392138
• http://web.archive.org/web/20120505035519/http://blog.sigfpe.com/2007/07/data-and-codata.html
• http://lambda-the-ultimate.org/node/2273 : start with comment "Two Kinds Of Laziness"
• Alice Through the Looking Glass
• the second example on http://www.gnu.org/software/guile/manual/html_node/Dynamic-Wind.html#Dynamic-Wind
• mb http://arxiv.org/pdf/1307.5277v1.pdf http://lambda-the-ultimate.org/node/4791
• https://www4.in.tum.de/publ/papers/2007_pizka_juergens_svm.pdf
• http://www.cs.cornell.edu/~ross/publications/eqsat/eqsat_tate_lmcs11.pdf
• http://meta2012.pereslavl.ru/papers/2012_Proceedings_of_the_Third_International_Valentin_Turchin_Workshop_on_Metacomputation__meta2012.pdf
• http://stefan.saasen.me/articles/git-clone-in-haskell-from-the-bottom-up/
• http://devdriven.com/2014/10/piumarta-and-warths-open-objects-in-scheme/
• http://courses.cs.tamu.edu/jarvi/2011/CSCE-604/index.html
• http://www.cse.lehigh.edu/~gtan/paper/robusta.pdf (how the JVM can remain safe, eg like its verifier does, even while calling native code eg like with the JNI): Robusta: Taming the Native Beast of the JVM. J. Siefers, G. Tan, and G. Morrisett. In the 17th ACM Conference on Computer and Communication Security (CCS '10), Oct. 2010. [paper]
  • slides, and related work: http://www.ics.uci.edu/~guoqingx/oopsla-pc-workshop/slides/tan-SafeLangInterop.pdf
  • summary: SFI, and also analysis to look for common exception mishandling bugs
• https://news.ycombinator.com/item?id=8984648

compilers

• http://aosabook.org/en/llvm.html
• https://docs.racket-lang.org/nanopass/index.html

PL textbooks and intros and courses

• https://en.wikipedia.org/wiki/Programming_language#Further_reading Abelson, Harold; Sussman, Gerald Jay (1996). Structure and Interpretation of Computer Programs (2nd ed.). MIT Press. Raphael Finkel: Advanced Programming Language Design, Addison Wesley 1995. Daniel P. Friedman, Mitchell Wand, Christopher T. Haynes: Essentials of Programming Languages, The MIT Press 2001. Maurizio Gabbrielli and Simone Martini: "Programming Languages: Principles and Paradigms", Springer, 2010. David Gelernter, Suresh Jagannathan: Programming Linguistics, The MIT Press 1990. Ellis Horowitz (ed.): Programming Languages, a Grand Tour (3rd ed.), 1987. Ellis Horowitz: Fundamentals of Programming Languages, 1989. Shriram Krishnamurthi: Programming Languages: Application and Interpretation, online publication. (superceded, see below) Bruce J. MacLennan?: Principles of Programming Languages: Design, Evaluation, and Implementation, Oxford University Press 1999. John C. Mitchell: Concepts in Programming Languages, Cambridge University Press 2002. Benjamin C. Pierce: Types and Programming Languages, The MIT Press 2002. Terrence W. Pratt and Marvin V. Zelkowitz: Programming Languages: Design and Implementation (4th ed.), Prentice Hall 2000. Peter H. Salus. Handbook of Programming Languages (4 vols.). Macmillan 1998. Ravi Sethi: Programming Languages: Concepts and Constructs, 2nd ed., Addison-Wesley 1996. Michael L. Scott: Programming Language Pragmatics, Morgan Kaufmann Publishers 2005. Robert W. Sebesta: Concepts of Programming Languages, 9th ed., Addison Wesley 2009. Franklyn Turbak and David Gifford with Mark Sheldon: Design Concepts in Programming Languages, The MIT Press 2009. Peter Van Roy and Seif Haridi. Concepts, Techniques, and Models of Computer Programming, The MIT Press 2004. David A. Watt. Programming Language Design Concepts. John Wiley & Sons 2004.
  • http://papl.cs.brown.edu/2014/ (sequel to PLAI: http://cs.brown.edu/courses/cs173/2012/book/ )
  • http://www.cs.cmu.edu/~rwh/plbook/book.pdf Robert Harper Practical Foundations for Programming Languages
• read Design Concepts in Programming Languages (see http://web.eecs.umich.edu/~bchandra/courses/papers/Turbak_6.821/ )
• http://www.eecs.harvard.edu/~greg/cs256sp2005/
• http://www.cs.cmu.edu/~rjsimmon/15312-s14/schedule.html
• http://web.mit.edu/justom/Public/6.170/
• Cezzar, Ruknet. A Guide to Programming Languages: Overview and Comparison. ISBN 978-0-89006-8 (alternate, search)12-0. ? pretty old and i've only seen it referenced once (in the above wikipedia article) but one review liked it
• http://cs.lmu.edu/~ray/classes/pl/
• https://www.amazon.com/Programming-Language-Pragmatics-Fourth-Michael/dp/0124104096
• https://plzoo.andrej.com/index.html
• read sipl
• http://norvig.com/paip.html

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

PL design / big picture

• http://c2.com/cgi/wiki?InstantLanguageForm
• http://c2.com/cgi/wiki?MinimalistLanguage
• http://c2.com/cgi/wiki?StepsTowardTheReinventionOfProgramming
• http://c2.com/cgi/wiki?CategoryLanguageDesign
• http://c2.com/cgi/wiki?MergingMapsAndObjects
• http://c2.com/cgi/wiki?CategoryProgrammingLanguage
• http://c2.com/cgi/wiki?LittleLanguage
• http://c2.com/cgi/wiki?LargeAndSmallLanguages
• http://c2.com/cgi/wiki?NonOrthogonalLanguageFeatures
• http://c2.com/cgi/wiki?LanguageGotchas
• read http://www.cs.brown.edu/~sk/Publications/Books/ProgLangs/2007-04-26/
• read Seymour Papert's "Mindstorms" (http://worrydream.com/LearnableProgramming/ says you gotta read it)
• mb read http://dreamsongs.com/10ideas.html , http://dreamsongs.com/Feyerabend/Feyerabend.html
• mb read http://dreamsongs.com/Files/PatternOfLanguageEvolution.pdf
• mb read http://dreamsongs.com/Files/Incommensurability.pdf
• mb read http://dreamsongs.com/Files/PatternsOfSoftware.pdf
• mb read the famous design patterns book
• http://thechangelog.com/rich-hickeys-greatest-hits/
• https://www.destroyallsoftware.com/talks/wat
• http://www.cs.cmu.edu/~rwh/plbook/book.pdf

uncategorized papers

• Object-Oriented Programming Versus Abstract Data Types. William R. Cook ?
• Software Extension and Integration with Type Classes. Ralf Lammel and Klaus Ostermann
• [http://www​.andres-loeh.de/OpenDatatypes?.pdf Open Data Types and Open Functions Andres Loh, Ralf Hinze]
• Spin-offs from the Expression Problem . Ralf Lämmel
• http://lhorie.github.io/mithril-presentation-oct-js-tech-night/
• 1ML: http://www.mpi-sws.org/~rossberg/1ml/1ml.pdf http://lambda-the-ultimate.org/node/5121
• http://secretvolcanobase.org/~tef/papers/unix_prog_design.pdf
• generic programming

lists

• http://www.slant.co/topics/583/~what-are-the-best-programming-technical-talks
• http://blog.fogus.me/2011/09/08/10-technical-papers-every-programmer-should-read-at-least-twice/

designing and building language tutorials

• building a haskell: http://dev.stephendiehl.com/fun/
  • http://compilers.iecc.com/crenshaw/
  • http://home.iae.nl/users/mhx/crenshaw/tiny.html
• "Back in my day, if you wanted to independently learn compilers, ML or gcc were your only open source compilers to study, with the latter looking like incoherent chicken scratch scrawl. Now you have LLVM, OpenJDK?, Mono, Roslyn, PyPy?, LuaJIT?, etc. Kids these days."

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

• http://blog.fogus.me/2011/10/14/why-clojure-doesnt-need-invokedynamic-but-it-might-be-nice/
• http://stackoverflow.com/questions/10784124/non-lazy-branch-of-ghc
• http://scheme2006.cs.uchicago.edu/11-ghuloum.pdf
  • https://github.com/nathell/lithium

target languages / minimal languages / bytecode implementations

• http://caml.inria.fr/pub/papers/xleroy-zinc.pdf Xavier Leroy, "The ZINC experiment: An Economical Implementation of the ML Language", 1990]
• Here is an embedding of the simply-typed lambda calculus with an arbitrary collection of base types, tuples and a fixed point combinator:

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

• https://github.com/tonsky/datascript

graphs

• https://github.com/tinkerpop/gremlin/wiki
• https://github.com/graphite-ng/graphite-ng
• http://graphlab.org/graphchi/
• read http://lucacardelli.name/Papers/A%20Spatial%20Logic%20For%20Querying%20Graphs%20(ICALP).pdf and follow citations
• https://facebook.github.io/react/blog/2015/05/01/graphql-introduction.html
  • https://news.ycombinator.com/item?id=9473519
• An association-based model of dynamic behaviour
• http://zippy.github.io/ceptr/group__semtrex.html#details
  • http://www.codeproject.com/Articles/894188/Introducing-Semtrex
  • https://github.com/zippy/ceptr/wiki http://zippy.github.io/ceptr/index.html https://docs.google.com/document/d/1Line362Wm0zMOZcEZMqPYfHqNS4XIVyVsP7SS_4jE2o/edit http://ceptr.org/
• google search for graph regular expressions, graph regex, grex
• GP (see plbook)
• Extending C for Checking Shape Safety Mike Dodds and Detlef Plump

haskelly incld' category theory

• http://www.scs.stanford.edu/11au-cs240h/notes/ghc-slides.html
• haskell mtl monads library inspiration: http://web.cecs.pdx.edu/~mpj/pubs/springschool.html
• Scrap Your Boilerplate: A Practical Design Pattern for Generic Programming. Ralf Lammel and Simon Peyton Jones
• http://hackage.haskell.org/package/pipes-4.0.0/docs/Pipes-Tutorial.html
• http://hackage.haskell.org/package/conduit
• http://www.haskell.org/haskellwiki/Foldable_and_Traversable
• https://www.fpcomplete.com/school/starting-with-haskell
• Haskell frameworks: syb, o'haskell, olaf's stuff, quick
• http://www.haskellforall.com/2012/09/the-functor-design-pattern.html
• http://blog.ezyang.com/2014/09/open-type-families-are-not-modular/
• https://www.fpcomplete.com/school/to-infinity-and-beyond/pick-of-the-week/a-little-lens-starter-tutorial
• https://en.wikibooks.org/wiki/Haskell/Applicative_Functors
• https://www.google.com/search?q=haskell+ml+module+system
• https://www.google.com/search?q=haskell+ml+module+system+ocaml
• http://bartoszmilewski.com/2014/10/28/category-theory-for-programmers-the-preface/
• http://www.stephendiehl.com/posts/essential_haskell.html
• https://github.com/bitemyapp/learnhaskell
• http://dev.stephendiehl.com/hask/
• http://semantic-domain.blogspot.com/2015/03/abstract-binding-trees.html (recc. at the top of https://pchiusano.github.io/2015-04-23/unison-update7.html )
• haxl
• mb GADTs Meet Their Match: Pattern-Matching Warnings That Account for GADTs, Guards, and Laziness http://lambda-the-ultimate.org/node/526
• https://awelonblue.wordpress.com/2014/12/19/vcache-an-acid-state-killer/
• https://news.ycombinator.com/item?id=12177685 (thread on some mistakes in Haskell's type system that makes libraries hard, in the author's opinion)
• York Reduceon related:
  • https://www.cs.york.ac.uk/fp/reduceron/jfp-reduceron.pdf Fig. 1. Core syntax of F-lite
    • https://www.cs.york.ac.uk/fp/reduceron/memos/Memo9.txt
  • The reduceron's "template code" (its ISA): [3] section 2.7 page 8
• https://wiki.haskell.org/Generics and 'Generics in Haskell' chapter of [4]