Haskell http://fprog.ru/ Erlang Cog Agda Idris Elixir

https://stepik.org/course/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5-%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-%D0%BD%D0%B0-%D1%8F%D0%B7%D1%8B%D0%BA%D0%B5-Haskell-75/

https://www.youtube.com/watch?v=E8I19uA-wGY FP Design pattern

https://torchhound.github.io/posts/haskellOneSentence.html

https://github.com/hemanth/functional-programming-jargon

Strong typing means values are of specific types that can only be used in well-defined ways. Weak typing means data is loose and can be used in different ways. In Clojure (strong typing), an operation that expects an integer can only operate on an integer, and will throw an error if fed anything else. In C (weak typing), an integer can be passed around and used as an integer, a pointer, or a character, depending on the strictness of the compiler; if not strict, it won't complain at all.

Dynamic typing means that the types of identifiers and parameters are flexible. Static typingmeans they must match 1:1. In Clojure (dynamic typing), a function that takes one parameter and operates on it as if it were a collection can operate on any kind of collection passed in, but if an integer is passed in, the function will fail at runtime. In Java (static typing), the function's argument must have a type; if it expects a List, passing it an integer will throw a compile-time error.

Clojure, Ruby, and Python are dynamic and strongly typed.

Java, C#, F#, Ocaml, Haskell, and Rust are static and strongly typed.

C and C++ are static and weakly typed.

JavaScript is dynamic and weakly typed.

Type annotations != static typing. For example, F# is statically typed but can be used without type annotations in most situations; this is known as type inference, where the compiler tries to figure out the type of the identifier given the context and hold the programmer to that type.

https://begriffs.com/

https://github.com/SamuelSchlesinger/HaskellTutorial

http://habrahabr.ru/post/272115/

https://github.com/sger/ElixirBooks Elixir

http://www.stephendiehl.com/posts/abstraction.html

http://www.russbishop.net/monoids-monads-and-functors

https://github.com/meiersi/HaskellerZ/tree/master/meetups/20160331-Haskell_Mistakes

https://takenobu-hs.github.io/downloads/haskell_lazy_evaluation.pdf

https://news.ycombinator.com/item?id=10793459 constraint programming

http://www.happylearnhaskelltutorial.com/

https://stepic.org/course/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5-%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-%D0%BD%D0%B0-%D1%8F%D0%B7%D1%8B%D0%BA%D0%B5-Haskell-75/

http://haskellformac.com/

http://www.stephendiehl.com/posts.html

http://drboolean.gitbooks.io/mostly-adequate-guide/

http://www.slideshare.net/ScottWlaschin/fp-patterns-buildstufflt

https://www.youtube.com/watch?v=__dDAD0Y_WU

https://www.youtube.com/watch?v=uA0Z7_4J7u8

https://github.com/michaelochurch/summer-2015-haskell-class

http://stackoverflow.com/questions/28139259/why-do-we-need-monads

https://news.ycombinator.com/item?id=10126805

https://channel9.msdn.com/Series/C9-Lectures-Erik-Meijer-Functional-Programming-Fundamentals/Lecture-Series-Erik-Meijer-Functional-Programming-Fundamentals-Chapter-1

http://alogic.livejournal.com/176357.html

http://comonad.com/reader/2014/letter-to-a-young-haskell-enthusiast/

http://mechanical-elephant.com/thoughts/2015-04-20-becoming-productive-in-haskell/index.html

https://github.com/caiorss/Functional-Programming

https://news.ycombinator.com/item?id=9431944

http://www.reddit.com/r/programming/comments/2wfwqv/16_months_of_functional_programming/

https://superginbaby.wordpress.com/2015/04/08/teaching-haskell-to-a-10-year-old-day-1/

https://vimeo.com/123181714

http://williamdemeo.github.io/2014/02/27/learn-you-an-agda/ Agda

https://www.edx.org/course/delftx/delftx-fp101x-introduction-functional-2126

http://www.slideshare.net/ScottWlaschin/fp-patterns-buildstufflt

http://eb.host.cs.st-andrews.ac.uk/drafts/effects.pdf

http://fby.by/

http://maryrosecook.com/blog/post/a-practical-introduction-to-functional-programming

http://avaxhm.com/ebooks/programming_development/1435712757z.html

Lazy Evaluation

https://hackhands.com/lazy-evaluation-works-haskell/

http://habrahabr.ru/post/247213/

https://medium.com/@chcokr/a-beginners-thoughts-on-programming-languages-part-3-lambdas-closures-functors-922a6a887575

http://en.wikipedia.org/wiki/Anonymous_function

http://jaspervdj.be/posts/2014-11-27-comonads-image-processing.html

http://habrahabr.ru/post/249803/

http://howistart.org/posts/haskell/1

https://news.ycombinator.com/item?id=8618486

http://habrahabr.ru/search/page8/?q=%5Bhaskell%5D

https://www.youtube.com/playlist?list=PLxj9UAX4Em-Ij4TKwKvo-SLp-Zbv-hB4B

http://julesjacobs.github.io/2014/10/16/the-best-collections-library-design-1.html

http://julesjacobs.github.io/2014/10/18/the-best-collections-library-design-2.html

http://psnively.github.io/blog/2014/10/14/Curry-Howard-the-Ontological-Ultimate/

http://andrew.gibiansky.com/

http://www.cs.cmu.edu/~crary/819-f09/ classic papers

https://developer.apple.com/swift/blog/ SWIFT blog

http://jelv.is/blog/Haskell-Monads-and-Purity/

https://news.ycombinator.com/item?id=8408452

https://stevekrouse.github.io/hs.js/

https://app.doxiq.com/d/rbczklzyvgczkfgh/Getting-it-Done-with-Haskell-pdf

https://news.ycombinator.com/item?id=8155832

http://pbrisbin.com/posts/applicative_functors/

Russian Haskell Book

http://dshevchenko.biz/hs/

http://ohaskell.dshevchenko.biz/ru/

https://github.com/denisshevchenko/ohaskell-code

https://gumroad.com/l/haskellbook?getthebook=Get+Haskell+Programming+now+from+Gumroad

http://dev.stephendiehl.com/hask/ How to learn haskell

http://www.happylearnhaskelltutorial.com/contents.html

http://habrahabr.ru/post/230649/ Lenses in JavaScript

Example in Haskell:

-- A binary tree. data BinaryTree a = Leaf a | Branch a (BinaryTree a) (BinaryTree a) -- Depth-first search. dfs :: Int -> BinaryTree Int -> Bool dfs x (Branch y left right) -- We found x in a branch if: = x == y -- the value at the branch equals x, || dfs x left -- or the value was found in the left branch, || dfs x right -- or the value was found in the right branch. dfs x (Leaf y) = x == y -- We found x in a leaf if the value at the leaf equals x. main = print (dfs 0 (Branch 1 (Branch 0 (Leaf 4) (Leaf 5)) (Leaf 2))) -- 1 -- / \ -- 0 2 -- / \ -- 4 5

An equivalent in C:

typedef enum Tag { LEAF, BRANCH } Tag; struct BinaryTree; typedef struct Leaf { int value; } Leaf; typedef struct Branch { int value; struct BinaryTree* left; struct BinaryTree* right; } Branch; typedef struct BinaryTree { Tag tag; union { Leaf as_leaf; Branch as_branch; } data; } BinaryTree; int dfs(const int x, const BinaryTree* const tree) { switch (tree->tag) { case BRANCH: { // Assumption: tree->tag == BRANCH ==> tree->data.as_branch is valid. const Branch* const branch = &tree->data.as_branch; return x == branch->value || dfs(x, branch->left) || dfs(x, branch->right); } case LEAF: // Assumption: tree->tag == LEAF ==> tree->data.as_leaf is valid. return x == tree->data.as_leaf.value; default: // This should never happen. exit(1); } }

Notice how in the Haskell version, because tags and unions are coupled, we can simultaneously check the tag and extract the fields with pattern matching. That means we don’t suffer from the same problem as in the C version, where we make assumptions in the switch branches based on the Boolean conditional. That’s a problem because the reliance on an implicit proof of correctness means the code isn’t as easy to refactor correctly.

http://www.ccs.neu.edu/home/matthias/HtDP2e/ Scheme book online

http://shaffner.us/cs/papers/tarpit.pdf

https://www.cs.uoregon.edu/research/summerschool/summer14/curriculum.html

http://habrahabr.ru/post/228957/ Idris

Finger Trees

http://habrahabr.ru/post/240783/

http://habrahabr.ru/post/243205/

http://habrahabr.ru/post/101818/ catresian trees treap

http://habrahabr.ru/search/?q=%5Bhaskell%5D

Monoids Monades

http://monadmadness.wordpress.com/2015/01/02/monoids-functors-applicatives-and-monads-10-main-ideas/

http://habrahabr.ru/post/112394/

http://slepnev.blogspot.ch/2014/06/yet-another-monad-tutorial.html

http://babkin-cep.blogspot.com/

HASKELL

https://github.com/bitemyapp/learnhaskell

http://haskellbook.com/

http://haskelldata.com/

http://dev.stephendiehl.com/hask/

http://shuklan.com/haskell

https://www.youtube.com/watch?v=hsacAUEgWD4

https://www.youtube.com/watch?v=02_H3LjqMr8

http://haskelllive.com/

http://twdkz.wordpress.com/2014/06/26/teenage-haskell/

https://www.youtube.com/watch?v=Li6oaO8x2VY

http://www.haskell.org/haskellwiki/BayHac2014

http://habrahabr.ru/post/225393/ IDE for Haskell

https://wunki.org/posts/2014-05-17-haskell-packages-development.html

http://www.reddit.com/r/programming/comments/266z2z/the_essence_of_compilation_in_haskell/

https://www.youtube.com/playlist?list=PL4C1D41CB47EED318

http://channel9.msdn.com/Series/C9-Lectures-Erik-Meijer-Functional-Programming-Fundamentals/Lecture-Series-Erik-Meijer-Functional-Programming-Fundamentals-Chapter-1

http://dev.stephendiehl.com/hask/

https://gist.github.com/bitemyapp/8739525

http://blog.gja.in/2014/01/functional-programming-101-with-haskell.html

https://en.wikibooks.org/wiki/Write_Yourself_a_Scheme_in_48_Hours

http://www.reddit.com/r/programming/comments/20zk5q/online_programming_books_a_list_of_haskell_books/

http://habrahabr.ru/post/214835/

http://www.onikudaki.net/blog/archives/6

https://news.ycombinator.com/item?id=7722652 Haskell for C programmers

http://www.slideshare.net/VladPatryshev

http://kwangyulseo.com/

http://stackoverflow.com/questions/5226055/truly-understanding-the-difference-between-procedural-and-functional/5280719#5280719

http://www.reddit.com/r/programming/comments/1soyna/this_is_the_best_explanation_of_functional/

https://news.ycombinator.com/item?id=6868303 HASKELL

http://bob.ippoli.to/archives/2013/09/18/exercism/

http://jeremykun.com/2013/09/30/the-universal-properties-of-map-fold-and-filter/

http://www.lektorium.tv/lecture/?id=14048 Labmda

http://www.lektorium.tv/lecture/?id=14049 Lambda

https://www.fpcomplete.com/school?show=tutorials

http://www.haskellcast.com/episode/002-don-stewart-on-real-world-haskell/

http://people.cs.aau.dk/~normark/prog3-03/html/notes/theme-index.html

http://functionaltalks.org/

http://www.stephanboyer.com/post/5/welcome

http://www.infoq.com/presentations/Clojure-Design-Patterns

http://jliszka.github.io/2013/10/24/exact-numeric-nth-derivatives.html

http://channel9.msdn.com/Series/C9-Lectures-Erik-Meijer-Functional-Programming-Fundamentals

http://stackoverflow.com/questions/16918/beginners-guide-to-haskell

http://en.wikibooks.org/wiki/Write_Yourself_a_Scheme_in_48_Hours

http://www.cs.kent.ac.uk/people/staff/sjt/Haskell_craft/probSolving.html

http://www.soshnikov.com/fpschool/

https://www.fpcomplete.com/ School of Haskell

http://habrahabr.ru/post/182442/ Cog

http://izbicki.me/blog/

http://michaelrbernste.in/

http://michaelrbernste.in/2013/06/20/what-is-declarative-programming.html

BOOKS

https://gist.github.com/leroux/6395804

http://book.realworldhaskell.org/read/

http://lisperati.com/haskell/

http://alexott.net/ru/fp/books/

http://www.haskellcraft.com/craft3e/Home.html BOOK

http://flibusta.net/b/303593/read BOOK

http://anton-k.github.io/ru-haskell-book/book/home.html

https://github.com/anton-k/ru-haskell-book

http://yannesposito.com/Scratch/en/blog/Haskell-the-Hard-Way/

Parallel and Concurrent Programming in Haskell

http://chimera.labs.oreilly.com/books/1230000000929/index.html

http://stackoverflow.com/questions/3077866/large-scale-design-in-haskell?rq=1

What I wish I new when learning Haskell

http://www.stephendiehl.com/posts/haskell_web.html

https://gist.github.com/bitemyapp/8739525

https://news.ycombinator.com/item?id=7559425

https://www.fpcomplete.com/business/fp-haskell-center/

http://bitemyapp.com/posts/2014-03-24-monads-bind-join-actions.html

http://yannesposito.com/Scratch/en/blog/Haskell-the-Hard-Way/

https://www.fpcomplete.com/school/to-infinity-and-beyond/pick-of-the-week/haskell-fast-hard

http://www.devalot.com/articles/2013/07/why-haskell.html

https://news.ycombinator.com/item?id=5546679

http://www.reddit.com/r/programming/comments/1cbr34/what_i_wish_i_knew_when_learning_haskell/

http://www.stephendiehl.com/posts/essential_haskell.html

http://fsharpforfunandprofit.com/series/thinking-functionally.html

http://ashkenas.com/dotjs/

https://www.fpcomplete.com/school

http://dev.stephendiehl.com/hask/#(1)

http://chris-taylor.github.io/blog/2013/02/10/the-algebra-of-algebraic-data-types/

http://chris-taylor.github.com/blog/2013/02/13/the-algebra-of-algebraic-data-types-part-iii/

https://docs.google.com/presentation/d/1riFjtN6gJ20G-iSIoQxCAx5ROuZAO0rrEn07IJPXSrs/edit#slide=id.p Type Classes

http://www.cakesolutions.net/teamblogs/2013/04/05/announcing-the-pragmatic-haskeller/

Books

http://synrc.com/publications/cat/

http://ivanych.net/doc/

http://www.gundersen.net/haskell-on-windows/

http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html

http://www.cs.utexas.edu/~wcook/anatomy/

http://adit.io/posts/2013-07-22-lenses-in-pictures.html

Data Analysis

http://blog.sqreamtech.com/2013/09/using-haskell-at-sqream-technologies/ SQL+HAskell

http://twdkz.wordpress.com/2013/05/31/data-analysis-with-monoids/

http://izbicki.me/blog/hlearn-cross-validates-400x-faster-than-weka

Video

http://www.youtube.com/watch?v=WHN8ovwEDiI&list=PLvj5k87ljYYHwOOcdGvS3qi85IvjOW--8

http://shuklan.com/haskell/index.html

http://shuklan.com/haskell/

http://bob.ippoli.to/archives/2013/01/11/getting-started-with-haskell/

http://www.twirpx.com/file/999451/ russian book http://habrahabr.ru/post/158993/

http://en.wikibooks.org/wiki/Haskell

http://habrahabr.ru/post/165559/

https://github.com/BinRoot/Haskell-Lectures

http://news.ycombinator.com/item?id=5033658

http://paulspontifications.blogspot.com/2013/01/when-haskell-is-faster-than-c.html

http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-080-great-ideas-in-theoretical-computer-science-spring-2008/

http://habrahabr.ru/post/163679/ Weak Reference in Java/C#/C++/Haskell

http://matt.might.net/articles/higher-order-list-operations/

http://www.ibm.com/developerworks/library/j-ft20/

http://news.ycombinator.com/item?id=5135075

http://stackoverflow.com/questions/16426463/what-constitutes-a-fold-for-types-other-than-list

http://codeutopia.net/blog/2013/01/23/parsing-and-evaluating-php-in-haskell-part-2/

Curring

http://ru.wikipedia.org/wiki/%D0%9A%D0%B0%D1%80%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5

http://programmers.stackexchange.com/questions/185585/what-is-the-advantage-of-currying

http://www.reddit.com/r/programming/comments/181y2a/what_is_the_advantage_of_currying/

http://raganwald.com/2013/03/07/currying-and-partial-application.html

http://www.reddit.com/r/programming/comments/19w3oo/whats_the_difference_between_currying_and_partial/

http://tailcalled.wordpress.com/2012/12/31/on-types-functional-programming-and-monads/

http://synrc.com/publications/cat/Lambda%20Calculus/MEPHI2003/

http://synrc.com/publications/cat/

http://habrahabr.ru/post/161205/ Types

http://nord.org.ua/course/2012/ifp/

http://nord.org.ua/course/2011/ifp/

http://neo.com/2012/11/13/y-not-adventures-in-functional-programming-part-i

http://ro-che.info/docs/

http://www.dev.gd/20121224-understanding-map-filter-and-fold.html

http://vimeo.com/45561411

http://jkff.info/software/timeplotters/

Polyglot

http://www.reddit.com/r/programming/comments/zbc4e/interesting_language_comparison_building_a_simple/

https://speakerdeck.com/u/matt_aimonetti/p/tower-of-babel-a-tour-of-programming-languages

http://www.shenlanguage.org/index.html

http://habrahabr.ru/post/150805/ LISP in C

http://www.youtube.com/watch?v=0m6hoOelZH8

http://www.intuit.ru/department/pl/funcprog/

https://news.ycombinator.com/item?id=6082645

http://izbicki.me/blog/hlearn-cross-validates-400x-faster-than-weka

http://www.polyomino.f2s.com/david/haskell/main.html

Algebraic DataTypes

http://tech.esper.com/2014/07/30/algebraic-data-types/

http://stackoverflow.com/questions/5911267/what-are-sums-and-products-data-structures

http://tel.github.io/2014/07/23/types_of_data/

http://habrahabr.ru/post/207126/

http://programmers.stackexchange.com/questions/73933/what-are-the-uses-of-algebraic-data-types

http://www.youtube.com/watch?feature=player_embedded&v=YScIPA8RbVE&noredirect=1

http://blog.lab49.com/archives/3011

http://chris-taylor.github.io/blog/2013/02/10/the-algebra-of-algebraic-data-types/

http://en.wikipedia.org/wiki/Algebraic_data_type

http://merrigrove.blogspot.com/2011/12/another-introduction-to-algebraic-data.html

http://cpp-next.com/archive/2010/07/algebraic-data-types/

http://astitcher.github.com/ACCU2012/slides/algebraic.html

http://chris-taylor.github.com/blog/2013/02/10/the-algebra-of-algebraic-data-types/

http://news.ycombinator.com/item?id=5196708

https://github.com/benanhalt/PyAlgebraicDataTypes

Pattern Matching

http://en.wikibooks.org/wiki/Haskell/Pattern_matching

https://haifengl.wordpress.com/2014/07/03/ocaml-pattern-matching/

http://justy-tylor.livejournal.com/224308.html pattern matching

CONTINUATION

http://blogs.msdn.com/b/wesdyer/archive/2007/12/22/continuation-passing-style.aspx

MONADS

http://blog.sigfpe.com/2006/08/you-could-have-invented-monads-and.html

http://stackoverflow.com/questions/28139259/why-do-we-need-monads

http://channel9.msdn.com/Shows/Going+Deep/Brian-Beckman-Dont-fear-the-Monads

http://www.dustingetz.com/2012/09/24/StrangeLoop2012-monads-for-normal-people-in-python-slides.html

http://cdsmith.wordpress.com/2012/04/18/why-do-monads-matter/

http://dev.stephendiehl.com/hask/flat.html

http://newartisans.com/2012/08/monads-in-pictures/

http://www.reddit.com/r/programming/comments/10ve0p/comprehending_monads/c6h1cnq

http://blogs.msdn.com/b/wesdyer/archive/2008/01/11/the-marvels-of-monads.aspx

http://www.reddit.com/r/programming/comments/10ve0p/comprehending_monads/

http://marakana.com/static/courseware/scala/presentation/comprehending-monads.html#slide-0

http://www.valuedlessons.com/2008/01/monads-in-python-with-nice-syntax.html#6799472260664409462

http://news.ycombinator.com/item?id=4959680

http://habrahabr.ru/post/144523/

http://nickknowlson.com/blog/2012/08/06/seven-languages-week-3-day-3/

Haskell

http://habrahabr.ru/post/152889/

http://habrahabr.ru/post/153383/

http://habrahabr.ru/post/166353/

http://acm.wustl.edu/functional/haskell.php

http://www.seas.upenn.edu/~cis194/lectures.html

https://www.fpcomplete.com/school?show=tutorials

http://www.haskellforall.com/

http://ocharles.org.uk/blog/posts/2012-12-01-24-days-of-hackage.html

http://ocharles.org.uk/blog/posts/2012-12-11-24-day-of-hackage-ekg.html

https://news.ycombinator.com/item?id=5546679

http://fpcomplete.com/ten-things-you-should-know-about-haskell-syntax/

http://newartisans.com/2012/08/monads-in-pictures/

http://pragprog.com/magazines/2012-11/thinking-functionally-with-haskell

http://pragprog.com/magazines/2012-09/thinking-functionally-with-haskell

https://github.com/anton-k/ru-haskell-book

www.haskellforall.com

http://www.sthaskell.com/ - ebook

http://research.microsoft.com/en-us/um/people/simonpj/papers/haskell-tutorial/index.htm

http://haskelllive.com/

http://www.scs.stanford.edu/11au-cs240h/notes/

http://www.intuit.ru/department/pl/haskel98/

http://pragprog.com/magazines/2012-08/thinking-functionally-with-haskell

http://channel9.msdn.com/Shows/Going+Deep/Lecture-Series-Erik-Meijer-Functional-Programming-Fundamentals-Chapter-1

http://www.infoq.com/presentations/Functional-Thinking

http://www.ibm.com/developerworks/java/library/j-ft10/index.html?ca=drs-

http://cyrille.martraire.com/2011/03/thinking-functional-programming-with-map-and-fold-in-your-everyday-java/

http://tryhaskell.org/ http://en.wikibooks.org/wiki/Haskell

http://donsbot.wordpress.com/

http://www.learnyouahaskell.com/

http://learnmeahaskell.blogspot.com/

http://book.realworldhaskell.org/

http://habrahabr.ru/blogs/Haskell/120590/

http://blog.ezyang.com/2011/11/how-to-read-haskell/

http://habrahabr.ru/blogs/Haskell/132969/

http://habrahabr.ru/blogs/Haskell/127556/#habracut

http://en.wikibooks.org/wiki/Write_Yourself_a_Scheme_in_48_Hours

http://ru.wikibooks.org/wiki/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5

http://projects.tmorris.net/public/how-to-learn-fp/artifacts/0.1/chunk-html/index.html

http://book.realworldhaskell.org/ http://www.haskell.org/~pairwise/intro/intro.html

http://stackoverflow.com/questions/16918/beginners-guide-to-haskell

http://www.cs.nott.ac.uk/~gmh/book.html

http://www.haskell.org/haskellwiki/Practical_web_programming_in_Haskell

http://www.defmacro.org/ramblings/fp.html

http://spbhug.folding-maps.org/wiki

http://antilamer.livejournal.com/356147.html Log Plotting with Haskell

http://steve.vinoski.net/blog/internet-computing-columns/

http://blog.ezyang.com/2010/01/why-haskell/

http://blog.ezyang.com/2011/03/type-tech-tree/

http://blog.ezyang.com/2010/10/rapid-prototyping-in-haskell/

http://blog.ezyang.com/2010/08/the-gateway-drug-to-type-programming/

http://blog.ezyang.com/2010/05/design-patterns-in-haskel/

http://thesz.livejournal.com/280784.html

http://yantayga.livejournal.com/28097.html?style=mine#cutid1

https://github.com/bos/stanford-cs240h

http://www.scs.stanford.edu/11au-cs240h/notes/

http://izbicki.me/blog/gausian-distributions-are-monoids

Erlang

https://hexlet.org/course/erlang/

http://zamotivator.livejournal.com/629685.html

https://news.ycombinator.com/item?id=8571728

http://learnyousomeerlang.com/

http://howistart.org/posts/elixir/1 Elixir

http://howistart.org/posts/erlang/1

http://www.infoq.com/presentations/Building-Highly-Available-Systems-in-Erlang

http://www.infoq.com/presentations/Erlang-OTP-Behaviors

http://learnyousomeerlang.com/splash-book

http://thewebdev.de/the-erlang-stack/

http://www.slideshare.net/maxlapshin/rails-eventmachine-erlang

http://ferd.ca/repl-a-bit-more-and-less-than-that.html

http://jlouisramblings.blogspot.com/2013/01/how-erlang-does-scheduling.html

Go

http://www.golang-book.com/

http://news.ycombinator.com/item?id=3733090 Go - C - Python

http://www.darkcoding.net/software/in-memory-key-value-store-in-c-go-and-python/

http://www.diesel-ebooks.com/item/9781469769165/Balbaert-Ivo-The-Way-to-Go-A-Thorough-Introduction-to-the-Go-Programming-Language/1.html

http://www.miek.nl/files/go/

http://my.safaribooksonline.com/9780132764100?cid=shareLink

Functional Programming

http://okmij.org/ftp/ Oleg Kiselyov

http://www.vimeo.com/28105411

http://www.rsdn.ru/article/funcprog/fp.xml

http://www.ibm.com/developerworks/java/library/j-ft1/index.html

http://matt.might.net/articles/compiling-up-to-lambda-calculus/

http://matt.might.net/articles/implementation-of-recursive-fixed-point-y-combinator-in-javascript-for-memoization/

In static typing, a variable is bound to a particular type for its lifetime. Its type can’t be changed and it can only reference type-compatible instances. That is, if a variable refers to a value of type A, you can’t assign a value of a different type B to it, unless B is a subtype of A, for some reasonable definition of “subtype”.

In dynamic typing, the type is bound to the value, not the variable. So, a variable might refer to a value of type A, then be reassigned later to a value of an unrelated type X.

The term dynamically-typed is used because the type of a variable is evaluated when it is used during runtime, while in a statically-typed language, the type is evaluated at parse time.

Y-Combinator

http://hisham.hm/2011/04/04/understanding-at-last-the-y-combinator-a-programmer-friendly-perspective/