Hey Underscore, You're Doing It Wrong!

I find this talk inspiring. Underscore.js got many things wrong for FP: ▶ this video . I've read Grokking Simplicity too. It's very approachable book. Highly recommend it for JS/TS developers who want to learn FP!

There is an excellent talk called "Underscore, you're doing it wrong!". The talk explains how well designed param order with currying leads to very short and expressive code -- and how underscore missed the boat. This aspect of it should be interesting as it's related to this post. It's well worth the watch. ▶ this video

That is great feedback. I am actually working on creating a "functional" version of the 2048 game, along with my own implementation of the AI solver, as part of this series. Kinda goofy, and maybe not a "real world" situation as much, but should at least show the concepts being applied. I also very much recommend this video by Brian Lonsdorf, titled "Hey Underscore, You're Doing It Wrong!: ▶ this video

With all due respect, I don't think you understand the purpose of currying and partial application. In your defense, the article merely explains what currying is, but does not explain why you need it. For instance while writing functional Javascript code, I never curry my methods, instead I use helper methods from functional libraries such as lodash or Ramda to curry. Where currying is useful is in cases like this: ```javascript //Definitions const filterUsers = (fieldName, value, users) => //Implementation const sortUsersBy = (fieldName, users) => //Implementation const takeUsers = (count, users) => //Implementation //Without currying UserService .getUsers() .then(users => filterUsers('active', true, users)) .then(users => sortUsersBy('age', users)) .then(users => takeUsers(3, users)); //If these methods were curried UserService .getUsers() .then(filterUsers('active', true)) .then(sortUsersBy('age')) .then(takeUsers(3)); ``` Here is a video which explains proper uses of currying (and does it very well) [1]. Here is another article if your coworker start using functional programming and you want to stop them [2]. 1. ▶ this video 2. link

Because then you can curry/partially apply functions independent of your data. It's _not_ because it's convention everywhere else. (I realize that only really makes sense if you know why it makes sense, so this video gives a pretty good explanation in ~30 minutes - ▶ this video )

You might already be using certain functional programming constructs without being aware of them. Contrary to popular misconception, OOP and functional programming don't have to be mutually exclusive. "Pure" functional programming (ala Haskell) and OOP most certainly are to an extent non-overlapping (since OOP has state+behaviour at its core), and pure fn-languages have no side-effects. High-order function in java don't exist, so one would do : new Thread(new Runnable() { ... }).start(); A builder pattern can be distilled down as a form of partial application (or, currying, if you like. They aren't the same thing, but are very similar): alertDialog .setMessage(...) .setPositiveButtonText(...) .setNegativeButtonText(...) .setPositiveButtonOnClickListener(...) .setNegativeButtonOnClickListener(...) .build() .show() Functors (in OCaml) can be viewed as Java's abstract-generic-classes with dependency injection [0]. Note that functors in different languages mean different things. Monads are tricky to understand [1], I have been led to believe. But if you use the promises API in javascript, then you're using a form of monad [2]. If you're familiar with javascript, have a look at: ▶ this video (Hey Underscore, you're doing it wrong!) I think the best way is to read a book on fn-programming. I've heard most people recommend these (pick a language, and choose a book; you cannot go wrong with any of these): Functional DS: link Real World Haskell: link Real World OCaml: link The Joy of

If you're interested in FP in javascript, you should check out the relatively new Ramda.js [1]. It switches from the underscore style collection first call pattern to a collection last pattern and automatically curries its functions. The combination allows for easier function composition. [1] link More info on the topic: link ▶ this video link

I would add: 'Hey Underscore, You're Doing It Wrong' -- ▶ this video It is much better than the title would suggest :)

Meh, I don't know or use Haskell and I'm interested in this stuff. I'm a javascript programmer introduced to these concepts via [1] ▶ this video and link . Programming in a point free style in javascript is great! 1: Hey Underscore, You're Doing it Wrong!

> Reading and understanding underscore will improve your functional programming skills. No. underscore does it wrong (check ▶ this video ) Check some of the real functional libs like Ramda and Pointfree Fantasy

Recently watched this video, which describes why underscore is actually making this difficult through its design. ▶ this video

@lrichardson, I agree with "your way", and apparently you are not alone. See Brian Lonsdorf talk about it, ▶ this video