see also [1]
toreads
- http://stackoverflow.com/questions/961942/what-is-the-worst-programming-language-you-ever-worked-with
- http://wiki.di.uminho.pt/twiki/pub/Education/MFES1112/Material/Logic-lesson5.pdf
- http://www.cs.man.ac.uk/~pjj/cs211/ho/ho.html
- http://replove.herokuapp.com/sakura/index.html and https://news.ycombinator.com/item?id=6355738 (start at the section with the word 'macrolet')
- finish reading and taking notes on Why Pascal is Not My Favorite Programming Language http://www.lysator.liu.se/c/bwk-on-pascal.html (start at section 2.5), and turning the existing notes into jasper to-dos
- clojure protocols, defrecord, def the other thing (interface?)
- http%3A%2F%2Fwww.cis.upenn.edu%2F~bcpierce%2Fpapers%2Fcrchandbook.ps
- https://github.com/tinkerpop/gremlin/wiki
- http://code.google.com/p/qbql/
- http://www.cse.scu.edu/~rdaniels/html/courses/Coen171/Powerpoint.htm
- http://www.cis.upenn.edu/~bcpierce/courses/670Fall04/GreatWorksInPL.shtml
- 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 ,
- Haskell frameworks: syb, o'haskell, olaf's stuff, quick
- http://research.microsoft.com/en-us/projects/specsharp/
- perl 6
- Logic programming primitives (look at prolog, curry)
- http://www.inf.ethz.ch/personal/wirth/Articles/Oberon.html oberon-07 (Wirth likes it better than his other languages Pascal, Modula-2, and better than Java and C#; however a bunch of other people like Modula-3: http://stackoverflow.com/questions/422461/is-anyone-programming-in-oberon )
- Dyna ( http://www.dyna.org/ )
- 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 ,
- read http://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.29.4790
- read Design Concepts in Programming Languages (see http://web.eecs.umich.edu/~bchandra/courses/papers/Turbak_6.821/ )
- read Types and Programming Languages by Pierce, mb read http://www.mpi-sws.org/~dreyer/ats/papers/harper-tspl.pdf
- 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
- http://en.wikipedia.org/wiki/Parallax_Propeller#Built_in_SPIN_byte_code_interpreter
- http://www.pyret.org/
- http://www.bencollier.info/content/finding-minimum-set-languages-learn-all-programming-paradigms
link Try adding a language with proof solving capabilities. ATS, Agda, Idris, Coq spring to mind. |
- http://words.steveklabnik.com/a-30-minute-introduction-to-rust
- 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://www.learnprolognow.org/
- 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)
- http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.127.5320 Organizing programs without classes
- 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
- read A Theory of Objects by Martín Abadi, Luca Cardelli
- 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
- Pratt's lisp with syntax, http://en.wikipedia.org/wiki/CGOL
- 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"
- 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. ":
- 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
- Plan9, Minix, VPRI, and Squeak
- 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/
- verilog, VHDL
- openCL, Cell processor, RapidMind? Multi-core Development Platform, http://en.wikipedia.org/wiki/OpenCL#Libraries
- openCL, pthreads, MPI, map-reduce
- git
- http://rzimmerman.github.io/kal/
- squeak
- Relational algebra and relational calculus
- xpath
- 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)
- Look at Python PEPs and similar for other languages
- Look at http://code.hazzens.com/d3tut/lesson_1.html
- 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://cis.poly.edu/cs614/NewdirectionsSaman1206.pdf
- actually mb: Scheme, CL, Clojure, Arc, Racket, Shen
- 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
- pico, just because it's small: http://en.wikipedia.org/wiki/Pico_%28programming_language%29
- random list of primitives: http://hackage.haskell.org/packages/archive/ddc-core-tetra/0.3.2.1/doc/html/DDC-Core-Tetra.html
- 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://nanomsg.org/ (0mq replacement)
- look at LIBRA for some library ops
- http://purelang.bitbucket.org/
- https://github.com/graphite-ng/graphite-ng
- http://graphlab.org/graphchi/
- http://thechangelog.com/rich-hickeys-greatest-hits/
- 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,
- https://www.destroyallsoftware.com/talks/wat
- read http://lucacardelli.name/Papers/A%20Spatial%20Logic%20For%20Querying%20Graphs%20(ICALP).pdf and follow citations
- Reread the Chu space concurrency stuff from Vaughn Pratt, and learn about modal logic a la von Benthem
- reread http://blog.ianbicking.org/ruby-python-power.html
- read sipl
- read on lisp
- read http://www.cs.brown.edu/~sk/Publications/Books/ProgLangs/2007-04-26/
- read Seymour Papert's "Mindstorms" (http://worrydream.com/LearnableProgramming/ says you gotta read it)
- read http://python-history.blogspot.com/
- mb read http://dreamsongs.com/10ideas.html , http://dreamsongs.com/Feyerabend/Feyerabend.html
- mb read http://dreamsongs.com/Files/PatternOfLanguageEvolution.pdf
- mb read http://dreamsongs.com/Files/Incommensurability.pdf
- mb read http://dreamsongs.com/Files/PatternsOfSoftware.pdf
- mb read the famous design patterns book
- mb read http://dreamsongs.com/CLOS.html
- read http://en.wikipedia.org/wiki/Comparison_of_programming_languages
- read http://www.ibm.com/developerworks/java/library/wa-clojure/index.html
- 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.
- interesting language for its conciseness (if not its platform): https://github.com/seliopou/typo
- 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: "
- http://hop.perl.plover.com/book/
- 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://aphyr.com/posts/301-clojure-from-the-ground-up-welcome
- http://www.kevinalbrecht.com/code/joy-mirror/j00rat.html
- http://www.kevinalbrecht.com/code/joy-mirror/j08cnt.html
- 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 "
- ohmu: http://portal.acm.org/citation.cfm?id=949350
- ontic: http://ttic.uchicago.edu/~dmcallester/ontic-spec.ps
- 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://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
- 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."
- 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://www.infoq.com/interviews/hickey-clojure-protocols
- http://www.4clojure.com/
- http://www.infoq.com/interviews/hickey-clojure-reader
- 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://assets.en.oreilly.com/1/event/27/A%20Survey%20of%20Concurrency%20Constructs%20Presentation.pdf
- 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://en.wikipedia.org/wiki/Programming_language and the textbooks in http://en.wikipedia.org/wiki/Programming_language#Further_reading
- 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/
- http://urbit.org (new Hoon stuff)
- 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
- http://norvig.com/lispy.py
- https://en.wikipedia.org/wiki/Type_introspection
- computer algebra systems; theorem-proving assistants
- http://www.infoq.com/presentations/oop-language-context
- http://www.buildyourownlisp.com/contents
- "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."
- 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. 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.
- https://en.wikipedia.org/wiki/Programming_language_theory
- https://en.wikipedia.org/wiki/Comparison_of_programming_languages
- 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
- https://en.wikipedia.org/wiki/Programming_paradigm
- 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/
- i read this but it's gold: http://www.toptal.com/python/top-10-mistakes-that-python-programmers-make
- 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
- On Lisp
- https://github.com/ethereum/wiki/wiki/%5BEnglish%5D-Ethereum-TOC
- frameworks to learn from: trading (metatrader, ninjatrader, sierra charts, zipline), desktop application and gui frameworks (gnome, kde, whatever windows has), scientific computing frameworks (octave, numpy, ipython), machine learning frameworks (rapidminer), simple programming applications/frameworks/languages (hypercard, basic, spreadsheets), web programming frameworks (django, rails, angular, ember, whatever java has, google app engine (with ndb)), query languages (sql etc, see above), component/plug-in architecture frameworks (zope, clos, Envisage), shells and shell-driven programming ecosystems (unix and powershell)
- datomic
- 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 Art of The Meta Object Protocol
- 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://www.google.com/search?client=ubuntu&channel=fs&q=concurrent+programming+language
- 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/