Reddit mentions: The best functional software programming books

I don't know C#, but I just spent 2 weeks working through a Kotlin textbook cover to cover, and then started rewriting my Java Android app in it. So, I'll list off some things I've enjoyed about it.

​

• Every file I've rewritten in Kotlin has reduced in line count from around 30%-50% compared to Java. And I'm probably not writing super idiomatic code yet (especially while reading the equivalent Java simultaneously and translating it over)
  
• val & var: vals are immutable, great for thread safety. Quickly you realize that most of your variables in general don't have be reinitialized.
  
• null safety: you have to opt into types being nullable with the ? operator, var person: Person vs var person: Person? - the first can't be null but the second can. Gives the compiler a lot of knowledge to enforce null safety in your app this way. The safe call (?.) and elvis (?:) operators build on this.
  
• Opt-in inheritance instead of opt-out. Classes need to be marked "open" for you to be allowed to inherit from them. Makes it so you can enforce a composition over inheritance style architecture.
  
• Extension functions: since you can't inherit, you still sometimes need to add functionality to a class for some purpose. Extension functions can be attached to the class definition, but private to a module (or added to a utility Extensions file that you can opt-into importing). So you can add behavior, but don't have to pollute the ecosystem outside of your module if your extensions aren't valuable in general usage.
  
• Not everything has to be part of a class. You can have free-standing functions
  
• The scoping functions are really nice (let, run, also, with, apply)
  
• when statements are really nice
  
• It's a multi-paradigm language, so you can take the best parts you enjoy from both OOP and functional development styles

While LYAH is a fantastic book, I also felt a bit lost after reading it. You're still kinda useless as a Haskell programmer, all the practical things like 'drawing to the screen', 'calling a web API' are not included and bread & butter concepts like monad transformers, arrays/vectors, exceptions, any form of parallelism / concurrency, widely used language extensions etc., required to use/understand many libraries, are not discussed.

I can recommend Real World Haskell as a second book. Skip the basic early chapters and some of the outdated stuff, and you're still left with enough good parts. Also the Parallel and Concurrent Haskell book is truly excellent. It's written in a way that should make it accessible to someone with just LYAH under their belt. Both are available online for free, btw.

I haven't personally read it, but some people here recommend this book:
www.amazon.com/Beginning-Haskell-A-Project-Based-Approach/dp/1430262508/

Also, have you seen this great collection:

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

? That should give you a good introduction to many of the advanced concepts.

I would also recommend to check out 24 days of hackage to get a good idea of Haskell's library ecosystem:

https://ocharles.org.uk/blog/pages/2012-12-01-24-days-of-hackage.html
https://ocharles.org.uk/blog/pages/2013-12-01-24-days-of-hackage.html

Hope that helps, good luck! ;-)

> For stuff you can pay for, take a look at Joe Armstrong's Programming Erlang: Software for a Concurrent World. Joe Armstrong's one of the creators of Erlang and gives a pretty good description of the language and why it was thought the way it is. Then you should read Erlang Programming from Francesco Cesarini and Simon Thompson. It's almost a continuation of Joe Armstrong's book in the sense that it will tell you more about Erlang's environment and how to make complete safe, reliable and scalable applications.

Personally, I highly recommend reading Francesco's book first, as I've found Joe's book to be too daunting sometimes. I don't know how to explain it better. It just seems like Francesco's experience in teaching erlang classes for 10+ years shows through his book.

I'm still in the process of reading Francesco's book, so maybe I'm biased because I'm already familiar with many things and I had no contact to erlang (except for some info/examples on erlang.org which sparked interest) prior to reading Joe's book.

Edit: Forgot to mention that some reviewers over at amazon support my thesis.

Yes, which is totally awesome BTW, and I think your book is a great place for people to start.

https://www.amazon.com/Web-Development-Clojure-Build-Bulletproof/dp/1680500821/

The question is, for a newbie interested in Clojure, how do we direct them to Luminus, or a similar set of beginner "blessed" libraries, as a definitive starting spot. To keep them from getting lost in the universe of alternative options. Basically every step of the process of getting started presents a beginner with options that they won't know how to answer until much later. Emacs or Cursive, Boot or Lein, Pedestal or Ring, Selmer or Enlive, Korma or Yesql, Om or Reagent.

What helped make Ruby and Rails easy to learn is those initial choices were pre-made. You were using Textmate, Rails (Rack, ActiveRecord, Prototype). Even though there were some bad choices, like Prototype as the default JS library, just by that choice being pre made it let you move forward into the learning. And by the time you built something, you knew enough to swap it out for JQuery, or whatever.

In practice lots of companies of all sizes are using Clojure for web development today. The success stories on the official site are a good place to start to see what it's being used for. I work in the enterprise and my team moved from Java to Clojure over past 6 years. We couldn't be happier with our decision.

What practical examples are you looking for specifically?

I published a Web Development with Clojure book that specifically focuses on building web applications using the language.

There aren't any frameworks because the community hasn't found them to be of value so far. However, that doesn't imply that there isn't a mature web platform available for Clojure. Luminus is widely used. It couples a template for generating the boilerplate for typical applications with documentation on how to accomplish common tasks. There are other alternatives as well such as Yada and Pedestal.

In terms of libraries and ecosystem, here are a few examples:

• compojure-api is a fantastic library for writing services
  
• HugSQL is a library I use for database access, but there are lots of others such as Honey SQL.
  
• you can use any Java logging library, I personally use logback. However, there's Timbre which is a Clojure centric logger.
  
• buddy is a popular authentication and authorization library
  
  Polymorphism is supported in the language via multimethods and protocols.
  
  Libraries such as component and integrant are used for inversion of control. Meanwhile, mount provides a novel and automated way to manage resource lifecycle.
  
  My experience working with OOP for over a decade is that it does not deliver on its promises. Large OOP codebases end up tangled and difficult to maintain due to shared mutable state. These systems are hard to reason about and they're hard to test. Any time you come back to an old project, it's hard to tell whether a change you make will be isolated or it will affect another part of the application via side effects.
  
  I found that code reuse was difficult to accomplish in practice, and also rare. With a language like Java, you end up writing most of the logic in methods, and those are only usable within the context of a particular class. When you need a similar method in a different class, you can't reuse your existing code directly. This leads to a mess of adapter and wrapper patterns often seen in OO codebases.
  

This will sound like it's just a tour of new features, but I feel like it's just a blow by blow guide on how to use c++17 well. I think it's a good book.

C++17 STL Cookbook: Discover the latest enhancements to functional programming and lambda expressions https://www.amazon.co.uk/dp/B01MTSADN8/ref=cm_sw_r_cp_apa_i_xEImDbGQ586RJ

Excellent! Thanks for the submission. For a mathier book, I recommend Lazy Functional Languages: Abstract Interpretation and Compilation.

If you're going to try tackling an MMORPG and scalability is a concern, think about learning Erlang. You can go from one server up to a hundred and you won't have to appreciably change your programming model, you get access to mnesia an erlang-centric distributed database, and can write each npc as a separate cooperative task if you really want to, which lets then think more complicated thoughts over multiple timesteps more easily.


Edit:

I'm not sure what about this post merited downmodding it into oblivion. I'm hardly an Erlang zealot. In fact this is pretty much the only domain for which I would recommend using Erlang to develop.

Erlang has been used for several massively multiplayer/multiuser projects.

• It is used for facebook's chat servers.
  
• Vendetta Online rewrote their server-side logic using Erlang.
  
• Open Poker gains a great deal of scalability and robustness from Erlang.

I was looking at his book, but I honestly think this one is a far better choice:

https://www.amazon.com/How-JavaScript-Works-Douglas-Crockford/dp/1949815005

I've dug into several haskell books and resources online and as crazy as it sounds my favorite book was: :https://www.amazon.com/Haskell-Cookbook-functional-applications-Applicatives-ebook/dp/B073QW9LS3/ref=sr_1_2?ie=UTF8&qid=1527444265&sr=8-2&keywords=Haskell+Packt

It's practical, short, gets you building projects, and has very clean examples and pictures. Very simple and easy to digest explanations.

The "entity3 gameState5 garbage" is more elegantly handled with the State/StateT monad. You may also want to check out the lens library. Lens + State monad is probably what you're looking for.

Check out [real world haskell chapter on monads (including State)] (http://book.realworldhaskell.org/read/monads.html) And google for some Lens tutorials online. I liked the chapters on State (and other monads) and the introduction to the Lens library in http://www.amazon.com/Beginning-Haskell-A-Project-Based-Approach/dp/1430262508

Also, you don't need to do:

let (entity, gameState') = createEntity gameState player
let square = createSquare (12 float2Double normalScale) (16 float2Double normalScale)

Instead do:

let (entity, gameState') = createEntity gameState player
square = createSquare (12 float2Double normalScale) (16 float2Double normalScale)

Never heard of it. Looked it up:

https://www.amazon.com/gp/product/1949815005/

> Douglas Crockford starts by looking at the fundamentals: names, numbers, booleans, characters, and bottom values. JavaScript’s number type is shown to be faulty and limiting, but then Crockford shows how to repair those problems. He then moves on to data structures and functions, exploring the underlying mechanisms and then uses higher order functions to achieve class-free object oriented programming. The book also looks at eventual programming, testing, and purity, all the while looking at the requirements of The Next Language. Most of our languages are deeply rooted in the paradigm that produced FORTRAN. Crockford attacks those roots, liberating us to consider the next paradigm.He also presents a strawman language and develops a complete transpiler to implement it. The book is deep, dense, full of code, and has moments when it is intentionally funny.

If I had to guess, I would say books tend to appeal more to those learning JavaScript and this book seems to cover more advanced topics which could make it less appealing. Its also still early. The book hasn't been out for a month yet. But my first impression is that the cover is not doing much to help. To me it looks dated :P

Web Development in Clojure, written by the author of this library, is also very good.

Functional Programming in C#: How to write better C# code https://www.amazon.com/dp/1617293954/ref=cm_sw_r_cp_apa_i_MrNzDb7EHSB42

If you don't mind spending money, spend it on a good book such as this. You can probably hack some decent web apps with just online tutorials and documentation though.

Here is the desktop version of your link

Perhaps you will find all the answers in this book: Web Development with Clojure: Build Bulletproof Web Apps with Less Code 2nd Edition by Dmitri Sotnikov

They weren't:

http://book.realworldhaskell.org/

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

http://www.amazon.com/Beginning-Haskell-A-Project-Based-Approach/dp/1430262508/ref=sr_1_2?ie=UTF8&qid=1406236911&sr=8-2&keywords=haskell

http://www.amazon.com/Haskell-Analysis-Cookbook-Nishant-Shukla-ebook/dp/B00LB6DIQU/ref=sr_1_1?ie=UTF8&qid=1406236986&sr=8-1&keywords=haskell+data+analysis+cookbook

Beginning Haskell

Haskell Data Analysis Cookbook

https://www.amazon.com/Kotlin-Programming-Nerd-Ranch-Guide/dp/0135161630/ref=nodl_

I like Kotlin Programming by Big Nerd Ranch though I cannot compare it to other books. But Big Nerd Ranch are reputable.

Effective Kotlin is probably for the more advanced but the book wasn't/isn't well received by this community so you will have to do your research on if it's for you.

Thompson's book was updated in 2011, and the Apress book looks like a good learning resource generally but I haven't read beyond a few chapters. There's a few odd typos where Mena writes "Platform does something" and he means GHC.

(Also, how about Bird's Pearls book? Hudak, School of Music?)

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

http://www.amazon.com/Beginning-Haskell-A-Project-Based-Approach/dp/1430262508