Functional Programming Paradigm Survey (Responses)

	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S
1	Timestamp	Are you currently in academia or the tech industry?	How many years of programming experience do you have?	Are you aware of the functional programming paradigm?	For how many years have you worked with functional languages?	Do you personally like working with the object-oriented paradigm or functional paradigm more?	Do you think you're more productive when using the object oriented paradigm or the functional paradigm?	Which functional languages have you used before?	(Optional) What are some things you've used functional programming for?	What are your reasons for choosing the functional paradigm when you voluntarily do so?	On a scale of 1 - 5, how important is each of these criteria when choosing between multiple functional languages? [intuitiveness of syntax]	On a scale of 1 - 5, how important is each of these criteria when choosing between multiple functional languages? [quality of official documentation]	On a scale of 1 - 5, how important is each of these criteria when choosing between multiple functional languages? [presence of developer community]	On a scale of 1 - 5, how important is each of these criteria when choosing between multiple functional languages? [access to good tutorials]	On a scale of 1 - 5, how important is each of these criteria when choosing between multiple functional languages? [performance (time, memory)]	On a scale of 1 - 5, how important is each of these criteria when choosing between multiple functional languages? [concurrency]	On a scale of 1 - 5, how important is each of these criteria when choosing between multiple functional languages? [interoperability with OOP (or other paradigms)]	On a scale of 1 - 5, how important is each of these criteria when choosing between multiple functional languages? [available libraries and frameworks]	Any other comments or feedback :-)

2	3/13/2016 7:55:10	Academia (including students)	4-8 years	No	< 1 year	Object oriented	Object oriented	None		Performance (time, memory), Concurrency	2	2	3	2	1	1	2	2
3	3/13/2016 8:29:57	Academia (including students)	4-8 years	Yes	2-4 years	Functional	Object oriented	Haskell, Scala	Building APIs, computational theory classes	Lambda expressions and lambda calculus, Cleaner, conciser code, Concurrency, Lazy evaluation	5	3	4	4	4	3	3	4
4	3/13/2016 9:53:58	Academia (including students)	2-4 years	Yes	< 1 year	Functional	Functional	Haskell, Scheme, Elixir, Elm		Cleaner, conciser code, Ease of formal verification	5	5	5	5	3	3	1	5
5	3/13/2016 10:07:25	Academia (including students)	4-8 years	Yes	< 1 year	Object oriented	Functional	F#		Immutability and statelessness, Cleaner, conciser code, Seems more intuitive than OOP (or other paradigms), Ease of formal verification	5	5	2	2	5	5	2	2
6	3/13/2016 10:16:11	Academia (including students)	4-8 years	Yes	1-2 years	Functional	Functional	Lisp, Haskell	Interpreters, compilers, parsers	Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Seems more intuitive than OOP (or other paradigms), Ease of formal verification	4	4	4	4	4	3	2	4
7	3/13/2016 10:56:01	Academia (including students)	2-4 years	Yes	1-2 years	Functional	Functional	Lisp, Haskell, Scheme		Immutability and statelessness, Lambda expressions and lambda calculus, Lack of side-effects, Seems more intuitive than OOP (or other paradigms), Concurrency, Lazy evaluation	4	4	3	4	3	4	2	4
8	3/13/2016 11:07:22	Industry	1-2 years	Yes	< 1 year	Object oriented	Object oriented	Scala		Cleaner, conciser code, Performance (time, memory), Concurrency	4	4	4	3	4	5	4	5
9	3/13/2016 11:07:29	Industry	4-8 years	Yes	< 1 year	Both	They are not contradictory	Haskell, Erlang, Elixir		Immutability and statelessness, Cleaner, conciser code, Lack of side-effects, Concurrency	5	5	4	5	5	5	5	5	Object oriented vs functional is a stupid debate in my opinion. They do not contradict each other. Object oriented is a style of structuring code and functional programming teaches how to treat code blocks as mathematical functional and write declarative code
10	3/13/2016 11:16:00	Academia (including students)	2-4 years	Yes	< 1 year	Object oriented	Object oriented	Haskell, Scala		Cleaner, conciser code	4	4	4	4	3	3	3	3
11	3/13/2016 11:39:56	Academia (including students)	4-8 years	Yes	< 1 year	Object oriented	Functional programming is very useful for some domains, but not for others.	OCaml		Immutability and statelessness, Performance (time, memory), Ease of formal verification	3	5	2	3	4	3	3	3
12	3/13/2016 11:51:43	Academia (including students)	2-4 years	Yes	< 1 year	Object oriented	Well it depends on the task really. Sometimes functional makes things more easy, but most of the time, things can be done with OOP pretty well	Lisp, Scheme	Parallelism	Lambda expressions and lambda calculus, Cleaner, conciser code, Concurrency	2	4	3	3	5	5	4	5
13	3/13/2016 12:01:45	Academia (including students)	4-8 years	Yes	4-8 years	Functional	Functional	Lisp, Haskell, OCaml, Clojure, Scheme		Immutability and statelessness, Cleaner, conciser code, Lack of side-effects, Concurrency, Ease of formal verification	2	3	3	2	3	4	1	1	If there were rows for "purity" or "proper typeclasses" in that last queston I would have given them both fives.
14	3/13/2016 12:04:29	Academia (including students)	4-8 years	Yes	< 1 year	Functional	Object oriented	Racket	College	Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms)	5	5	5	5	3	3	3	5
15	3/13/2016 12:14:13	Academia (including students)	4-8 years	Yes	1-2 years	Object oriented	Object oriented	Haskell, ML, Scheme		Lambda expressions and lambda calculus, Cleaner, conciser code, Lazy evaluation	4	4	3	3	3	2	2	3
16	3/13/2016 12:37:42	Academia (including students)	4-8 years	Yes	4-8 years	Functional	Object oriented	Lisp, Haskell		Lambda expressions and lambda calculus, Cleaner, conciser code, Seems more intuitive than OOP (or other paradigms), Performance (time, memory)	4	3	5	5	4	3	3	5
17	3/13/2016 12:40:02	Academia (including students)	2-4 years	Yes	< 1 year	Object oriented	Object oriented	Scala, OCaml		Cleaner, conciser code, Concurrency, Ease of formal verification	4	5	5	4	5	5	5	5
18	3/13/2016 13:02:40	Academia (including students)	2-4 years	Yes	1-2 years	Functional	Object oriented	Haskell		Immutability and statelessness, Cleaner, conciser code, Lack of side-effects, Lazy evaluation, Ease of formal verification	4	5	3	4	3	3	2	4
19	3/13/2016 13:16:00	Academia (including students)	2-4 years	Yes	1-2 years	Node.js	Functional	Haskell, Clojure		Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Ease of formal verification	3	4	5	5	5	3	1	2
20	3/13/2016 14:37:37	Industry	> 8 years	Yes	2-4 years	Object oriented	Object oriented	Haskell, OCaml, ML, Clojure, F#		Immutability and statelessness, Lambda expressions and lambda calculus, Seems more intuitive than OOP (or other paradigms)	5	3	4	5	2	1	1	1
21	3/13/2016 15:17:05	Industry	1-2 years	Yes	< 1 year	Object oriented	Object oriented	OCaml		Lambda expressions and lambda calculus, Concurrency	3	4	4	5	4	4	3	4
22	3/13/2016 15:42:03	Academia (including students)	4-8 years	No	< 1 year	Object oriented	Object oriented	Clojure	Professional internship projects	Cleaner, conciser code, Performance (time, memory), Concurrency	3	2	2	4	4	4	5	5
23	3/13/2016 15:47:58	Academia (including students)	> 8 years	Yes	2-4 years	Depends on what I'm doing	Object oriented	Lisp, Haskell, Scala, OCaml, ML, Scheme, Elixir, Elm, Racket	Research, Personal Projects, Teaching	Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Lazy evaluation, Ease of formal verification, Complexity of Type Systems	4	5	5	2	3	4	3	5
24	3/13/2016 16:06:41	Academia (including students)	2-4 years	Yes	< 1 year	Object oriented	Object oriented	Lisp, Scheme	Course at college	Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Ease of formal verification	5	5	5	5	3	3	4	5	I like memes.
25	3/13/2016 16:07:16	Academia (including students)	2-4 years	Yes	< 1 year	Object oriented	Object oriented	Scala		Immutability and statelessness, Cleaner, conciser code, Performance (time, memory)	4	4	4	3	4	3	4	4
26	3/13/2016 16:16:42	Industry	2-4 years	Yes	1-2 years	Object-Oriented with some functional features and with a de-emphasis on inheritance, favoring composability? like Kotlin or Swift	Object-Oriented with some functional features and with a de-emphasis on inheritance, favoring composability? like Kotlin or Swift	Lisp		Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Concurrency, Lazy evaluation	5	5	4	4	1	3	5	4
27	3/13/2016 16:37:45	Academia (including students)	4-8 years	Yes	1-2 years	Functional	Functional	Haskell		Cleaner, conciser code, Seems more intuitive than OOP (or other paradigms)	4	4	4	4	3	4	2	5
28	3/13/2016 16:46:00	Academia (including students)	1-2 years	Yes	< 1 year	Object oriented	Object oriented	None		Immutability and statelessness, Cleaner, conciser code	4	2	4	3	4	4	3	5
29	3/13/2016 16:53:14	Industry	2-4 years	Yes	2-4 years	depends on situation	depends on situation	Haskell, Clojure		Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects	3	5	5	4	3	3	1	5	Please don't reinforce the polarization between OOP and FP
30	3/13/2016 16:55:51	Industry	> 8 years	Yes	4-8 years	Functional	Functional	Lisp, Haskell, Clojure, Scheme, Erlang, F#, Elixir	Professionally	Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms), Concurrency	1	3	5	1	1	5	1	3
31	3/13/2016 16:57:41	Industry	> 8 years	Yes	4-8 years	Functional	Functional	Lisp, Haskell, Scala, OCaml, Clojure, Scheme		Lambda expressions and lambda calculus, Cleaner, conciser code, Seems more intuitive than OOP (or other paradigms)	2	2	2	3	4	3	1	4
32	3/13/2016 16:59:03	Both	2-4 years	Yes	< 1 year	Object oriented	Object oriented	None		Immutability and statelessness, Cleaner, conciser code, Lack of side-effects, Concurrency	4	4	3	5	3	4	2	4
33	3/13/2016 16:59:18	Industry	> 8 years	Yes	4-8 years	Functional	Functional	Lisp, Haskell, Scala, OCaml, ML, Clojure, Scheme, Erlang, Agda, Coq, Idris, Purescript, Elm	Essentially everything fwiw	Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms), Performance (time, memory), Concurrency, Ease of formal verification	3	3	4	2	4	4	2	5
34	3/13/2016 17:00:31	Industry	> 8 years	Yes	2-4 years	Functional	Functional	Haskell, OCaml, ML, Scheme, F#, Agda, Coq	Digital humanities research	Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms), Ease of formal verification	3	4	4	4	4	3	1	4
35	3/13/2016 17:03:11	Industry	> 8 years	Yes	4-8 years	Functional	Functional	Lisp, Haskell, Clojure, Scheme	personal, web sites, utilities	Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Concurrency	4	5	4	5	3	4	2	4
36	3/13/2016 17:09:13	Industry	1-2 years	Yes	1-2 years	Functional	Functional	Haskell	web (professional), games (personal)	Immutability and statelessness, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms)	3	5	3	5	3	2	1	5
37	3/13/2016 17:10:05	Academia (including students)	> 8 years	Yes	> 8 years	Functional	Mix	Lisp, Haskell, Scala, OCaml, ML, Clojure, Scheme, Erlang, F#		Lambda expressions and lambda calculus, Cleaner, conciser code, Ease of formal verification	3	3	3	3	3	3	3	3
38	3/13/2016 17:15:49	Industry	> 8 years	Yes	1-2 years	Functional	Functional	OCaml, Scheme		Cleaner, conciser code, Seems more intuitive than OOP (or other paradigms)	3	5	3	2	4	2	1	4
39	3/13/2016 17:16:39	Academia (including students)	< 1 year	Yes	< 1 year	Functional	Functional	Haskell, Clojure, Erlang	Network communication	Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms), Concurrency	4	5	5	4	3	5	1	3	42
40	3/13/2016 17:18:13	Industry	> 8 years	Yes	1-2 years	Functional	Unsure	Haskell		Immutability and statelessness, Cleaner, conciser code, Lack of side-effects	4	4	5	3	4	4	2	4
41	3/13/2016 17:19:22	Industry	1-2 years	Yes	< 1 year	Functional	Object oriented	Scala		Cleaner, conciser code	5	5	5	5	5	5	5	5
42	3/13/2016 17:20:53	Industry	> 8 years	Yes	4-8 years	Functional	Functional	Haskell, Scala, Elixir, JavaScript		Immutability and statelessness, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms), Performance (time, memory), Concurrency, Lazy evaluation, Ease of formal verification	5	5	5	5	3	4	2	5
43	3/13/2016 17:20:57	Industry	> 8 years	Yes	> 8 years	Functional	Both	Lisp, Haskell, OCaml, Clojure, Scheme		Immutability and statelessness, Cleaner, conciser code, Concurrency, Lazy evaluation	4	4	3	2	3	4	3	5
44	3/13/2016 17:23:05	Industry	1-2 years	Yes	< 1 year	Functional	Functional	Haskell	Personal projects	Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms), Concurrency, Lazy evaluation, Ease of formal verification	2	3	4	5	4	5	2	3
45	3/13/2016 17:23:25	Academia (including students)	4-8 years	Yes	2-4 years	Functional	Functional	Haskell, Clojure, Erlang		Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms), Concurrency, Lazy evaluation	4	4	4	4	4	4	1	4
46	3/13/2016 17:24:38	Industry	4-8 years	Yes	2-4 years	Functional	Functional	Lisp, Haskell, Scala, Clojure, Scheme		Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms), Concurrency, Lazy evaluation, Ease of formal verification	5	5	4	4	3	5	3	5
47	3/13/2016 17:24:58	Industry	> 8 years	Yes	2-4 years	Functional	Functional	Haskell		Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms)	3	4	4	4	3	3	2	5
48	3/13/2016 17:25:15	Industry	4-8 years	Yes	4-8 years	Functional	Functional	Haskell, Scheme, Erlang	Websites/web apps, system software, test software	Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms), Concurrency, Ease of formal verification	4	4	5	4	4	4	1	5
49	3/13/2016 17:31:47	Academia (including students)	2-4 years	Yes	< 1 year	Functional	Functional	Lisp	AI Lab	Lambda expressions and lambda calculus	2	5	5	5	4	4	2	5
50	3/13/2016 17:36:17	Industry	4-8 years	Yes	< 1 year	Functional	Object oriented	Haskell, Scheme		Immutability and statelessness, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms), Concurrency, Lazy evaluation, Ease of formal verification	2	3	4	4	3	3	1	3
51	3/13/2016 17:39:26	Industry	2-4 years	Yes	1-2 years	Functional	Object oriented	Scala, Elixir		Immutability and statelessness, Lack of side-effects, Seems more intuitive than OOP (or other paradigms), Concurrency	4	5	5	3	3	4	2	4
52	3/13/2016 17:43:52	Industry	4-8 years	Yes	1-2 years	Functional	Functional	Haskell, F#		Immutability and statelessness, Cleaner, conciser code, Lack of side-effects, Concurrency	4	4	4	4	3	4	2	4
53	3/13/2016 17:46:36	Industry	> 8 years	Yes	2-4 years	Functional	Functional	Lisp, Clojure, Python with itertools/functools	Simplifying programs professionally.	Cleaner, conciser code, Seems more intuitive than OOP (or other paradigms), Performance (time, memory), Concurrency, Lazy evaluation	5	5	5	3	3	5	3	5	Declarative vs Imperative is a more important distinction for me than FP vs OOP.
54	3/13/2016 17:47:52	Industry	4-8 years	Yes	< 1 year	Functional	Functional	Lisp, Clojure	personal	Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms), Concurrency, Lazy evaluation	4	4	3	5	4	4	4	5
55	3/13/2016 17:48:05	Industry	> 8 years	Yes	2-4 years	Functional	Functional	Lisp, Haskell, Scala, Clojure, Scheme		Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code	3	4	4	5	3	3	3	5
56	3/13/2016 17:48:46	Academia (including students)	4-8 years	Yes	2-4 years	Functional	Object oriented	Haskell		Lambda expressions and lambda calculus, Lack of side-effects, Lazy evaluation, Ease of formal verification	4	5	4	4	3	3	3	4
57	3/13/2016 17:52:03	Academia (including students)	2-4 years	Yes	< 1 year	Functional	Object oriented	Lisp, Haskell, Scala, Scheme		Cleaner, conciser code, Lack of side-effects, Ease of formal verification	5	4	4	4	4	4	2	5
58	3/13/2016 17:52:06	Academia (including students)	> 8 years	Yes	1-2 years	Functional	Object oriented	Lisp, Haskell, Clojure		Immutability and statelessness, Cleaner, conciser code, Concurrency, Ease of formal verification	4	5	4	2	3	3	2	3
59	3/13/2016 17:53:54	Industry	> 8 years	Yes	> 8 years	they both have their uses	depends on the situation	Lisp, Haskell, Scala, OCaml, Scheme, Erlang, Elixir	Web servers, Web apps, APIs, simple scripts, games	Cleaner, conciser code, Seems more intuitive than OOP (or other paradigms)	3	5	5	3	1	2	2	5	This survey is biased towards those with low experience/strong opinions, and against those with high experience/"use the right tool for the job"-opinions. Also seems subtly biased towards academia.
60	3/13/2016 17:55:12	Academia (including students)	< 1 year	Yes	< 1 year	I theoretically prefer functional, I end up using object-oriented languages. :(	Don't know. I haven't done anything serious enough to find out. :(	Haskell, Erlang, Elixir, None	Random bits of things I've wanted to try out.	Immutability and statelessness, Cleaner, conciser code, Concurrency, Ease of formal verification	3	4	3	3	4	4	2	3
61	3/13/2016 17:55:55	Industry	2-4 years	Yes	1-2 years	Functional	Functional	Scala, Scheme		Immutability and statelessness, Cleaner, conciser code, Lack of side-effects, Lazy evaluation, Ease of formal verification	2	5	3	3	4	5	3	3
62	3/13/2016 17:56:54	Academia (including students)	4-8 years	Yes	2-4 years	Functional	Functional	Lisp, Haskell, Scala		Cleaner, conciser code, Seems more intuitive than OOP (or other paradigms), Lazy evaluation, Ease of formal verification	3	2	2	4	1	1	1	3
63	3/13/2016 17:57:42	Industry	> 8 years	Yes	< 1 year	Object oriented	Object oriented	None	personal	Immutability and statelessness, Lack of side-effects	4	3	3	5	4	5	1	2
64	3/13/2016 18:03:23	Industry	> 8 years	Yes	1-2 years	It depends on the context.	It depends on the context.	Clojure, Erlang	GUI-heavy tools for artists, web frontends, playful experimentation	Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Learning more about programming, to make me a better programmer in general	1	3	5	3	4	1	1	4
65	3/13/2016 18:05:55	Academia (including students)	2-4 years	Yes	< 1 year	Object oriented	Object oriented	Scala		Lambda expressions and lambda calculus, Cleaner, conciser code	5	4	4	4	4	4	3	3
66	3/13/2016 18:14:35	Industry	> 8 years	Yes	1-2 years	Functional	Functional	Haskell, Clojure, Erlang, Elixir, Elm	Web development	Immutability and statelessness, Cleaner, conciser code, Performance (time, memory), Concurrency	4	4	5	5	4	5	2	5
67	3/13/2016 18:15:47	Industry	> 8 years	Yes	1-2 years	Functional	Functional	Haskell, Erlang		Lambda expressions and lambda calculus, Seems more intuitive than OOP (or other paradigms), Concurrency	5	4	4	4	3	5	2	5
68	3/13/2016 18:19:29	Industry	2-4 years	Yes	< 1 year	Functional	Object oriented	Scala		Cleaner, conciser code, Lack of side-effects	3	5	4	4	3	4	3	5
69	3/13/2016 18:20:11	Industry	4-8 years	Yes	2-4 years	Functional	Functional	Haskell, Scala, Clojure		Immutability and statelessness, Cleaner, conciser code, Lack of side-effects, Concurrency	2	3	4	4	4	5	1	5
70	3/13/2016 18:22:24	Industry	> 8 years	Yes	2-4 years	Functional	Functional	Haskell, Clojure, elm, javascript (in a functional style)	hobbie projects, client-side web apps professionally	Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects	3	5	3	2	4	4	2	4
71	3/13/2016 18:22:42	Academia (including students)	2-4 years	Yes	1-2 years	Functional	Functional	Lisp, Haskell, Clojure, Scheme	personal, minor academic	Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Seems more intuitive than OOP (or other paradigms)	3	3	2	3	3	3	3	3
72	3/13/2016 18:25:37	Industry	> 8 years	Yes	< 1 year	Imperative	Imperative	None		Immutability and statelessness, Cleaner, conciser code, Lack of side-effects, Concurrency	4	4	5	3	4	5	2	5
73	3/13/2016 18:28:19	both	1-2 years	Yes	1-2 years	Functional	Functional	Haskell, Scala, OCaml		Immutability and statelessness, Seems more intuitive than OOP (or other paradigms), Concurrency	4	4	5	5	3	4	3	4
74	3/13/2016 18:35:35	Industry	4-8 years	Yes	4-8 years	Functional	Functional	Haskell, Scala	In Atlassian software	Immutability and statelessness, Cleaner, conciser code, Lack of side-effects, Ease of formal verification	1	1	1	1	3	2	1	2	What is OOP? The reasons for choosing one language over another needs expanding. We choose languages with useful type system features (e.g. higher-kinded types, type-classes and type-inference) so that we can reuse code. We also choose languages with good documentation tools, such as QuickCheck/ScalaCheck and Hoogle.
75	3/13/2016 18:35:51	Industry	4-8 years	Yes	2-4 years	Functional	Functional	Lisp, Haskell, Erlang, F#, Elixir		Immutability and statelessness, Cleaner, conciser code, Lack of side-effects, Concurrency	5	3	3	3	4	4	3	4
76	3/13/2016 18:36:32	Academia (including students)	4-8 years	Yes	2-4 years	Functional	Functional	Pyret, SMLNJ, Racket	http://liber-brunoniana.github.io/Articles/Liber%20Brunoniana.html	Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects	5	4	3	2	1	1	1	4
77	3/13/2016 18:43:35	Academia (including students)	2-4 years	Yes	< 1 year	Functional	Functional	Haskell	personal projects	Immutability and statelessness, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms), Lazy evaluation, Ease of formal verification	4	4	3	3	4	4	3	3
78	3/13/2016 18:43:36	Industry	> 8 years	Yes	4-8 years	Functional	Functional	Haskell, Scala		Immutability and statelessness, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms)	1	3	3	3	4	2	1	4
79	3/13/2016 18:44:15	Industry	> 8 years	Yes	2-4 years	Functional	Functional	Lisp, Haskell, ML, Scheme	Personal.	Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms), Concurrency, Ease of formal verification	4	5	2	2	3	4	1	5
80	3/13/2016 18:47:44	Industry	4-8 years	Yes	4-8 years	Functional	Functional	Lisp, Haskell, OCaml, ML, Clojure, Scheme, Erlang		Immutability and statelessness, Lack of side-effects, Concurrency	1	4	4	4	4	3	3	4
81	3/13/2016 18:48:09	Industry	4-8 years	Yes	2-4 years	Functional	Functional	Haskell, Scala	Startups. API's	Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Concurrency, Ease of formal verification	5	5	5	4	2	4	2	4
82	3/13/2016 18:51:14	Academia (including students)	4-8 years	Yes	2-4 years	Functional	Functional	Lisp, Haskell, Elixir	Personal projects, scripts for work	Cleaner, conciser code, Concurrency	5	5	3	2	3	4	3	5	I think there simply isn't a one-size-fits-all, but if there were, functional programming would be bery close. Things like working with GUIs would be unintuitive in FP, I'd imagine (although still very much possible!)
83	3/13/2016 18:58:17	Industry	> 8 years	Yes	1-2 years	Functional	Depends on use-case	Clojure, Scheme, F#	Educating myself, some limited in-industry implementations in JavaScript	Immutability and statelessness, Cleaner, conciser code, Lack of side-effects	3	5	5	2	4	3	4	3
84	3/13/2016 18:59:19	Industry	4-8 years	Yes	2-4 years	Functional	Functional	Lisp, Haskell, OCaml, Clojure, Erlang, Elixir	Toy projects	Cleaner, conciser code, Seems more intuitive than OOP (or other paradigms), Concurrency	4	4	4	4	3	3	2	4
85	3/13/2016 18:59:21	Industry	4-8 years	Yes	< 1 year	Functional	Functional	Clojure, Elm		Immutability and statelessness, Cleaner, conciser code, Lack of side-effects	4	5	3	5	3	3	3	4
86	3/13/2016 19:00:32	Industry	2-4 years	Yes	< 1 year	Functional	Object oriented	Erlang, Elixir, Elm		Cleaner, conciser code, Lack of side-effects, Concurrency	2	4	4	4	3	5	2	2
87	3/13/2016 19:00:36	Academia (including students)	2-4 years	Yes	1-2 years	Functional	I use them for different things.	Haskell, OCaml, ML, Scheme, F#		Cleaner, conciser code, Seems more intuitive than OOP (or other paradigms)	4	3	3	4	4	2	2	3
88	3/13/2016 19:04:29	Industry	4-8 years	Yes	4-8 years	Functional	Functional	Lisp, Haskell, Clojure, F#		Immutability and statelessness, Lack of side-effects, Seems more intuitive than OOP (or other paradigms)	5	5	5	5	5	5	5	5
89	3/13/2016 19:07:23	Academia (including students)	4-8 years	Yes	1-2 years	Functional	Functional	Lisp, Haskell, Clojure, Scheme, Rust	numeric/symbolic computation, AI/ML, dynamic systems	Lambda expressions and lambda calculus, Cleaner, conciser code, Lazy evaluation, Ease of formal verification	4	5	4	3	2	3	3	2
90	3/13/2016 19:15:07	Academia (including students)	2-4 years	Yes	< 1 year	Functional	Functional	Clojure, Js	Games, data processing	Immutability and statelessness, Cleaner, conciser code, Lack of side-effects	4	4	5	4	4	3	3	5
91	3/13/2016 19:15:15	Industry	> 8 years	Yes	4-8 years	Functional	Functional	Lisp, Haskell, OCaml, Clojure, Scheme	Compilers, data science, BI analytics backends, academic research.	Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms), Concurrency, Lazy evaluation, Ease of formal verification	4	3	4	4	4	4	1	4
92	3/13/2016 19:15:24	Industry	> 8 years	Yes	2-4 years	Functional	Functional	Clojure		Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms), Concurrency, Lazy evaluation	2	2	1	2	2	1	2	2
93	3/13/2016 19:18:51	Industry	4-8 years	Yes	< 1 year	Object oriented	Object oriented	Lisp, Haskell, Scala, ML	Math	Seems more intuitive than OOP (or other paradigms), Concurrency, Lazy evaluation	4	4	4	4	4	4	4	4
94	3/13/2016 19:19:54	Industry	> 8 years	Yes	> 8 years	Functional	Functional	Lisp, Clojure, Ruby		Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms), Lazy evaluation	5	5	3	2	2	2	1	2
95	3/13/2016 19:23:01	Academia (including students)	2-4 years	Yes	1-2 years	Functional	Object oriented	Lisp, Haskell, Clojure, Scheme		Lambda expressions and lambda calculus, Seems more intuitive than OOP (or other paradigms), Performance (time, memory), Concurrency, Lazy evaluation	5	4	4	4	4	3	4	3
96	3/13/2016 19:24:26	Industry	4-8 years	Yes	1-2 years	Functional	Functional	Haskell, Erlang, Elixir		Immutability and statelessness, Cleaner, conciser code, Seems more intuitive than OOP (or other paradigms), Concurrency	4	3	3	4	5	5	1	3
97	3/13/2016 19:32:08	Industry	2-4 years	Yes	< 1 year	Functional	Functional	Lisp, Haskell, Elixir	Personal	Immutability and statelessness, Lambda expressions and lambda calculus, Cleaner, conciser code, Lack of side-effects, Seems more intuitive than OOP (or other paradigms), Concurrency, Ease of formal verification	4	5	4	5	4	5	3	5
98	3/13/2016 19:32:11	Industry	1-2 years	Yes	< 1 year	Functional	Functional	Haskell, Scheme	Professional static website, personal experimentation	Immutability and statelessness, Lambda expressions and lambda calculus, Seems more intuitive than OOP (or other paradigms), Concurrency, Ease of formal verification	4	5	4	5	4	4	2	3	Still a newbie, but I must say the functionnal paradigm is much more fascinating than oop.
99	3/13/2016 19:32:30	Industry	> 8 years	Yes	1-2 years	Object oriented	Object oriented	Lisp, Haskell, ML	Studying automated parallelisation in compilers	Lack of side-effects, Performance (time, memory)	5	3	3	3	5	5	3	3
100	3/13/2016 19:34:32	Academia (including students)	> 8 years	Yes	< 1 year	imperative, bitches!	lisp macros	Lisp, Erlang	great justice	get pussy	4	4	3	3	5	5	5	4	nice survey ;)