It has nothing to do at all with what kind of thing you are building, it is a general means of expressing common patterns in programs. Much of the reason people like FP is because it provides a high degree of code reuse in standardized forms, and it does so with a good bit of terseness and flexibility. Just about everything else in the FP world is about optimizing safety, performance, and reliability without giving up these benefits.
When someone says "FP is good," it's analogous to saying "well-commented code is good." As in, it's good everywhere you have the time to do it correctly. (There just happens to be a lot of debate about how to do it correctly.)
Sure, I get what it is but what I don't get is how I would use it in my world of mutating data and side-effects.
I understand what you mean, because even though I love FP a lot, I still struggle to conceive whole systems (other than simple map-filter dataflow ones) this way. So far I keep the FP principles for small pieces, hoping later on I'll find a way to close the gaps.
[1] John Backus tried to design purely functional languages a long time ago and he hit the IO wall (he mentions it in some article). Haskellers had issues at first and found that Monads were a nice functional way to express IO-like logic. It's still something weird, a lot less clean than purely functional expressions to be evaluated.
Most of us probably already follow best practices in terms of small functions, no global state, promises, composability etc. But at the end of every chain I have a db query and most of those mutate some data or other.
Hopefully some day it clicks.
While you wait for that, try writing useful code despite not fully understanding it.
Tell me what you think of the following code examples:
> sum . take 2 $ [1,2,3,4,5]
3
> -- now lets pretend we have a list of numbers we got from the DB
> let mockDBResponse = return [1,2,3,4,5] :: IO [Int]
> -- first lets try the exact same code as above
> sum . take 2 $ [1,2,3,4,5]
3
> sum . take 2 $ mockDBResponse
<interactive>:46:16:
Couldn't match expected type ‘[c]’ with actual type ‘IO [Int]’
Relevant bindings include it :: c (bound at <interactive>:46:1)
In the second argument of ‘($)’, namely ‘mockDBResponse’
In the expression: sum . take 2 $ mockDBResponse
> -- what to do? Use <$>
> import Control.Applicative ((<$>))
> sum . take 2 <$> mockDBResponse
3
1) Applying pure functions to pure functions sum . take 2 $ [1,2,3,4,5]
2) Applying pure functions to monadic functions that implement fmap of the Functor typeclass sum . take 2 <$> [1,2,3,4,5]
When I noticed that adding brackets around $ allowed me to apply pure functions to monadic ones a lot more made sense to me.See "Turning the database inside out with Apache Samza" by Martin Kleppmann: https://www.youtube.com/watch?v=fU9hR3kiOK0
It is, again, like saying "I don't see how this helps me in my world of uncommented code". You could just comment your code, right?
(Or if that's too much work, or it's a shared code base and you can't get buy-in, just start going forward?)
What you want to avoid is side-effects. One class of side-effect would be database operations. So let's imagine you have this code:
let products = [{id: 1, price: 10.12, desc: 'foo'}, {id: 2, price: 5, desc: 'bar'}];
for (i = 0; i < products.length; i++) {
products[i] = formatPrice(products[i]);
}
console.log(products);
Looks good, right? I mean, presumably formatPrice just, I dunno, turns prices from numbers into strings like "$5.00", or whatever. But what if formatPrice looked like this? function formatPrice(product) {
product.desc = '';
saveToDatabase(product);
product.price = '$' + product.price.toString();
return product;
}
There might be some reason why that's the exact functionality you want, but it's terrible practice to write; your price formatting code is performing database operations, which are side effects. Don't do that. :)What you want is to chain together a number of simple functions. And sure, one of them could even be "saveToDatabase". That's fine. What's not fine is having some random function, somewhere, randomly mutating your database.
If you think FP requires you not to use a database, you've badly misunderstood FP. What it's asking is for you to be explicit about what you're doing. Pure functions are easy to reason about; global variables are hard. Database operations are especially hard to reason about, which is why you want them locked away safely at the start and end of your processing chain, and not just as random side effects of otherwise unrelated code.
The book in question gives the following explanation for what a side-effect is: "We'll be referring to effect as anything that occurs in our computation besides the calculation of a result."
This is in chapter 3, and they provide the following list for what is a possible side-effect:
- changing the file system
- inserting a record into a database
- making an http call
- mutations
- printing to the screen / logging
- obtaining user input
- querying the DOM
- accessing system state
With that in mind, there is not much I can do in my code and have a functional app without side-effects.Not quite. Let's take one of those side effects as an example... say accessing system state.
You probably aren't just accessing system state. You probably want to update it in some way right? Your function to update it could easily be pure.
Take obtaining user input for example. Getting the user input is usually the most boring part of the program isn't it? The majority of what you do with that user input could very likely be pure functions.
You also get the benefit that those side effects have a set of laws to govern their behavior in failure cases.
It's refreshing getting rid of the whole class of bugs caused by developers using harmless sounding method names that subtly alter their data.
It did require substantial rewriting of the basic units of the program I tried it in, so there is that...
Calculus is not for economics but there are guides to calculus for economics majors. A given language isn't word processing but a "guide to writing a word process in Pascal" is not unimaginable.
The parent asked for a guide to using functional programming for the web back end. I'm not sure why sure a thing couldn't exist.
In the case of JS, using functional techniques simplifies the code quite substantially. Testing becomes easier. Immutable data can be much easier to reason about. It's often orthogonal to OOP, functional techniques in the small, OOP to structure in the large. FRP is very useful for interactions front-end (form validation for example), but also is just all-round terrific for message passing. Recursion is ideal for certain scenarios. If you take something like handling errors, an example would be the way promises deal with them, with the ability to collect at the end of the chain, or deal on a case-by-case basis.
I'm just listing stuff off the top of my head; with a general-purpose language [with the option of different paradigms] it's not so much a case of 'build a web app', it's more 'if you use these techniques, you may well find that your code is easier to reason about'.
I think the metaphor I like is that with FP it's as if you have an assembly line of functions, and you pass your data down the line, with each function transforming in turn; each function can easily be ripped out and/or replaced and tested. There are multiple downsides and pitfalls - overly abstracted code being a very common one, but as a general approach it's often extremely useful.
Books maybe worth a flick through (tried to pick stuff that is less...abstract, & I have specific interests, so am biased) - Functional JS by Michael Fogus, Programming Elixir by Dave Thomas, Learn You Some Erlang for Great Good by Fred Hébert & Programming Erlang by Joe Armstrong
Railway Oriented Programming (F#) http://fsharpforfunandprofit.com/rop/
Netflix talking about FRP http://youtu.be/XRYN2xt11Ek
(sorry for the slightly rambling post, typing & copy/pasting ain't great on a phone)
I personally like Eric Normand's "Web Development in Clojure" videos[0].
Like another commenter mentioned, FP is not a tool to use here but not there, it's a general method of abstraction that can reduce a lot of clutter and boilerplate, and make the code more terse, so that when you read it, you see what your are doing, rather than be entangled in all the details of how you are doing it.
I personally utilize functional programming concepts all the time, to the point that I get very frustrated when I have to work in a language that doesn't support functional programming.
We then ended up mixing in some WebGL for high performance parts, and that turned out to work best as more object-oriented code. Probably partly due to the library we used.
http://realworldhaskell.org/ (sometimes code is too old to compile)
also good: https://nikita-volkov.github.io/a-taste-of-state-parsers-are...
> database queries
https://www.fpcomplete.com/school/advanced-haskell/persisten...
> performing business logic
Give a more specific example. Preferably with code, and I'll respond with a Haskell/FP equivalent.
> calls to memcached,
import qualified Database.Memcache.Client as M
mc <- M.newClient [M.ServerSpec "localhost" 11211 M.NoAuth] M.defaultOptions
M.set mc "key" "value" 0 0
v <- M.get mc "key"
More on memcache here: http://hackage.haskell.org/package/memcache> handling error cases/messages,
http://book.realworldhaskell.org/read/error-handling.html
> validating input
Give an example on input. Depending on complexity I'd most likely use attoparsec or maybe just stuff from the text library.
> outputting data in various formats (JSON, HTML templates, etc.)
JSON: http://hackage.haskell.org/package/aeson
HTML: Not sure about outputting html from a data type's structure, but this might be what you are looking for: http://hackage.haskell.org/package/blaze-html
> how/where does FP help with that?
First I need to know what your definition of FP is. I think it's safe for me to say without knowing your definition that it doesn't help with those specifically as much as it does with tying them all together and having a greater handle on what their behavior/interaction with eachother will be.
> Is FP more a paradigm for computationally intensive programming? Back-end web programming? Front-end?
General purpose.
> I come across "FP is good" all the time, but I've never found any kind of resource to help me understand the tradeoffs between FP and non-FP, where it makes sense to use it and where it doesn't.
That's a shame and I couldn't find really good ones either. To be fair though, such a comparison wouldn't be the easiest to create. I'll add it to my "attempt to blog about" list and we'll see what happens.
In the meantime this might help:
http://phaazon.blogspot.com/2014/02/regular-imperative-state...
> Or any kind of FP tutorial on how to build, for example, a basic web CRUD app.
https://www.fpcomplete.com/school/advanced-haskell/building-...
http://adit.io/posts/2013-04-15-making-a-website-with-haskel...
https://github.com/ryantrinkle/memoise
https://news.ycombinator.com/item?id=9830431
I'm also in the middle of creating a Haskell version of the Django polls tutorial:
(And to all the other replies/links as well, I can't edit my original comment anymore and don't want to take up space with extra comments. But all very appreciated!)
I also have a few semi-useful things on my blog currently so I'll go ahead and put that in my profile as well.
EDIT: Additionally, if you experiment with Haskell be sure to use Stack[0] instead of cabal to avoid potential headaches. The Stack wiki[1] was a useful but easily overlooked resource for me as well.
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: https://www.youtube.com/watch?v=m3svKOdZijA (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: http://www.cs.cmu.edu/~rwh/theses/okasaki.pdf
Real World Haskell: http://book.realworldhaskell.org/read/
Real World OCaml: https://realworldocaml.org/v1/en/html/index.html The Joy of Clojure: http://www.manning.com/fogus2/
Learn You a Haskell for Greater Good: http://learnyouahaskell.com/chapters
Learn You some Erlang for Greater Good: http://learnyousomeerlang.com/content
Systems Programming in OCaml: https://ocaml.github.io/ocamlunix/
[0] https://monadmadness.wordpress.com/2015/01/02/monoids-functo...
E.g. when most of the code I write is database queries, performing business logic, calls to memcached, handling error cases/messages, validating input, and then outputting data in various formats (JSON, HTML templates, etc.) -- how/where does FP help with that?
Is FP more a paradigm for computationally intensive programming? Back-end web programming? Front-end? I come across "FP is good" all the time, but I've never found any kind of resource to help me understand the tradeoffs between FP and non-FP, where it makes sense to use it and where it doesn't. Or any kind of FP tutorial on how to build, for example, a basic web CRUD app.