see also [1]
higher priority / dont forget about these
General
urbit
introductions
interop
toreads unsorted
link Try adding a language with proof solving capabilities. ATS, Agda, Idris, Coq spring to mind. |
- 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
- 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://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
- 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?
- "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/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]
- https://news.ycombinator.com/item?id=8984648
compilers
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.
- 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
uncategorized papers
lists
designing and building language tutorials
- building a haskell: http://dev.stephendiehl.com/fun/
- "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
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
graphs
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://wiki.haskell.org/Generics and 'Generics in Haskell' chapter of [4]
- http://programmers.stackexchange.com/questions/279316/what-exactly-makes-the-haskell-type-system-so-revered-vs-say-java
- https://www.reddit.com/r/haskell/comments/27z7yw/is_there_such_a_thing_as_a_lowlevel_functional/
- what was that cross-language thingee that Steve mentioned once?
- https://www.reddit.com/r/haskell/comments/3zc81v/tradeoffs_of_dependent_types_xpost_from_ridris/
- https://www.quora.com/Are-there-any-minimal-functional-programming-languages
- http://groupoid.space/om.htm
- https://ro-che.info/articles/2016-02-03-finally-tagless-boilerplate
- Morte and Om stuff (see Morte and Om section)
- mb not https://ro-che.info/articles/2016-02-03-finally-tagless-boilerplate
- http://www.haskellforall.com/2014/10/how-to-desugar-haskell-code.html from 'monads' on (i already read before that)
- mb http://www.haskellforall.com/2014/12/a-very-general-api-for-relational-joins.html
- http://www.russbishop.net/monoids-monads-and-functors
- http://www.haskellforall.com/2012/05/scrap-your-type-classes.html "SYTC essentially says “hey, why don’t we pass around an object that describes the implementation of the contract that we care about, rather than having the compiler infer it for us?”. If you’re familiar with Scala, this is how they implement typeclasses in terms of implicit parameters. If you’re not, SYTC is equivalent to passing around a vtable whenever you want to invoke code on a dynamic target." [5]
- http://www.stephendiehl.com/posts/haskell_2017.html
- https://en.wikibooks.org/wiki/Haskell/Applicative_functors#A_sliding_scale_of_power
- https://github.com/hemanth/functional-programming-jargon
- http://www.michaelburge.us/2017/08/17/rolling-your-own-blockchain.html
- St, lenses, rank2 polymorphism, gadt
- https://reasonablypolymorphic.com/book/preface
- https://github.com/passy/awesome-recursion-schemes
- http://lambda-the-ultimate.org/story-selective-functors#comment
- http://brendanfong.com/programmingcats.html
- higher kinded types
- https://www.reddit.com/r/haskell/comments/glz389/examples_of_incorrect_abstractions_in_other/
- " > these aren't programming languages, they're data languages. Sounds like a job for free applicative functors, which are strictly less powerful than free monads (which you can imagine as the set of interpretable languages). From John De Goes's ScalaWorld? 2015 presentation: Free Functors: Programs that Change Values Free Applicatives: Programs that Build Data Free Monads: Programs that Build Programs "
- https://web.archive.org/web/20171202114607/https://medium.com/lazy-eval/applicative-functors-in-haskell-f509e1c764d3
- https://ncatlab.org/nlab/show/computational+trilogy rec. by https://lobste.rs/s/xhct5o/things_unlearned#c_yycxq0
- https://www.researchgate.net/publication/226525714_The_Design_of_a_Pretty-printing_Library
- https://github.com/ChrisPenner/wc
- https://eighty-twenty.org/2018/12/30/typeclassopedia
algebraic effects
Morte and Om
vms
pythonic
c ish / c y / cy
- simpler variants of C with small compilers
rusty
lispy
- 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] } }"
- similar to previous bullet point, the Lisp in The Roots of Lisp
- http://readevalprintlove.fogus.me/sakura/index.html 's Fluchtpunkt Lisps: T ( http://mumble.net/~jar/tproject/ ) , shen, http://www.newlisp.org/ , PicoLisp? , Wasp Lisp
- http://readevalprintlove.fogus.me/sakura/index.html : "PicoLisp? is, in my opinion, the most interesting entry in a family of really really small Lisps that also includes Nanolisp and femtoLisp, although I would hesitate to include these latter two in the Fluchtpunkt category"
- some of http://readevalprintlove.fogus.me/sakura/index.html 's practical lisps: Common Lisp, Clojure, Scheme (R5RS, R6RS, R7RS-big), Racket, Dylan
- http://readevalprintlove.fogus.me/sakura/index.html 's kernel lisps: R7RS-small, Scheme48, Lisp Machine Lisp, EuLisp?, and Kawa.
- http://readevalprintlove.fogus.me/sakura/index.html 's figure "
- read the rest of * http://readevalprintlove.fogus.me/sakura/index.html
- actually mb: Scheme, CL, Clojure, Arc, Racket, Shen
- List of LISP dialects to look at: Scheme, CL, Clojure, Arc, http://users.rcn.com/david-moon/PLOT/page-1.html, ELL (http://axisofeval.blogspot.com/2010/05/no-new-ideas-please.html), ??, see http://axisofeval.blogspot.com/2010/04/dylan-and-lisp-family-trees-central.html
- http://stackoverflow.com/questions/4135820/is-clojure-considered-lispy-or-schemey "Clojure is missing most of the "best" features from Scheme, such as fully-hygienic macros, proper tail-call optimization, first-class continuations, etc."
- http://norvig.com/lispy.py
- On Lisp
- mb read http://dreamsongs.com/CLOS.html
- http://replove.herokuapp.com/sakura/index.html and https://news.ycombinator.com/item?id=6355738 (start at the section with the word 'macrolet')
- http://aphyr.com/posts/301-clojure-from-the-ground-up-welcome
- http://www.infoq.com/interviews/hickey-clojure-protocols
- http://www.4clojure.com/
- http://www.infoq.com/interviews/hickey-clojure-reader
- http://arclanguage.org/best
- https://github.com/kanaka/mal
- https://github.com/jbush001/LispMicrocontroller HDL (Verilog or VHDL) implementation of a Lisp
- http://www.amazon.com/Lisp-Small-Pieces-Christian-Queinnec/dp/0521545668
- http://web.archive.org/web/20060518142405/http://www.international-lisp-conference.org/2005/media/dussud-slides.pdf
- https://www.google.com/search?q=macrology+scheme
- http://www.greghendershott.com/fear-of-macros/ (re: Racket)
- http://www.greghendershott.com/rackjure/
- http://docs.racket-lang.org/scribble/ documentation
- http://pkg-build.racket-lang.org/doc/sweet/index.html "an alternative to s-expressions"
- https://github.com/pixie-lang/pixie
- Christian Queinnec titled "Lisp in Small Pieces" or LISP (recc. by https://news.ycombinator.com/item?id=9742249 )
- https://en.wikipedia.org/wiki/ISLISP
- clojurescript.next, om.next: https://news.ycombinator.com/item?id=9848602
- http://www.sicpdistilled.com/
- Object-Oriented Programming in Common Lisp recc. by https://news.ycombinator.com/item?id=9352752 and https://news.ycombinator.com/item?id=9354611
- The Art of the Metaobject Protocol
- https://en.wikipedia.org/wiki/Fixed-point_combinator#Strict_fixed_point_combinator
- https://en.wikipedia.org/wiki/Fixed-point_combinator#Fixed_point_combinators_in_lambda_calculus
- http://typedclojure.org/
- http://norvig.com/lispy.html
- another random (toy?) lisp in python implementation: https://github.com/keithgabryelski/plisp/blob/master/plisp.py
- https://juxt.pro/blog/posts/generative-ui-clojure-spec.html
- https://news.ycombinator.com/item?id=10826431
- http://www.gigamonkeys.com/book/beyond-exception-handling-conditions-and-restarts.html
- http://www.ibm.com/developerworks/library/j-clojure-protocols/
- https://news.ycombinator.com/item?id=32383525
continuations
J
continuations
concurrency (and parallelism, and distributed systems)
- http://kilby.stanford.edu/~rvg/352.html
- https://aphyr.com/posts/313-strong-consistency-models
- Concurrency primitives (look at erlang, http://elixir-lang.org/, concurrent haskell, pH (parallel haskell), curry?),openmp, mpi, posix threads, http://en.wikipedia.org/wiki/Unified_Parallel_C , http://en.wikipedia.org/wiki/Unified_Parallel_C , Boost asio, Boost interprocess, Boost mpi, Boost thread, charm++, cilk, various IPC mechanisms from unix, bsd, and other languages, linda, ease, tuple spaces, http://skandium.niclabs.cl/ , http://en.wikipedia.org/wiki/Intel_Threading_Building_Blocks , http://en.wikipedia.org/wiki/Sieve_C%2B%2B_Parallel_Programming_System , http://en.wikipedia.org/wiki/Chapel_programming_language , http://en.wikipedia.org/wiki/X10_%28programming_language%29 , http://software.intel.com/en-us/intel-mkl/ , http://en.wikipedia.org/wiki/ACML , gpgpu , cell, dsp , encryption, mpeg en/decoding, http://golang.org/doc/effective_go.html#concurrency ,
- Python Copperhead uses the (Nvidia) Thrust library to run on CUDA, TBB (Thread Building Blocks), or OpenMP?
- glitch managed time paper: http://research.microsoft.com/apps/pubs/default.aspx?id=211297
- Programming with Managed Time. Sean McDirmid? Jonathan Edwards
- Norman Ramsey and Simon Peyton Jones. Featherweight concurrency in a portable assembly language
- http://davidad.github.io/blog/2014/03/23/concurrency-primitives-in-intel-64-assembly/
- http://clojure.com/blog/2013/06/28/clojure-core-async-channels.html https://news.ycombinator.com/item?id=5959773 http://blog.drewolson.org/blog/2013/07/04/clojure-core-dot-async-and-go-a-code-comparison/ https://news.ycombinator.com/item?id=5991806 http://rigsomelight.com/2013/07/18/clojurescript-core-async-todos.html http://news.ycombinator.com/item?id=6070736
- http://blog.paralleluniverse.co/post/49445260575/quasar-pulsar#fnref:3
- http://blog.paralleluniverse.co/post/49445260575/quasar-pulsar
- http://blog.paralleluniverse.co/post/64210769930/spaceships2
- http://assets.en.oreilly.com/1/event/27/A%20Survey%20of%20Concurrency%20Constructs%20Presentation.pdf
- https://www.google.com/search?client=ubuntu&channel=fs&q=concurrent+programming+language
- https://www.fpcomplete.com/school/advanced-haskell/beautiful-concurrency
- https://blog.mozilla.org/javascript/2015/02/26/the-path-to-parallel-javascript/
- GPU Programming course
- https://omohundro.files.wordpress.com/2009/03/omohundro86_the_essential_starlisp_manual.pdf
- http://www.cs.cmu.edu/~blelloch/papers/Ble90.pdf esp paralation lisp
- https://blogs.msdn.microsoft.com/ashleyf/2013/10/13/programming-the-f18/
- mb http://www.albahari.com/threading/
- mb http://sdiehl.github.io/gevent-tutorial/
- mb https://www.goinggo.net/2013/09/detecting-race-conditions-with-go.html
- https://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html
- http://libdispatch.macosforge.org/
- http://wayback.archive.org/web/20101202000829/http://www.macruby.org/documentation/gcd.html
- tensorflow, which bills itself as a general dataflow framework, etc
- process calculi
- http://theory.stanford.edu/~rvg/branching/branching.html
- https://en.wikipedia.org/wiki/Temporal_logic
- how is it that quantum computing different from NFAs eg letting you just run embarrassingly parallel things in parallel and computing NP-complete stuff quickly?
- https://wingolog.org/tags/concurrency (rec by https://news.ycombinator.com/item?id=12890307)
- http://llvm.org/devmtg/2016-11/Slides/Nishanov-LLVMCoroutines.pdf
- https://webkit.org/blog/7846/concurrent-javascript-it-can-work/
- https://cacm.acm.org/magazines/2008/11/537-software-transactional-memory-why-is-it-only-a-research-toy/fulltext
- https://github.com/rust-lang/rfcs/blob/0806be4f282144cfcd55b1d20284b43f87cbe1c6/text/0230-remove-runtime.md
- http://joeduffyblog.com/2015/11/03/blogging-about-midori/
- https://www.infoq.com/presentations/rust-2019/
- https://bugs.ruby-lang.org/issues/17100 ruby ractor
- https://github.com/TimelyDataflow/timely-dataflow
- https://github.com/WebAssembly/threads/blob/master/proposals/threads/Overview.md
- https://vorpus.org/blog/notes-on-structured-concurrency-or-go-statement-considered-harmful/ and https://lobste.rs/s/8msejg/notes_on_structured_concurrency_go
- https://www.infoq.com/presentations/rust-2019/
- https://begriffs.com/posts/2020-03-23-concurrent-programming.html
- discussion: https://news.ycombinator.com/item?id=22672128
- quote from discussion: "Next article in the series: now that you know about the dangerous/complicated primitives, don't ever touch them again. Instead use the high-level safe concurrency/parallelism mechanisms in your programming language: futures/promises, nurseries, channels, observers, actors, monitors. Ideally, these should be built-in, but a library whose API composes well into most programs will also do. Data races can be statically removed by carefully restricting certain parts of the language design, see Pony."
- The road to OCaml 5.0 cites some papers and links regarding the new multicore OCaml design
- https://blog.dziban.net/coroutines/
paradigms
functional
metaprogramming
macros
theory
DSLs
- Design Principles for Internal Domain-Specific Languages: A Pattern Catalog illustrated by Ruby. Sebastian Gunther and Thomas Cleenewerck
evaluation strategy
call-by-text and fexprs
types
- Introductory resources to type theory for language implementers
- https://en.wikipedia.org/wiki/Type_system
- read Types and Programming Languages by Pierce, mb read http://www.mpi-sws.org/~dreyer/ats/papers/harper-tspl.pdf
- read Software Foundations by Pierce et al https://www.cis.upenn.edu/~bcpierce/sf/current/index.html
- https://github.com/jozefg/learn-tt
- Barendregt, Lambda calculi with types (1991)
- https://en.wikipedia.org/wiki/Pure_type_system#Notes and https://en.wikipedia.org/wiki/Pure_type_system#Implementations
- not sure that i want to read this, but just putting it here for reference: http://cs.au.dk/~amoeller/papers/tajs/paper.pdf (the paper by Anders Møller on typing javascript, success typings, and abstract interpretation with the lattice diagrams in it)
- Adam Megacz says "Phil Wadler's excellent Proofs are Programs: 19th Century Logic and 21st Century Computing and Mike Gordon's From LCF to HOL should be required starting points for anybody interested in programming languages and type systems. ":
- read A Theory of Objects by Martín Abadi, Luca Cardelli
- http://www.eecs.harvard.edu/~greg/cs256sp2005/lec15.txt
- http://www.stephanboyer.com/post/39/covariance-and-contravariance
- https://www.google.com/search?client=ubuntu&channel=fs&q=coercive+inclusive+subtype
- Self-Representation in Girard’s System U http://compilers.cs.ucla.edu/popl15/popl15-full.pdf
- Second-order logic explained in plain English
- http://bracha.org/pluggableTypesPosition.pdf
- https://en.wikipedia.org/wiki/Type_rule
- https://github.com/tomprimozic/type-systems
- https://news.ycombinator.com/item?id=7530644
- some papers on gradual typing
- in the 'is sound gradual typing dead?' paper, it notes that sound gradual typing systems, which i presume are inserting type checks when a dynamically typed value is passed to statically typed code, on many benchmarks have 100x overhead over untyped code! i guess this is because it can be more work to check that the entire type of the value is correct when it is passed in than just to check that it has the properties you need, IF you end up needing them? i guess one way around this would be to just leave all code untyped whenever partially typed stuff is linked in (!) or to do whole-program analysis to see which values are already typed and which aren't, and only use the statically typed code for values that are already typed
- Types and Static Type Checking (Introducing Micro-Haskell)
- Semantics of programming languages
- https://wiki.haskell.org/Monomorphism_restriction
- mb: http://okmij.org/ftp/Haskell/types.html
- https://www.google.com/search?q=type+erasure+vs+reified+generics
- http://clojure.org/about/spec
- No value restriction is needed for algebraic effects and handlers has something to do with 'true reference cells' and effect systems
- How to Build Static Checking Systems Using Orders of Magnitude Less Code using incomplete language grammars (“micro-grammars”)
- Set-Theoretic Types for Polymorphic Variants improved type system for OCaml 'polymorphic variants' at the expense of deterministic type inference
- https://www.researchgate.net/publication/2952858_Henk_A_Typed_Intermediate_Language
- https://www.google.com/search?q=liquid+types&ie=utf-8&oe=utf-8
- http://fantom.org/forum/topic/1433 starting with comment jodastephen Sun 6 Mar 2011 (i already read all the comments above that one)
- https://wiki.haskell.org/Generics and chapters 3-7 of [13]
- remember to read up on those problems with gradual typing (where it seemed like there was 'local minima' after you start giving type annotations but before you finish)
- http://mathoverflow.net/questions/18089/what-is-the-manner-of-inconsistency-of-girards-paradox-in-martin-lof-type-theor
- the Curry–Howard? correspondence
- [14] says " I highly reccomend you read, "Localized type inference of atomic types in python" by Brett Cannon (2005), it shines a light on just how much this doesn't work. " in response to another comment
- https://www.reddit.com/r/Python/comments/1or1hn/type_inferencechecking_projects/
- http://cstheory.stackexchange.com/questions/33361/church-rosser-property-for-dependently-typed-lambda-calculus
- http://maiavictor.github.io/2015/11/18/church-scott-perigot-encodings/
- http://www.hedonisticlearning.com/posts/understanding-typing-judgments.html
- https://www.google.com/search?q=MLTT+type+theory
- https://www.google.com/search?q=PTS+SAR+notation%2C+given+by+Barendregt
- http://adam.chlipala.net/cpdt/
- https://en.wikipedia.org/wiki/Calculus_of_constructions
- http://stackoverflow.com/questions/3112725/advantages-of-scalas-type-system
- http://lampwww.epfl.ch/~odersky/papers/mfcs06.pdf
- System F_{<:}^w "Subtyping however is not represented in the ((lambda)) cube, even though systems like F <: ω {\displaystyle F_{<:}^{\omega }} F^\omega_{<:}, known as higher-order bounded quantification, which combines subtyping and polymorphism are of practical interest, and can be further generalized to bounded type operators. Further extensions to F <: ω {\displaystyle F_{<:}^{\omega }} F^\omega_{<:} allow the definition of purely functional objects; these systems were generally developed after the lambda cube paper was published.[1]"
- https://en.wikipedia.org/wiki/Simply_typed_lambda_calculus
- understand this comment: "In Haskell those types actually support more powerful functionality (like foldMap and traverse which are my main go to examples)"
- understand "parametricity"
- scala and path dependent types for dependent typing: http://stackoverflow.com/questions/12935731/any-reason-why-scala-does-not-explicitly-support-dependent-types
- http://typelevel.org/blog/2016/08/21/hkts-moving-forward.html
- https://en.wikipedia.org/wiki/Higher-order_abstract_syntax
- http://programmers.stackexchange.com/questions/167975/is-haskells-type-system-formally-equivalent-to-javas
- https://hexdocs.pm/elixir/typespecs.html
- https://news.ycombinator.com/item?id=13950649
- match-bounded polymorphism: https://www.cs.princeton.edu/courses/archive/fall98/cs441/mainus/node28.html and https://www.google.com/search?q=match-bounded+polymorphism&ie=utf-8&oe=utf-8
- https://www.reddit.com/r/haskell/comments/66p7s7/the_influence_of_dependent_types_stephanie_weirich/
- https://www.cs.uoregon.edu/research/summerschool/summer15/curriculum.html , Basic Proof Theory — Frank Pfenning , rec. by https://news.ycombinator.com/item?id=14722383
- http://leanprover.github.io/
- http://lucacardelli.name/Papers/TypefulProg.pdf
- 1ML, MLsub, Liquid Haskell
- https://stackoverflow.com/questions/41557954/practical-applications-of-rank-2-polymorphism
- http://okmij.org/ftp/Computation/typeclass.html
- http://ropas.snu.ac.kr/~kwang/520/pierce_book.pdf
- "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."
- https://ucsd-progsys.github.io/liquidhaskell-blog/
- https://mitpress.mit.edu/books/little-typer
- Modular implicits. Looks really good and clear, i might have to buckle down and read it. About an extension to OCaml based on Scala's 'implicits' to allow Haskell-typeclass like stuff. Like type classes but without the requirement that each typeclass only has a single implementation throughout the program -- instead allows lexically scoped choices of implementation. Contains in-depth comparison between Haskell's approach, Scala's approach, and their own. Also briefly compares to C++ concepts. Sounds like a clear exposition of the sort of approach that i probably want to take (but i'll have to understand it first).
- https://without.boats/blog/the-problem-of-effects/
- https://news.ycombinator.com/item?id=25352922
- https://counterexamples.org/
- https://jaredforsyth.com/posts/whats-cool-about-unison/#Algebraic-Effects-called-quot-Abilities-quot-in-the-unison-world which rec.s https://www.eff-lang.org/handlers-tutorial.pdf and https://doi.org/10.1145/2544174.2500590 noting that Unison uses what those papers call 'shallow handlers'
- https://www.foonathan.net/2021/07/concepts-structural-nominal/
- https://www.google.com/search?q=how%20to%20implement%20a%20type%20system
- https://conferences.oreilly.com/oscon/oscon-or-2019/public/schedule/detail/75709.html
- https://github.com/tomprimozic/type-systems
- https://lexi-lambda.github.io/blog/2020/01/19/no-dynamic-type-systems-are-not-inherently-more-open/
- https://blog.asana.com/2020/01/typescript-quirks/
- https://incrementalelm.com/opaque-types-let-you-think-locally/
- consider https://www.w3.org/TR/owl2-profiles/#OWL_2_EL , an ontology language with polytime inference (it's a restrictive description logic)
- https://www.researchgate.net/publication/305560717_Semantic_Object-Oriented_Programming_SOOP
- https://arxiv.org/abs/1907.00855 Type Checking Program Code using SHACL (Extended Version)
- trioo
- https://news.ycombinator.com/item?id=25352922
- https://mukulrathi.com/create-your-own-programming-language/intro-to-type-checking/#typing-expressions
- Complete and Easy Bidirectional Typechecking for Higher-Rank Polymorphism
- https://www.cs.cmu.edu/~fp/courses/15312-f04/handouts/15-bidirectional.pdf
- https://www.tweag.io/blog/2021-10-21-tcplugins-1/
- * https://www.tweag.io/blog/2021-12-09-tcplugins-2/
- https://www.cs.cmu.edu/~fp/courses/15312-f04/handouts/
- Bidirectional Typing
- https://bracha.org/pluggableTypesPosition.pdf
- https://hirrolot.github.io/posts/why-static-languages-suffer-from-complexity.html
- https://hirrolot.github.io/posts/how-to-keep-lambda-calculus-simple.html
- https://gist.github.com/Hirrolot/27e6b02a051df333811a23b97c375196
- https://gist.github.com/Hirrolot/89c60f821270059a09c14b940b454fd6
provers
high assurance and small core stuff from nickpsecurity
math
OOP
" Another key point is his arguing for extreme late-binding. What does that mean? Well, consider this code:
my $order = OrderFactory?->fetch(%order_args); my $invoice = $order->invoice;
If you have multiple "order" classes, you may not know which class you are dealing with, so you can't know, at compile time which invoice method you're calling. OOP languages generally don't select (bind) the method (invoice) for the invocant ($order) until run time. Otherwise, polymorphism can't work.
But what's extreme late binding? Does the invoice method exist? In a language like Java, that code won't even compile if the method doesn't exist. It might even be dead code that is never called, but you can't compile it if that method isn't there. That's because Java at least checks to ensure that the method exists and can be called.
Another key point is his arguing for extreme late-binding. What does that mean? Well, consider this code:
my $order = OrderFactory?->fetch(%order_args); my $invoice = $order->invoice;
If you have multiple "order" classes, you may not know which class you are dealing with, so you can't know, at compile time which invoice method you're calling. OOP languages generally don't select (bind) the method (invoice) for the invocant ($order) until run time. Otherwise, polymorphism can't work.
But what's extreme late binding? Does the invoice method exist? In a language like Java, that code won't even compile if the method doesn't exist. It might even be dead code that is never called, but you can't compile it if that method isn't there. That's because Java at least checks to ensure that the method exists and can be called.
For many dynamic languages, such as Perl (I ♥ Perl), there's no compilation problem at all because we don't bind the method to the invocant until that code is executed, but you might get a panicked 2AM call that your batch process has failed ... because you might have encapsulation, but not isolation. Oops. . This is "extreme" late binding with virtually no checks (other than syntax) performed until runtime. ... Extreme late-binding is important because Kay argues that it permits you to not commit too early to the "one true way" of solving an issue (and thus makes it easier to change those decisions), but can also allow you to build systems that you can change while they are still running! "
this post goes into that too:
https://softwareengineering.stackexchange.com/questions/301919/object-oriented-late-binding
" “Binding” refers to the act of resolving a method name to a piece of invocable code. Usually, the function call can be resolved at compile time or at link time. An example of a language using static binding is C:
int foo(int x);
int main(int, char) { printf("%d\n", foo(40)); return 0; }
int foo(int x) { return x + 2; }
Here, the call foo(40) can be resolved by the compiler. This early allows certain optimizations such as inlining. The most important advantages are:
we can do type checking
we can do optimizations
On the other hand, some languages defer function resolution to the last possible moment. An example is Python, where we can redefine symbols on the fly:
def foo(): """"call the bar() function. We have no idea what bar is.""" return bar()
def bar(): return 42
print(foo()) # bar() is 42, so this prints "42"
- use reflection to overwrite the "bar" variable locals()["bar"] = lambda: "Hello World"
print(foo()) # bar() was redefined to "Hello World", so it prints that
bar = 42 print(foo()) # throws TypeError?: 'int' object is not callable
This is an example of late binding. While it makes rigorous type checking unreasonably (type checking can only be done at runtime), it is far more flexible and allows us to express concepts that cannot be expressed within the confines of static typing or early binding. For example, we can add new functions at runtime.
Method dispatch as commonly implemented in “static” OOP languages is somewhere in between these two extremes: A class declares the type of all supported operations up front, so these are statically known and can be typechecked. We can then build a simple lookup table (VTable) that points to the actual implementation. Each object contains a pointer to a vtable. The type system guarantees that any object we get will have a suitable vtable, but we have no idea at compile time what the value of this lookup table is. Therefore, objects can be used to pass functions around as data (half the reason why OOP and function programming are equivalent). Vtables can be easily implemented in any language that supports function pointers, such as C.
...
This kind of method lookup is also known as “dynamic dispatch”, and somewhere in between of early binding and late binding. I consider dynamic method dispatch to be the central defining property of OOP programming, with anything else (e.g. encapsulation, subtyping, …) to be secondary. ... While this is late-ish binding, this is not the “extreme late binding” favoured by Kay. Instead of the conceptual model “method dispatch via function pointers”, he uses “method dispatch via message passing”. This is an important distinction because message passing is far more general. In this model, each object has an inbox where other objects can put messages. The receiving object can then try to interpret that message. The most well-known OOP system is the WWW. Here, messages are HTTP requests, and servers are objects. ... The power of message passing is that it scales very well: no data is shared (only transferred), everything can happen asynchronously, and objects can interpret messages however they like. This makes a message passing OOP system easily extendable. I can send messages that not everyone may understand, and either get back my expected result or an error. The object need not declare up front which messages it will respond to. "
frameworks and libs
major languages , applications
- http://www.pyret.org/
- Look at Self, Io, Ruby, Perl6, F#, smalltalk, Clean, prolog, curry, haskell, erlang, fourth, mercury, alloy, Oz, beta, J, eiffel, occam (CSP, channel r/w), occam-pi (+ pi-calc stuff; see https://www.cs.kent.ac.uk/research/groups/plas/wiki/OccamPiReference), lorel (db highly cited), datalog (db, pierre likes. it's a "positive language with fixpoint", mb struql ("on the equivalence of recursive and nonrecursive programs"), stackless python, perl moose, http://www.onyxneon.com/books/modern_perl/index.html, Sage theorem prover, Common Lisp Object System , C#, smalltalk (is 'everything is a node' just the same as 'everything is an object'?), Chapel (milewski likes it: http://bartoszmilewski.com/2011/11/07/supercomputing-in-seattle/ ), Shen (was: qi), coq (see http://www.cis.upenn.edu/~bcpierce/sf/ ), http://en.wikipedia.org/wiki/Refal, subtext, OCaml, urbit's nock and hoon, http://www.urbit.org/2013/08/22/Chapter-2-nock.html , OMeta ,
- Look at recent new languages; julia, boo, alice, F#, clojure, C#, D, timber, go, fortress, newspeak, nemerle, potion, cobra, falcon, Fantom, factor, mythryl, felix, scratch, scala, http://c2.com/cgi/wiki?AwelonProgrammingLanguage, Go, eve, http://cdent.org/, http://github.com/manuel/ell/blob/master/KERNEL.org, (Robert Fischer's stuff: http://github.com/RobertFischer/ashlar, http://kenai.com/projects/duby/ ), coffescript, http://www.dartlang.org/ , http://winningraceconditions.blogspot.com/2012/09/rust-0-index-and-conclusion.html , powershell , https://wiki.gnome.org/Vala/Tutorial , http://elixir-lang.org/ , http://amber-lang.net/ , http://nimrod-code.org/index.html (emphasis on close-to-the-metal), julia (numerics) , " my main GUI programming language (a modern version of hypertalk - http://www.runrev.com) ", http://maude.cs.uiuc.edu/ , axis of eval guy's language https://github.com/manuel/wat-js ( ) , also https://github.com/manuel/taf ( http://manuel.github.io/taf/doc/plan.html http://axisofeval.blogspot.com/2013/02/tafs-translation-to-ocaml-for-type.html ) , http://web.cs.wpi.edu/~jshutt/kernel.html , awelon , http://research.microsoft.com/en-us/people/dimitris/pie.pdf , https://en.wikipedia.org/wiki/Lava_%28programming_language%29 , Ur/Web , https://bitbucket.org/munificent/magpie, cyclone , https://github.com/pete/roboto , http://www.vitanuova.com/inferno/papers/sh.html (recc. by http://debu.gs/entries/inferno-part-0-namespaces , see also "I’d like to write some about the shell, mostly in the form of examples. If you are interested but do not want to wait, the article written by the author of the shell is a great introduction, and I have a solution on Github for my favorite Project Euler problem which should serve as a fun example of doing math in the shell. It may look a bit messy; after all, the shell is not for math. But comparing it to the roughly equivalent bash solution (including the timing information) is illuminating." on that page, links https://github.com/pete/euler/blob/master/infernosh/031.sh https://github.com/pete/euler/blob/master/bash/031.sh ) , "OBJ2 is a programming language with Clear-like parametrised modules and a functional system based on equations." -- has homomorphisms on modules called 'views' , Sweeney's language "lambda aleph": http://www.leafpetersen.com/leaf/publications/dtp2013/lambda-aleph-overview.pdf , http://arxiv.org/pdf/1307.5277v1.pdf , Cayenne , https://wiki.gnome.org/Vala/About , Ceylon , http://faculty.hampshire.edu/lspector/push3-description.html , http://convergepl.org/about.html , https://en.wikipedia.org/wiki/Scratch_%28programming_language%29
- https://news.ycombinator.com/item?id=10926038
- perl 6
- Logic programming primitives (look at prolog, curry)
- verilog, VHDL
- openCL, Cell processor, RapidMind? Multi-core Development Platform, http://en.wikipedia.org/wiki/OpenCL#Libraries
- openCL, pthreads, MPI, map-reduce
- git
- squeak
- Relational algebra and relational calculus
- xpath
- http://www.learnprolognow.org/
other languages
math: Maple Mathcad Maxima Sage
- computer algebra systems; theorem-proving assistants
- disciple Haskell variant
- "Disciple Core is an explicitly typed languages based on System-F2, intended as an intermediate representation for a compiler. In addition to the features of System-F2 it supports region, effect and closure typing. Evaluation order is left-to-right call-by-value by default, but explicit lazy evaluation is also supported. There is also a capability system to track whether objects are mutable or constant, and to ensure that computations that perform visible side effects are not suspended with lazy evaluation. "
- some primitives: http://disciple.ouroborus.net/wiki/Language/Transforms http://disciple.ouroborus.net/wiki/Tutorial/Core/Transforms
- http://www.kevinalbrecht.com/code/joy-mirror/j00rat.html
- http://www.kevinalbrecht.com/code/joy-mirror/j08cnt.html
- Plan9, Minix, VPRI, and Squeak
- Processing, http://wiring.org.co/ , http://arduino.cc/en/Reference/HomePage
- Look at other misc languages? limbo, occam, newspeak, newsqueak, csp, stackless python, bitc, typed scheme, modula-3, lua, rebol, ometa, http://www.chrisseaton.com/katahdin/, E (http://www.skyhunter.com/marcs/ewalnut.html), javascript. see also "timed cc" model by carlos olarte et al "concurrent constraint calculi", icon, snobal, groovy/grails, rails, http://c2.com/cgi/wiki?CecilLanguage, dylan, merd, Bliss (PDP-10 C-level language that Shivers liked: http://www.paulgraham.com/thist.html ), http://code.google.com/p/anic/, E: http://www.erights.org/elang/intro/index.html http://www.erights.org/elang/quick-ref.html, Tcl, kotlin, http://www.rust-lang.org/, http://en.wikipedia.org/wiki/Agda_%28programming_language%29 (apparently Coquand himself like Agda now? i found a course of his with Agda code. see also http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.AgdaVsCoq . This guy prefers Coq just because it has tactics: http://adam.chlipala.net/cpdt/html/Intro.html ) , epigram, http://idris-lang.org/ , http://asmjs.org/spec/latest/, Joss (alan kay likes Joss better than BASIC)
- pico, just because it's small: http://en.wikipedia.org/wiki/Pico_%28programming_language%29
- look at LIBRA for some library ops
- recc. by http://stackoverflow.com/questions/3958630/what-are-important-languages-to-learn-to-understand-different-approaches-and-con?rq=1 : datalog, J, Factor/Forth, Oz, JavaScript?, IO, Self, CLIPS, Frink, QI, Erlang (and presumably Clojure)
- interesting language for its conciseness (if not its platform): https://github.com/seliopou/typo
quotes / move to book
- interesting note on which conferences are interested in programming language design: http://alarmingdevelopment.org/?p=451#more-451
- related: http://tagide.com/blog/2012/03/research-in-programming-languages/ "there appears to be no correlation between the success of a programming language and its emergence in the form of someone’s doctoral or post-doctoral work"
- "I was invited to contribute an article on Python to HOPL-III, the third installment of ACM's prestigious History of Programming Languages conference, held roughly every ten years. Unfortunately, the demands of the rather academically inclined reviewers were too much for my poor hacker's brain. Once I realized that with every round of review the amount of writing left to do seemed to increase rather than decrease, I withdrew my draft. Bless those who persevered, but I don't believe that the resulting collection of papers gives a representative overview of the developments in programming languages of the past decade." -- http://neopythonic.blogspot.com/2009/01/history-of-python-introduction.html Guido van Rossum, inventor of Python
- "An earlier version was rejected from POPL 2007. Based on the reviews I received and comments from Simon Peyton-Jones, I revised the paper and submitted it to TOPLAS, but it was again rejected. It may be possible to write a paper about PlusCal? that would be considered publishable by the programming-language community. However, such a paper is not the one I want to write. For example, two of the three TOPLAS reviewers wanted the paper to contain a formal semantics--something that I would expect people interested in using PlusCal? to find quite boring. (A formal TLA+ specification of the semantics is available on the Web.) I therefore decided to publish it as an invited paper in the ICTAC conference proceedings." -- http://research.microsoft.com/en-us/um/people/lamport/pubs/pubs.html , comments from Leslie Lamport on a paper. Leslie Lamport invented the Paxos commit algorithm and did other important work on concurrency ( http://en.wikipedia.org/wiki/Leslie_Lamport ).
- "In 2002 I introduced Onward!, which is a track or subconference for new ideas and new thinking. Sort of an antidote to the salami-slice approach to computer-science research (normal science in Kuhn's terminology)." -- http://dreamsongs.com/OOPSLA.html -- noted Lisp expert
- "Programming Languages Are for People...The point of programming languages is to prevent our poor frail human brains from being overwhelmed by a mass of detail...Architects know that some kinds of design problems are more personal than others. One of the cleanest, most abstract design problems is designing bridges. There your job is largely a matter of spanning a given distance with the least material. The other end of the spectrum is designing chairs. Chair designers have to spend their time thinking about human butts. Software varies in the same way. Designing algorithms for routing data through a network is a nice, abstract problem, like designing bridges. Whereas designing programming languages is like designing chairs: it's all about dealing with human weaknesses."
- "The current outcome is *extremely* frustrating. While the blind spots here were real, we were driven by the requirements of the academic research community to spend nearly three years finding a way to do complete inference over mutability. That was an enormous effort, and it delayed our recognition that we were sitting on the wrong kind of underlying type system entirely. While I continue to think that there is some value in mutability inference, I think it's a shame that a fairly insignificant wart in the original inference mechanism managed to prevent larger-scale success in the overall project for what amount to *political* reasons. If not for that distraction, I think we would probably have learned enough about the I/O and the instance coherency issues to have moved to a different type system while we still had a group to do it with, and we would have a working and useful language today." -- http://www.coyotos.org/pipermail/bitc-dev/2012-March/003300.html
- "Choosing the best notation is the entire problem of programming language design, and this problem is neither mathematical nor scientific. A programming language is a user interface for programmers" -- http://unqualified-reservations.blogspot.com/2007/08/whats-wrong-with-cs-research.html
- My conclusions are (a) programming language design is primarily a humanity, secondarily engineering, and also has a little bit of math and science mixed in. But CS academia promotes based on math and science accomplishments, not humanities accomplishments. (b) CS promotes and pays for discovering, not for doing and certainly not for maintaining. But most of the labor in making a useful programming language is doing and maintaining.
- in longer form: that computer science academia forces researchers to spend their time on the sort of task for which you have formal results, whereas programming language design is more like architecture, a mixture of humanities and science. In addition, i'll make my own observations: (a) it can be hard for an untenured researcher to gain tenure if they spend all their time creating a solid reimplemention of a mixture of old ideas. (b) it can be hard to get grants to support maintaining old software. Together, this suggests that young academics are strongly discouraged from spending their most of their time expanding an initially promising kernel for a language into a large, practically useful, well-maintained implementation.
- note that many of the most popular functional programming languages have some major contributors from industry, e.g. Haskell and F# both have some guys at microsoft research.
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
- http://concurrencykit.org/
- https://aphyr.com/posts/313-strong-consistency-models
- https://en.wikipedia.org/wiki/Consistency_model
- https://en.wikipedia.org/wiki/Non-blocking_algorithm esp wait-free vs lock-free vs obstruction-free
- https://en.wikipedia.org/wiki/Readers%E2%80%93writer_lock
- https://en.wikipedia.org/wiki/Synchronization_%28computer_science%29
- https://en.wikipedia.org/wiki/Spinlock
- http://www.slideshare.net/deanwampler/reactive-design-languages-and-paradigms slide 17+ notes on ootConcurrencyNotes2
- https://github.com/niwinz/niwi-slides/blob/master/2014/concurrency/content.asciidoc
- understand https://github.com/jhusain/compositional-functions
- http://whiteknight.github.io/2011/04/30/vision_parrot_concurrency_3.html
- http://niner.name/Hybrid_Threads_for_the_Parrot_VM.pdf
- 'parallel library' list that includes both state-threads and libmill (which i heard of independently as helping to provide Goroutine-ish stuff): https://github.com/htoooth/the-guide-of-high-performance-geo-computing/blob/master/chapter/3.md#7-%E5%B9%B6%E8%A1%8C%E7%B1%BB%E5%BA%93
- https://en.wikipedia.org/wiki/%CE%A0-calculus https://en.wikipedia.org/wiki/Process_calculus and https://en.wikipedia.org/wiki/Actor_model_and_process_calculi_history https://en.wikipedia.org/wiki/Process_calculus#Mathematics_of_processes
- learn pi-calculus, Actors, petri nets, CSP, CCS, ACP, LOTOS, π-calculus, ambient calculus, PEPA, fusion calculus, join calculus
- already wrote these down in plPartConcurrency: "Leading examples of process calculi include CSP, CCS, ACP, and LOTOS.[1] More recent additions to the family include the π-calculus, the ambient calculus, PEPA, the fusion calculus and the join-calculus." "CCS, CSP, and ACP constitute the three major branches of the process calculi family: the majority of the other process calculi can trace their roots to one of these three calculi" "Various process calculi have been studied and not all of them fit the paradigm sketched here. The most prominent example may be the ambient calculus. " "The use of channels for communication is one of the features distinguishing the process calculi from other models of concurrency, such as Petri nets and the Actor model (see Actor model and process calculi)." [16]
- https://en.wikipedia.org/wiki/Parallel_programming_model
- https://en.wikipedia.org/wiki/Concurrent_computing
- bisimulation
- https://en.wikipedia.org/wiki/Barrier_(computer_science)
- http://clojure.org/reference/agents
- https://en.wikipedia.org/wiki/Systolic_array
- https://en.wikipedia.org/wiki/Petri_net
- http://lucumr.pocoo.org/2016/10/30/i-dont-understand-asyncio/
- https://asyncio.readthedocs.io/en/latest/
- "Is there an article or book where the major "ways" of doing concurrency in different languages are explained and compared? E.g. thread process mutex semaphore etc. in Java et al, callback promise async await in JS, goroutine channel in Go, task async await plinq in C#, asyncio in Python, etc. "
- http://joeduffyblog.com/2015/11/03/blogging-about-midori/
- midori paper: https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/msr-tr-2012-79.pdf
- https://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html
- Argus paper: http://dl.acm.org/citation.cfm?id=42399
- https://www.cs.cmu.edu/~scandal/nesl.html
- structured concurrency
- http://rsim.cs.illinois.edu/Pubs/msinclair-thesis.pdf section 3.3 which explains https://www.cs.tau.ac.il/~orilahav/seminar18/Rats.pdf, pdf page 16, DRFrlx table categories: Unpaired, Commutative, Non-Ordering, Quantum, Speculative
- https://thorstenball.com/blog/2014/10/13/why-threads-cant-fork/
- JAVA’S INSECURE PARALLELISM by PER BRINCH HANSEN 1999 "...The claim that Java supports monitors is shown to be false. The author concludes that Java ignores the last twenty-five years of research in parallel programming languages"
* "Blackboard Systems by Engelmore & Morgan"; or maybe just read about JavaSpaces. Rec. by Fogus: https://github.com/fogus/thunks/blob/main/reading/quirkeys.org but the book doesn't look like the best thing for me to read
* [http://aggregate.ee.engr.uky.edu/EXHIBITS/SC09/mogsimlcpc09final.pdf MIMD Interpretation on a GPU
- tangentially rec'd in a discussion on Erlang ( [17] ):
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 / syntax
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
- http://www.azulsystems.com/blog/wp-content/uploads/2011/03/2011_WhatDoesJVMDo.pdf
- https://www.youtube.com/watch?v=LhadeL7_EIU recc. by https://news.ycombinator.com/item?id=12025526
- this guy suggests learning from the implementations of: lua, v8, guile (but just last year), smalltalk and family (esp. strongtalk and the other pre-v8 projects), ml and family (MLton and ocaml), haskell (after many years of being too slow), any better scheme (>20), any better lisp (>5), php7 (just last year), and then the tiny lua based ones, like potion, wren, tinyrb, tinypy or tvmjit (with simple method ast->jit), or partially io, lily, or the other post-smalltalk languages, like maru (simpliest ast->jit) or the soda family around alan key and ian piumarta.
- thesis on SELF
- SELF implementation paper: http://bibliography.selflanguage.org/_static/implementation.pdf
- http://home.pipeline.com/~hbaker1/CheneyMTA.html [21] mentioned in [22]
- http://codehereandthere.blogspot.com/2015/07/the-evolution-of-programming-language.html (about Lily)
- http://nullprogram.com/blog/2013/12/30/
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."
Assembly
- https://www.cs.cornell.edu/talc/papers/talx86-wcsss.pdf
- https://www.cs.cornell.edu/talc/default.html
- related: Popcorn: A prototype compiler for a safe C-like language.
- SCHEME--: A prototype compiler for a subset of the scheme language (written in Popcorn).
- Linear TAL: A linearly typed variant of TAL that manages its own memory through linear alias tracking.
- what is wrong with macro-based control flow? "MASM, TASM, and HLA provide several high-level-like control structures (e.g., IF, WHILE, REPEAT..UNTIL, and FOR) ...none of NASM, FASM, or RosAsm? support these...Nevertheless, each of these assemblers provide macros to simulate these control statements (with varying degrees of success). Unfortunately, such macros rarely do as good a job as the real statements in languages like HLA or MASM. "
- http://wayback.archive.org/web/20160319140545/http://flatassembler.net/docs.php?article=manual#2.3.3
- http://www.aosabook.org/en/ironlang.html
- Propeller, XMOS chips. Not as target architectures, but just to learn. The Propeller and the XMOS are oriented towards replacing peripherals and interrupts with multiple cores (presumably doing 'bitbanging', that is, software implementations of protocols sometimes implemented in hardware peripherals). They have on the order of 2-24 cores (8 for Propeller), so whatever they are doing probably won't scale to millions of cores. They both provide some primitives for synchronization/sharing memory/thread scheduling (the XMOS providing a few more or maybe with more high-level guarantees, apparently), however, and i can probably learn from this for the 'local shared memory'. But for computation, they have low efficiency, and apparently if you just want parallel computation, people say it would be better just to get one fast high-end core and have it multitask.
- GA144 chips. These are too low-level for what i want; each core only has 128 words of memory (plus 20 words of stacks and registers). One commentator said about a (presumably) similar chip, "Think of the chip as being a step up from FPGAs (in some ways) rather than a small CPU.". However, they are very interesting, so i should learn more about them. There's some tutorials to programming them in the Forth section of plChOtherParadigmsLangs. Note that one awesome thing about these chips is that they are apparently very energy-efficiency while apparently also having very low low-power states, rivaling the MSP430; see http://www.greenarraychips.com/home/documents/greg/WP003-100617-msp430.pdf .
- read about RTOSs and microkernals
- http://www.complang.tuwien.ac.at/anton/euroforth/ef13/papers/ertl-paf.pdf
- https://john-millikin.com/unix-syscalls
- https://forwardcom.info/ https://github.com/ForwardCom
- https://news.ycombinator.com/item?id=16743559
- http://wiki.luajit.org/Bytecode-2.0
- https://github.com/nominolo/lambdachine/blob/master/docs/luajit-notes.markdown
- https://webassembly.org/docs/rationale/
- https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md
- some good stuff in here (not just GC but also parametric polymorphism are covered): https://github.com/WebAssembly/gc/blob/master/proposals/gc/Overview.md
- https://golang.org/doc/asm
- https://github.com/teh-cmc/go-internals/blob/master/chapter1_assembly_primer/README.md
- https://blog.sgmansfield.com/2017/04/a-foray-into-go-assembly-programming/
- https://goroutines.com/asm
- https://www.davidwong.fr/goasm/
- https://docs.python.org/3/library/asyncio-eventloop.html
- https://people.eecs.berkeley.edu/~necula/Papers/cil_cc02.pdf
- check out the ISAs for these admired architectures: "The ones listed by 4 or more people (not including Bell) were:
- CDC-6600 and 7600 - listed by Fisher, Sites, Smith, Worley
- Cray-1 - listed by Hill, Patterson, Sites, Smith, Sohi, Wallach (also Bell, sorta)
- IBM S/360 and S/370 - listed by Alpert, Hill, Patterson, Sites (also Bell)
- MIPS - listed by Alpert, Hill, Patterson, Sohi, Worley Special mention:
- 6502 - only listed by Wilson, but she was the chief architect of ARM so i think her choice is important to note
- Itanium - mentioned in the top-ranked comment in this HN discussion
- DEC Alpha - mentioned in the second-ranked comment in this HN discussion "
- https://wramp.wand.nz/book.html
- https://github.com/WebAssembly/threads/blob/master/proposals/threads/Overview.md
- take another look at https://en.wikipedia.org/wiki/Motorola_68000_series / ColdFire? b/c ppl liked 68k back in the day
- https://web.archive.org/web/20010823113747/http://www.pcmag.com/article/0%2C2997%2Cs%3D1754%26a%3D11072%2C00.asp says that IBM would have used the 68k for the IBM PC but it wasnt ready yet
- https://danielmangum.com/posts/risc-v-bytes-passing-on-the-stack/
- https://developer.toradex.com/knowledge-base/linux-floating-point-calling-convention-co-processor-engine
- https://riscv.org/wp-content/uploads/2015/01/riscv-calling.pdf
- A Brief History of Programming, Part 1
- https://news.ycombinator.com/item?id=21613714
- https://gist.github.com/erincandescent/8a10eeeea1918ee4f9d9982f7618ef68
- https://news.ycombinator.com/item?id=21613885
- https://www2.eecs.berkeley.edu/Pubs/TechRpts/2016/EECS-2016-130.pdf
- https://github.com/riscv/riscv-bitmanip/blob/master/bitmanip-0.92.pdf
- Why no one should use the AT&T syntax ever (start reading at section "AT&T is backwards")
- https://lobste.rs/s/zifjgi/why_no_one_should_use_at_t_syntax_ever_for shows that other ppl tend to prefer the intel syntax, too
- https://wordsandbuttons.online/can_you_tell_an_assembly_language_when_you_see_one.html
- https://www.cs.ucf.edu/~dcm/Teaching/CDA5106-Fall2015/Appendices/appendix_k.pdf
- https://digitalassets.lib.berkeley.edu/techreports/ucb/text/CSD-00-1124.pdf
- https://en.wikipedia.org/wiki/Comparison_of_instruction_set_architectures
- https://scholarworks.wmich.edu/cgi/viewcontent.cgi?article=2517&context=masters_theses
- https://web.archive.org/web/20210904234253/https://webcache.googleusercontent.com/search?q=cache%3A0roXQ_BalvAJ%3Ahttps%3A%2F%2Fcsce.ucmss.com%2Fcr%2Fbooks%2F2017%2FLFS%2FCSREA2017%2FFEC3090.pdf+&cd=1&hl=en&ct=clnk&gl=us
- think about 'soft float convention' (defn: https://www.google.com/search?q=soft%20float%20calling%20convention&ie=utf-8&oe=utf-8&client=firefox-b-1-m )
- ARM64 addr modes: https://developer.arm.com/documentation/102374/0101/Loads-and-stores---addressing
- https://forwardcom.info/
- https://www.agner.org/optimize/blog/read.php?i=421
- https://www.forwardcom.info/comparison.html
- https://www.agner.org/optimize/blog/read.php?i=795#918
- https://modexp.wordpress.com/2018/10/30/arm64-assembly/
- 1001 Ways of Implementing a System Call
- https://bgbtechblog.wordpress.com/2017/08/02/forgot-about-this/
- https://flameeyes.blog/2012/06/23/debunking-x32-myths/
- a new ABI proposal: https://web.archive.org/web/20170311201034/linuxplumbersconf.net/2011/ocw//system/presentations/531/original/x32-LPC-2011-0906.pptx
- forwardcom ABI
- RISC-V ABI
- see also https://github.com/riscv-collab/riscv-gnu-toolchain/issues/225 for (possible) info about ABI stuff
- https://dercuano.github.io/notes/tiny-interpreters-for-microcontrollers.html
- https://dercuano.github.io/notes/bootstrapping-instruction-set.html
- https://dercuano.github.io/notes/archival-vm.html
- https://wiki.alopex.li/RiscIn2022
- https://en.wikipedia.org/wiki/SWEET16
- comments on https://yosefk.com/blog/the-high-level-cpu-challenge.html , and all of the followup: https://yosefk.com/blog/high-level-cpu-follow-up.html
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:
- Kythe
- http://piumarta.com/software/cola/ , mb also Ometa
- Racket and read the Arc source
- TAL
- COQASM?
- HLA
- Verilog
- VHDL
- others? See plChHardLangs
- C 'variants'
- listed in the C chapter
- D
- golang
- ILs
- VMs
- 'simple' low-levelish HLLs
- oberon?
- self?
- nim
- rust? (probably not 'simple')
- Fantom 'pods' (b/c these guys have looked at both JVM .jar and CLR .dlls and made something crossplatform that fixes the weaknesses they saw in each one, see 'Modularity' section of http://fantom.org/doc/docIntro/WhyFantom )
- https://en.wikipedia.org/wiki/PreScheme
- Lua FFI (and that retrospective about why memory allocation in it was stack-based)
- skim http://www.cs.tufts.edu/~nr/c--/download/ppdp.pdf section 3.4 and on pdf page 7 (already skimmed up to 3.4)
- have to think carefully about FFIs; that's one thing that i don't know much about that could have a large impact on the design, since a big part of the point of making OotB? easy to implement on various platforms including HLLs is to make interop easy with these HLLs.
- Extensible virtual machines by Timothy L. Harris. Read the literature review of 'flexible virtual machines'. I already skimmed the rest.
- "Though mostly in that FORTH code is just barely a veneer over stack machine assembly. It might also be worth looking at old Z80 interpreters (should be able to find them around old infocom fandoms, since they like to keep that stuff alive) or various small VMs (RetroFORTH?'s Nga and Ngaro are well documented and tiny, Lua's VM design is very battle tested, and I think Janet's is basically Lua but on a stack machine)"
- http://www.complang.tuwien.ac.at/anton/euroforth/ef13/papers/ertl-paf.pdf
Transpiling
OSs
Program transformation
Prolog
normal forms
- https://en.wikipedia.org/wiki/A-normal_form
- David "Kelsey subsequently spent time as a prof at Northeastern, then left for NEC's prestige lab in Princeton, where he worked on the Kali distributed system. He also got set down precisely on paper something all the CPS people knew at some intuitive level: that the whole "SSA" revolution in the classical compiler community was essentially a rediscovery of CPS. (Harrumph.) " (Olin Shivers, [24])
- "So the lineage of the CPS-as-compiler-IR thesis goes from Steele's Rabbit compiler through T's Orbit to SML/NJ. At which point Sabry & Felleisen at Rice published a series of very heavy-duty papers dumping on CPS as a representation and proposing an alternate called A-Normal Form. ANF has been the fashionable representation for about ten years now; CPS is out of favor. This thread then sort of jumps tracks over to the CMU ML community, where it picks up the important typed-intermediate-language track and heads to Cornell, and Yale, but I'm not going to follow that now." -- http://www.paulgraham.com/thist.html
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 discussions on interesting things
https://news.ycombinator.com/item?id=15051645 http://lambda-the-ultimate.org/node/5466 https://news.ycombinator.com/item?id=64225 http://www-cs-students.stanford.edu/~blynn/c/fortran.html also most of the rest of that site : Java vs C Haskell vs C C Cruft C Wishlist Bash vs C Go vs C https://zverok.space/blog/2023-11-10-syntax-sugar3-hash-values-omission.html
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. " what is Radul working on now? In a blog post on March 21, 2016, two years in to working on a probabilistic programming platform. So, since at least March 21, 2014, he was working on a probabilistic programming platform. On Aug 7, 2017, he posted something called " Musings on Probprog". His Nov 19, 2017 blog post "Compositional statistical unit testing", suggests that he was still working on it. Two more blog posts, on Dec 25, 2017 and Dec 23, 2018, are about probabilistic inference and statistical testing. So, from at least Mar 21, 2014 until approximately Dec 23, 2018 (possibly a little shorter or much longer), he was probably working on a probabilistic programming platform. His most cited paper appears to be "Automatic differentiation in machine learning: a survey" in 2015, followed by The Art of the Propagator (Jan 26 2009) and his thesis (3 Nov 2009? although the downloadable version appears to be a draft from Sep 2009; oh i see the final thesis is at http://dspace.mit.edu/bitstream/handle/1721.1/49525/MIT-CSAIL-TR-2009-053.pdf?sequence=1 ; but it doesnt have the section on Dataflow that i was looking, that's only in the draft). In a paper published Aug 18 2021 on which he was an author ("Getting to the point. index sets and parallelism-preserving autodiff for pointful array programming"), his affiliation is "Google Research". Before that, he had another paper in 2021 on "An adaptive-MCMC scheme for setting trajectory lengths in Hamiltonian Monte Carlo". In 2021, there appears to be exactly one paper on which he was first author, "The Base Measure Problem and its Solution", https://proceedings.mlr.press/v130/radul21a.html , which appears to be research supporting probabilistic programming systems. In 2020, there appears to be exactly one paper on which he was first author, "Automatically batching control-intensive programs for modern accelerators", which I'm guessing could be related to the implementation of probabilistic programming systems with the use of GPUs. Since the propagator stuff, he's been doing some work on probabilistic programming https://github.com/ekmett/propagators
- https://www.cs.man.ac.uk/~pjj/cs2111/ho/node9.html
- http://blog.rust-lang.org/2015/05/11/traits.html
- http://blog.skylight.io/rust-means-never-having-to-close-a-socket/
- http://stackoverflow.com/questions/57483/what-are-the-differences-between-a-pointer-variable-and-a-reference-variable-in
- https://news.ycombinator.com/item?id=7669836 https://news.ycombinator.com/item?id=7670718
- http://www.oreilly.com/programming/free/files/software-architecture-patterns.pdf
- Channels Are Not Enough... or Why Pipelining Is Not That Easy
- http://gafter.blogspot.com/2007/03/on-expressive-power-of-programming.html?m=1
- http://www.ccs.neu.edu/home/matthias/HtDP2e/
- https://dreamsongs.com/Files/DesignBeyondHumanAbilitiesSimp.pdf
- http://www.raphkoster.com/gaming/dikuscr.shtml
- GC: https://news.ycombinator.com/item?id=9854408
- ActorScript (Hewitt's thing) tutorial, another actorscript document
- https://en.wikipedia.org/wiki/Unbounded_nondeterminism i saw a LtU? discussion in which Hewitt said ActorScript? is cool b/c it has this. I don't quite understand it; my suspicion is that it is a 'red herring' of the sort (real computers aren't Turing machines b/c they have finite memory; the mathematical foundational problems with infinities; etc)
- Composite Replicated Data Types: eventually consistent libraries as non-leaky abstractions
- Tracking the Flow of Ideas through the Programming Languages Literature
- Punctuated equilibrium in the large scale evolution of programming languages
- Conservation laws for free!
- https://www.thc.org/root/phun/unmaintain.html , starting with "Program Design" (i read the stuff above that already)
- http://www.defmacro.org/ramblings/fp.html
- https://github.com/btrask/stronglink/blob/master/SUBSTANCE.md
- http://www.vpri.org/pdf/tr2007008_steps.pdf
- functional relational programming
- figure out what this stuff is: http://stackoverflow.com/a/3602268/171761
- figure out this scala syntax: http://www.scala-lang.org/old/node/12478
- http://codeschool.org/python-continued/ : gives some insight into what is confusingly different in Python syntax
- USL: i already took some notes on this, but i should learn it better because Margaret H. Hamilton is a heavyweight who programmed part of Apollo 11
- http://blog.heapanalytics.com/goodbye-coffeescript-hello-typescript/
- "November 3, 2015. INC CHalk Talk. Ryad Benosman. Vision and Natural Computation Group. Institut National de la Sante et de la Recherche Medicale, Paris, France. A FRAMEWORK FOR GENERAL PURPOSE COMPUTATION USING NEURONS, PRECISE TIMING, DELAYS, AND SYNCHRONY. Abstract: There has been significant research over the past two decades in developing new platforms for spiking neural computation. Current neural computers are primarily developed to mimic biology. They use neural networks, which can be trained to perform specific tasks to mainly solve pattern recognition problems. These machines can do more than simulate biology; they allow us to rethink our current paradigm of computation. The ultimate goal is to develop brain-inspired general purpose computation architectures that can breach the current bottleneck introduced by the von Neumann architecture. This work proposes a new framework for such a machine. We show that the use of neuron-like units with precise timing representation, synaptic diversity, and temporal delays allows us to set a complete, scalable compact computation framework. The framework provides both linear and nonlinear operations, allowing us to represent and solve any function. We show usability in solving real use cases from simple differential equations to sets of nonlinear differential equations leading to chaotic attractors. " http://hackersdelight.org/basics2.pdf provides some other basic functions that we might want to provide in a library or in core (abs, etc)
- https://www.cs.ox.ac.uk/jeremy.gibbons/publications/iterator.pdf recc. by https://news.ycombinator.com/item?id=10773457
- the first 89 pages of Smalltalk-80: The Language and its Implementation (recc. by http://peter.michaux.ca/articles/smalltalk-mvc-translated-to-javascript )
- everything on this (note: this is mostly NON-fiction about programming languages): http://blog.fogus.me/2015/04/27/six-works-of-computer-science-fiction/
- Ask HN: What language features have particularly appealed to you?
- https://news.ycombinator.com/item?id=9298710
- GLL
- re-read http://www.randomhacks.net/2005/12/03/why-ruby-is-an-acceptable-lisp/
- https://en.wikipedia.org/wiki/Category:Operators_%28programming%29
- http://people.cis.ksu.edu/~schmidt/705a/Lectures/paradigmsS.html
- http://people.cis.ksu.edu/~schmidt/705a/Lectures/history.html
- http://people.cis.ksu.edu/~schmidt/705a/Lectures/NS12/ns12S.html
- " Programming-language history is full of such meta-languages: VDL (for tree machines), lambda-calculus (for rewriting machines), binary-machine code (for von Neumann/Turing machines) are three famous ones. More recently, there are also the object calculus, CCS, CSP, and various logical frameworks (Isabelle/HOL, Coq, LF). "
- the lexicon in ootNotes16 (copied from http://publications.nr.no/directdownload/publications.nr.no/lexicon.pdf ) and the preceding examples of common patterns in Java
- http://cstheory.stackexchange.com/questions/6256/whats-the-difference-between-term-rewriting-and-pattern-matching
- http://web.archive.org/web/20150324183351/http://www.emu.edu.tr/aelci/Courses/D-318/D-318-Files/plbook/index.htm
- http://beautifulracket.com/first-lang.html
- http://objective.st/
- the links to specific machines in https://en.wikipedia.org/wiki/Abstract_machine
- Elm is 'saying farewell to (classic) FRP', which apparently means something Conal Elliott talked about "Fran: Functional Reactive Animation" [https://groups.google.com/d/msg/elm-discuss/6U74_aNXC04/IWG16EykCQAJ. Elm is replacing Signals with Subscriptions. This guy and the one who replies to em also talks about flatmap/switch and Elm's new emphasis on 'cells': http://lambda-the-ultimate.org/node/5338#comment-92560
- go thru [[notes-computer-programming-programmingLanguageDesign-prosAndCons-programmingConstructs2?]] and integrate relevant things into Oot notes
- object algebras for the Expression Problem
- phantom types
- React mixins considered harmful
- https://www.gnu.org/software/guile/docs/master/guile.html/Object-File-Format.html#Object-File-Format
- http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html
- http://stefan-marr.de/papers/oopsla-marr-ducasse-meta-tracing-vs-partial-evaluation/ (" RPython is very similar to Graal+Truffle, except that RPython is based on tracing and Graal+Truffle is based on partial evaluation. There's a nice paper comparing the two approaches and their relative merits" [25]
- http://www.languageworkbenches.net/
- https://en.wikipedia.org/wiki/META_II
- https://github.com/JetBrains/Nitra
- Graal + Truffle
- riko: A stream processing engine modeled after Yahoo! Pipes
- already read: https://scottlocklin.wordpress.com/2013/07/28/ruins-of-forgotten-empires-apl-languages/ , also read https://scottlocklin.wordpress.com/2012/09/18/a-look-at-the-j-language-the-fine-line-between-genius-and-insanity/ and https://scottlocklin.wordpress.com/2015/12/15/an-introduction-to-kerf/ and http://conceptualorigami.blogspot.com/2010/12/vector-processing-languages-future-of.html and https://scottlocklin.wordpress.com/2012/09/12/not-all-programmers-alike/
- http://www.jsoftware.com/help/jforc/forks_hooks_and_compound_adv.htm
- https://en.wikipedia.org/wiki/Tacit_programming
- understand Numpy 'broadcasting' https://www.reddit.com/r/apljk/comments/4n0z1q/is_aplj_similar_to_pythons_numpy/d40eofh
- someday mb read the other 'whats-new-in-csharp-X's (like https://blogs.msdn.microsoft.com/dotnet/2016/08/24/whats-new-in-csharp-7-0/ )
- mb: where is 'if' in Morte? is it a church encoding sorta thing?
- https://eprint.iacr.org/2016/633.pdf oyente smart contract analyzer
- A survey of attacks on Ethereum smart contracts
- http://www.cs.dartmouth.edu/~mckeeman/cs48/mxcom/gem/html/GrowingCompiler.html
- http://docs.reconfigure.io/tutorial_1_hist_parallel.html and http://docs.reconfigure.io/tutorial_2_addition.html
- https://news.ycombinator.com/item?id=14745038
- https://news.ycombinator.com/item?id=14744980
- http://antirez.com/articoli/tclmisunderstood.html
- https://news.ycombinator.com/item?id=14856273
- http://christopherchase.cc/posts/tcl-until.html
- https://news.ycombinator.com/item?id=15051645
- "The Limits of Correctness" (1985) by Bryan Cantwell Smith: https://www.student.cs.uwaterloo.ca/~cs492/11public_html/p18-smith.pdf
- Peter Naur, "Programming as theory building." (1985) http://pages.cs.wisc.edu/~remzi/Naur.pdf https://news.ycombinator.com/item?id=10833278 https://news.ycombinator.com/item?id=7491661
- Out Of The Tarpit, by Moseley and Marks https://github.com/papers-we-love/papers-we-love/blob/master/design/out-of-the-tar-pit.pdf (proposes functional relational programming)
- Purely Functional Data Structures by Chris Okasaki - https://www.cs.cmu.edu/~rwh/theses/okasaki.pdf
- Can programming be liberated from the von Neumann style? - John Backus's Turing lecture - http://dl.acm.org/citation.cfm?id=128
- https://www.cs.ucsb.edu/~urs/oocsb/self/papers/papers.html eg "Self: the power of simplicity"
- "Kademlia, a P2P distributed hash table. DHTs are very complex from the outside but very simple once you understand the building blocks. https://pdos.csail.mit.edu/~petar/papers/maymounkov-kademlia-lncs.pdf
- "Hmm, I think it's important to understand Chord DHT first and only after that move on to Kademlia, then S/Kademlia and so on."
- "The Derivative of a Regular Type is its Type of One-Hole Contexts" - Conor McBride?, http://strictlypositive.org/diff.pdf
- http://erlang.org/download/armstrong_thesis_2003.pdf
- https://www.microsoft.com/en-us/research/wp-content/uploads/2016/07/state-lasc.pdf
- http://alumni.media.mit.edu/~mt/thesis/mt-thesis-Contents.html
- http://web.mit.edu/jakebeal/www/Publications/NIAI-2008.pdf
- mb http://www.jwhanlon.com/files/thesis-print.pdf
- https://jsandler18.github.io/ , part 9, "Locks", and on
- https://www.python.org/dev/peps/pep-0384/
- features that never made it close to Rust 1.0
- http://canonical.org/~kragen/memory-models/
- https://en.wikipedia.org/wiki/Bootstrapping_(compilers)
- From folklore to fact: comparing implementations of stacks and continuations
IPC
data
tobemined
cmdline and shells
e.g. http://www.softpanorama.org/People/Scripting_giants/scripting_languages_as_vhll.shtml
for LOVM/Lo
for OVM
CPS ILs
general implementation tips
effects
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.
---
https://people.inf.ethz.ch/wirth/CompilerConstruction/index.html
https://people.inf.ethz.ch/wirth/ProjectOberon/index.html
---
https://cygni.se/the-perfect-programming-language/ https://news.ycombinator.com/item?id=21543244
---
i haven't read the HN discussion yet on Notes on a Smaller Rust except i have read the subthread of the first comment: https://news.ycombinator.com/item?id=20465716
i have read the lobsters discussion.
now there is a followup:
https://without.boats/blog/revisiting-a-smaller-rust/
---
scala
memory management
syntax
tooling
npm | etc) how is "minimal version selection" working out? ☶ ask go |
control
ovm
libraries
related
tobemined
---
"
dunefox 2 days ago [–]
First-class logic/constraint programming like in Flix (chttps:flix.dev/). This would make complex logic easier and powerful.
reply "