Links

Website

• http://chrisdone.com/posts/haskell-lang
• http://new-www.haskell.org/

Inspiration

• http://hyperpolyglot.org/
• http://joelrunyon.com/two3/an-unexpected-ass-kicking
• https://speakerdeck.com/u/matt_aimonetti/p/tower-of-babel-a-tour-of-programming-languages
• http://www.futurealoof.com/posts/nodemodules-in-git.html (but with ./vendor instead of ./node_modules)
• http://www.harukizaemon.com/blog/2010/03/01/functional-programming-in-object-oriented-languages/
• http://www.ccs.neu.edu/home/matthias/Presentations/ecoop2004.pdf

Automatic Application

add = (a, b) -> { a + b }
add(5, 37)         # 42
add()(5)()()(37)   # 42
add5 = add(5)      # returns a new lambda
add5(37)           # 42
add.apply(5, 37)   # returns a new lambda
add.apply(5, 37)() # 42

• http://fr.umio.us/favoring-curry/
• https://github.com/CrossEye/ramda
• http://hughfdjackson.com/javascript/why-curry-helps/
• https://www.youtube.com/watch?v=m3svKOdZijA
• https://fitzgen.github.io/wu.js/
• http://bahmutov.calepin.co/put-callback-first-for-elegance.html

Method Resolution (for multiple inheritance)

• http://www.python.org/download/releases/2.3/mro/ (describes the C3 algorithm, which Python uses)

Inheritance

• https://lwn.net/SubscriberLink/548560/26d15e832d21a483/
• http://en.wikipedia.org/wiki/Multiple_inheritance

Proper Tail Calls

• http://duartes.org/gustavo/blog/post/tail-calls-optimization-es6/
• https://mitpress.mit.edu/sicp/full-text/book/book-Z-H-11.html
• http://spin.atomicobject.com/2014/11/05/tail-call-recursion-optimization/
• http://projectfortress.sun.com/Projects/Community/blog/ObjectOrientedTailRecursion
• http://home.olympus.net/~7seas/recurse.html

Documentation

• https://github.com/GitbookIO/gitbook

WAT

• https://gist.github.com/c8188956cd66c38feb1f

Protocol

• http://clojure.org/protocols
• https://github.com/Gozala/protocol
• http://www.russbishop.net/monoids-monads-and-functors

Web Framework

• http://blog.plataformatec.com.br/2012/06/why-your-web-framework-should-not-adopt-rack-api/
• http://tenderlovemaking.com/2011/03/03/rack-api-is-awkward.html
• http://reneerb.com/

Numbers

• https://en.wikipedia.org/wiki/Hypercomplex_number
• https://www.youtube.com/playlist?list=PLiaHhY2iBX9g6KIvZ_703G3KJXapKkNaF

Units

• https://en.wikipedia.org/wiki/Lemma_(morphology)
• https://github.com/joshwlewis/unitwise
• http://unitsofmeasure.org/
• https://futureboy.us/frinkdata/units.txt

Pipes, Pipelines And Streaming

• https://streams.spec.whatwg.org/
• http://maryrosecook.com/blog/post/a-practical-introduction-to-functional-programming
• http://maxogden.com/node-streams.html

Typing

• http://www.cs.washington.edu/education/courses/cse590n/10au/hanenberg-oopsla2010.pdf
• http://variadic.me/posts/2012-10-25-maybe-bane-null.html
• http://variadic.me/posts/2012-10-26-maybe-adding-error-message.html
• http://bendyworks.com/geekville/articles/2012/12/from-ruby-to-haskell-part-1-testing
• http://www.harukizaemon.com/blog/2010/03/01/functional-programming-in-object-oriented-languages/
• http://www.codecommit.com/blog/scala/what-is-hindley-milner-and-why-is-it-cool
• http://mortoray.com/2013/08/13/we-dont-need-a-string-type/
• http://mortoray.com/2013/11/27/the-string-type-is-broken/
• http://kevinmahoney.co.uk/articles/tests-vs-types/

Generics

• http://cglab.ca/~abeinges/blah/rust-generics-and-collections/

Build System

• http://gittup.org/tup/

Compilers

• http://dylanfoundry.org/2014/11/05/integrating-with-llvm/
• http://llvm.lyngvig.org/Articles/Mapping-High-Level-Constructs-to-LLVM-IR
• http://dev.stephendiehl.com/numpile/
• http://tirania.org/blog/archive/2012/Apr-04.html
• http://existentialtype.wordpress.com/2011/03/19/dynamic-languages-are-static-languages/
• http://blog.headius.com/2012/09/an-experiment-in-static-compilation-of.html
• http://www.altdevblogaday.com/2011/12/24/static-code-analysis/
• http://typescript.codeplex.com/
• http://matt.might.net/articles/intro-static-analysis/
• http://jster.net/category/compilers-and-parsers
• http://jsparse.meteor.com/
• http://pegjs.majda.cz/
• https://github.com/rubinius/rubinius/blob/master/lib/racc/parser.rb
• http://stackoverflow.com/questions/19132/expression-versus-statement
• http://yawnt.github.com/blog/2013/02/15/on-compilers-and-interpreters/
• https://practicingruby.com/articles/shared/zzdrpyxcqtan
• http://llvm.org/docs/LangRef.html
• http://llvm.org/docs/tutorial/
• http://createyourproglang.com/
• https://github.com/seattlerb/ruby_parser/blob/master/lib/ruby_lexer.rb
• http://ruby.runpaint.org/methods#lookup-algorithm
• http://dinosaur.compilertools.net/bison/bison_6.html#SEC50
• https://en.wikipedia.org/wiki/Shunting-yard_algorithm
• http://onoffswitch.net/building-a-custom-lexer/
• http://onoffswitch.net/a-handrolled-language-parser/
  • http://www.reddit.com/r/programming/comments/19gsdd
• http://blog.regehr.org/archives/1170
• http://nethack4.org/blog/building-c.html
• http://theorangeduck.com/page/you-could-have-invented-parser-combinators
• http://www.aosabook.org/en/ghc.html
• https://cesquivias.github.io/blog/2014/10/13/writing-a-language-in-truffle-part-1-a-simple-slow-interpreter/
• https://cesquivias.github.io/blog/2014/12/02/writing-a-language-in-truffle-part-2-using-truffle-and-graal/
• https://cesquivias.github.io/blog/2015/01/08/writing-a-language-in-truffle-part-3-making-my-language-much-faster/
• https://cesquivias.github.io/blog/2015/01/15/writing-a-language-in-truffle-part-4-adding-features-the-truffle-way/
• https://blog.indutny.com/
• https://blog.indutny.com/4.how-to-start-jitting
• https://blog.indutny.com/5.allocating-numbers
• http://elm-lang.org/blog/compilers-as-assistants
• http://prog21.dadgum.com/30.html
• https://jakubdziworski.github.io/categories.html#Enkel-ref

Pointers

• http://cslibrary.stanford.edu/106/

Virtual Machines

• http://www.tratt.net/laurie/tech_articles/articles/fast_enough_vms_in_fast_enough_time
• http://vertx.io/
• https://blog.mozilla.org/javascript/2012/10/15/the-ins-and-outs-of-invalidation/
• https://pauladamsmith.com/blog/2015/01/how-to-get-started-with-llvm-c-api.html

Debuggers

• http://t-a-w.blogspot.co.uk/2007/03/how-to-code-debuggers.html
• http://www.codereversing.com/blog/?p=168
• http://www.codereversing.com/blog/?p=169
• http://www.codereversing.com/blog/?p=170
• http://www.codereversing.com/blog/?p=176
• http://www.codereversing.com/blog/?p=178

Asynchrony

• http://sndrs.ca/2014/08/12/asynchronous-programming-with-goroutines-in-ruby/
• http://blog.ometer.com/2011/07/24/callbacks-synchronous-and-asynchronous/
• http://blog.izs.me/post/59142742143/designing-apis-for-asynchrony
• http://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/
• https://joearms.github.io/2013/04/02/Red-and-Green-Callbacks.html

Concurrency

• http://www.drdobbs.com/article/print?articleId=210604448
• http://blog.paracode.com/2012/09/07/pragmatic-concurrency-with-ruby/
• http://preshing.com/20121019/this-is-why-they-call-it-a-weakly-ordered-cpu
• http://tonyarcieri.com/2012-the-year-rubyists-learned-to-stop-worrying-and-love-the-threads
• http://jlouisramblings.blogspot.co.uk/2013/01/how-erlang-does-scheduling.html

Threading

• http://blog.paracode.com/2012/09/07/pragmatic-concurrency-with-ruby/
• http://www.toptal.com/ruby/ruby-concurrency-and-parallelism-a-practical-primer

Testing

• http://www.macwright.org/2014/03/11/tape-is-cool.html

Package Management

• http://theupdateframework.com/
• http://corner.squareup.com/2013/12/securing-rubygems-with-tuf-part-1.html
• http://everythingstays.com/
• https://keybase.io
• https://keybase.io/docs/kbfs
• https://help.github.com/articles/generating-a-gpg-key/

SQL

• https://en.wikipedia.org/wiki/Language_Integrated_Query
• http://code.jonwagner.com/2012/08/24/best-practices-for-linq-enumerables-and-queryables/

Standard Libraries

• http://www.creativedeletion.com/2015/01/28/falsehoods-programmers-date-time-zones.html

Algorithms

• http://bartoszmilewski.com/2014/10/28/category-theory-for-programmers-the-preface/
• http://blog.notdot.net/2012/08/Damn-Cool-Algorithms-Homomorphic-Hashing
• http://www.pvk.ca/Blog/2012/08/27/tabasco-sort-super-optimal-merge-sort/
• http://seanmehan.globat.com/blog/2011/12/20/set-theory-and-sql-concepts/
• https://github.com/natefaubion/adt.js
• https://github.com/natefaubion/matches.js
• http://www.2ality.com/2012/09/expressions-vs-statements.html
• http://blog.carbonfive.com/2012/10/02/enumerator-rubys-versatile-iterator/
• https://medium.com/@sent0hil/consistent-hashing-a-guide-go-implementation-fe3421ac3e8f
• http://en.wikipedia.org/wiki/Perfect_hash_function
  • https://github.com/mixu/perfect
• http://emboss.github.com/blog/2012/10/01/how-are-enumerators-for-arbitrary-objects-implemented/
• http://emboss.github.com/blog/2012/10/14/computing-the-units-digit-of-a-power-a-constant-time-algorithm-using-a-little-number-theory/
• http://atlas.cs.virginia.edu/~weimer/2008-415/reading/bacon-garbage.pdf
• http://www.cs.virginia.edu/~cs415/reading/bacon-garbage.pdf
• http://www.dev.gd/20121224-understanding-map-filter-and-fold.html
• http://samesake.com/log/2013/01/03/Three-little-birds/
• http://worrydream.com/AlligatorEggs/
• http://en.wikipedia.org/wiki/To_Mock_a_Mockingbird
• http://www.risc.jku.at/people/ckoutsch/stuff/e_algorithms.html
• http://bigocheatsheet.com/
• http://rubysource.com/rubys-missing-data-structure/

Module Loading

• https://blog.jcoglan.com/2013/03/30/callbacks-are-imperative-promises-are-functional-nodes-biggest-missed-opportunity/ (scroll down for async module loading)

Random Number Generator

• http://www.av8n.com/turbid/paper/turbid.htm

Functional Reactive Programming

• http://elm-lang.org/
• http://elm-lang.org/learn/What-is-FRP.elm
• http://elm-lang.org/learn/Escape-from-Callback-Hell.elm

Shelling Out

• https://github.com/gdb/rubysh

Side Effects

• http://www.blueskyonmars.com/2015/10/01/side-effects-vs-promises/

IO

• https://robots.thoughtbot.com/io-in-ruby
• http://www.saminiir.com/lets-code-tcp-ip-stack-1-ethernet-arp/

Data Structures

• http://www.javacodegeeks.com/2012/09/self-taught-developers-are-you-missing.html
• http://www.cidrdb.org/cidr2015/Papers/CIDR15_Paper16.pdf
• http://blog.burntsushi.net/transducers/

Regular Expressions

• http://nikic.github.com/2012/06/15/The-true-power-of-regular-expressions.html

Parsing

• http://bford.info/packrat/
• http://loup-vaillant.fr/tutorials/earley-parsing/recogniser

Reference

• http://patshaughnessy.net/ruby-under-a-microscope
• http://www.intechopen.com/subjects/computer-and-information-science/books/all/1
• http://nominolo.blogspot.com/2012/07/implementing-fast-interpreters.html
• http://debasishg.blogspot.in/2012/07/property-based-testing-for-domain-models.html
• http://trac.webkit.org/browser/trunk/Source/JavaScriptCore/offlineasm/parser.rb
• http://rigaux.org/language-study/syntax-across-languages.html
• http://wcook.blogspot.com/2012/07/proposal-for-simplified-modern.html
• http://mortoray.com/2012/07/20/why-i-dont-use-a-parser-generator/
• http://nominolo.blogspot.co.uk/2012/07/implementing-fast-interpreters.html
• http://nominolo.blogspot.co.uk/2012/07/implementing-fast-interpreters_31.html
• http://confreaks.com/videos/371-rubyconf2010-debugging-ruby
• http://www.slideshare.net/tmm1/debugging-ruby
• http://buildnewgames.com/garbage-collector-friendly-code/
• http://feepingcreature.github.com/oop.html
• https://github.com/harukizaemon/hamster
• http://www.retroprogramming.com/2012/09/itsy-documenting-bit-twiddling-voodoo.html
• http://dave.cheney.net/2012/09/03/another-go-at-the-next-big-language
• http://blog.headius.com/2012/09/avoiding-hash-lookups-in-ruby.html
• http://gbracha.blogspot.com.au/2011/01/maybe-monads-might-not-matter.html
• http://matt.might.net/articles/what-cs-majors-should-know/
• http://www.htdp.org/
• http://austintaylor.org/post/25941951131/5-models-of-oop
• https://blog.stackmob.com/2013/01/free-yourself-from-the-tyranny-of-null-part-1/
• https://blog.stackmob.com/2013/01/free-yourself-from-the-tyranny-of-null-part-2-why-weve-banned-null-in-our-codebase/
• https://speakerdeck.com/alex/why-python-ruby-and-javascript-are-slow
• https://eschew.wordpress.com/2013/10/28/on-llvms-gc-infrastructure/
• http://blog.fogus.me/2011/09/08/10-technical-papers-every-programmer-should-read-at-least-twice/