<p>I've read the Wikipedia articles for both <a href="http://en.wikipedia.org/wiki/Procedural_programming" rel="noreferrer">procedural programming</a> and <a href="http://en.wikipedia.org/wiki/Functional_programming" rel="noreferrer">functional programming</a>, but I'm still slightly confused. Could someone boil it down to the core?</p>

[{'answer_id': 23286, 'author': 'juan', 'author_id': 1782, 'author_profile': 'https://Stackoverflow.com/users/1782', 'pm_score': 6, 'selected': False, 'text': '<p>In computer science, functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids state and mutable data. It emphasizes the application of functions, in contrast with the procedural programming style that emphasizes changes in state.</p>\n'}, {'answer_id': 23290, 'author': 'Konrad Rudolph', 'author_id': 1968, 'author_profile': 'https://Stackoverflow.com/users/1968', 'pm_score': 8, 'selected': True, 'text': '<p>A functional language (ideally) allows you to write a mathematical function, i.e. a function that takes <em>n</em> arguments and returns a value. If the program is executed, this function is logically evaluated as needed.<sup>1</sup></p>\n\n<p>A procedural language, on the other hand, performs a series of <em>sequential</em> steps. (There\'s a way of transforming sequential logic into functional logic called <a href="http://en.wikipedia.org/wiki/Continuation_passing_style" rel="noreferrer">continuation passing style</a>.)</p>\n\n<p>As a consequence, a purely functional program always yields <em>the same value</em> for an input, and the order of evaluation is not well-defined; which means that uncertain values like user input or random values are hard to model in purely functional languages.</p>\n\n<hr>\n\n<p><sup>1</sup> As everything else in this answer, that’s a generalisation. This property, evaluating a computation when its result is needed rather than sequentially where it’s called, is known as “laziness”. Not all functional languages are actually universally lazy, nor is laziness restricted to functional programming. Rather, the description given here provides a “mental framework” to think about different programming styles that are not distinct and opposite categories but rather fluid ideas.</p>\n'}, {'answer_id': 23324, 'author': 'Herms', 'author_id': 1409, 'author_profile': 'https://Stackoverflow.com/users/1409', 'pm_score': 4, 'selected': False, 'text': "<p>To expand on Konrad's comment:</p>\n\n<blockquote>\n  <p>As a consequence, a purely functional program always yields the same value for an input, and the order of evaluation is not well-defined;</p>\n</blockquote>\n\n<p>Because of this, functional code is generally easier to parallelize.  Since there are (generally) no side effects of the functions, and they (generally) just act on their arguments, a lot of concurrency issues go away.</p>\n\n<p>Functional programming is also used when you need to be capable of <em>proving</em> your code is correct.  This is much harder to do with procedural programming (not easy with functional, but still easier).</p>\n\n<p>Disclaimer:  I haven't used functional programming in years, and only recently started looking at it again, so I might not be completely correct here. :)</p>\n"}, {'answer_id': 23335, 'author': 'Community', 'author_id': -1, 'author_profile': 'https://Stackoverflow.com/users/-1', 'pm_score': 5, 'selected': False, 'text': '<p>I believe that procedural/functional/objective programming are about how to approach a problem. </p>\n\n<p>The first style would plan everything in to steps, and solves the problem by implementing one step (a procedure) at a time. On the other hand, functional programming would emphasize the divide-and-conquer approach, where the problem is divided into sub-problem, then each sub-problem is solved (creating a function to solve that sub problem) and the results are combined to create the answer for the whole problem. Lastly, Objective programming would mimic the real world by create a mini-world inside the computer with many objects, each of which has a (somewhat) unique characteristics, and interacts with others. From those interactions the result would emerge.</p>\n\n<p>Each style of programming has its own advantages and weaknesses. Hence, doing something such as "pure programming" (i.e. purely procedural - no one does this, by the way, which is kind of weird - or purely functional or purely objective) is very difficult, if not impossible, except some elementary problems specially designed to demonstrate the advantage of a programming style (hence, we call those who like pureness "weenie" :D).</p>\n\n<p>Then, from those styles, we have programming languages that is designed to optimized for some each style. For example, Assembly is all about procedural. Okay, most early languages are procedural, not only Asm, like C, Pascal, (and Fortran, I heard). Then, we have all famous Java in objective school (Actually, Java and C# is also in a class called "money-oriented," but that is subject for another discussion). Also objective is Smalltalk. In functional school, we would have "nearly functional" (some considered them to be impure) Lisp family and  ML family and many "purely functional" Haskell, Erlang, etc. By the way, there are many general languages such as Perl, Python, Ruby.</p>\n'}, {'answer_id': 23385, 'author': 'Brian Leahy', 'author_id': 580, 'author_profile': 'https://Stackoverflow.com/users/580', 'pm_score': 3, 'selected': False, 'text': "<p>To expand on Konrad's comment:</p>\n\n<blockquote>\n  <p>and the order of evaluation is not\n  well-defined</p>\n</blockquote>\n\n<p>Some functional languages have what is called Lazy Evaluation.  Which means a function is not executed until the value is needed.  Until that time the function itself is what is passed around.</p>\n\n<p>Procedural languages are step 1 step 2 step 3... if in step 2 you say add 2 + 2, it does it right then.  In lazy evaluation you would say add 2 + 2, but if the result is never used, it never does the addition.</p>\n"}, {'answer_id': 23499, 'author': 'Wedge', 'author_id': 332, 'author_profile': 'https://Stackoverflow.com/users/332', 'pm_score': 3, 'selected': False, 'text': "<p>Procedural languages tend to keep track of state (using variables) and tend to execute as a sequence of steps. Purely functional languages don't keep track of state, use immutable values, and tend to execute as a series of dependencies. In many cases the status of the call stack will hold the information that would be equivalent to that which would be stored in state variables in procedural code.</p>\n\n<p>Recursion is a classic example of functional style programming.</p>\n"}, {'answer_id': 23693, 'author': 'Brad Gilbert', 'author_id': 1337, 'author_profile': 'https://Stackoverflow.com/users/1337', 'pm_score': 7, 'selected': False, 'text': '<p>Basically the two styles, are like Yin and Yang. One is organized, while the other chaotic. There are situations when Functional programming is the obvious choice, and other situations were Procedural programming is the better choice. This is why there are at least two languages that have recently come out with a new version, that embraces both programming styles. <em>( <a href="https://raku.org/" rel="noreferrer">Perl\xa06</a> and <a href="https://dlang.org/" rel="noreferrer">D\xa02</a> )</em></p>\n<p>#Procedural:#</p>\n<ul>\n<li>The output of a routine does not always have a direct correlation with the input.</li>\n<li>Everything is done in a specific order.</li>\n<li>Execution of a routine may have side effects.</li>\n<li>Tends to emphasize implementing solutions in a linear fashion.</li>\n</ul>\n<p>##<a href="https://raku.org/" rel="noreferrer">Perl 6</a>   <a href="https://raw.githubusercontent.com/Raku/mu/master/misc/camelia.txt" rel="noreferrer" title="Why a butterfly?"><img src="https://i.stack.imgur.com/ML21J.png" width="26" height="24"></a>##</p>\n<pre class="lang-perl6 prettyprint-override"><code>sub factorial ( UInt:D $n is copy ) returns UInt {\n\n  # modify &quot;outside&quot; state\n  state $call-count++;\n  # in this case it is rather pointless as\n  # it can\'t even be accessed from outside\n\n  my $result = 1;\n\n  loop ( ; $n &gt; 0 ; $n-- ){\n\n    $result *= $n;\n\n  }\n\n  return $result;\n}\n</code></pre>\n<p>##<a href="https://dlang.org/" rel="noreferrer">D 2</a>##</p>\n<pre class="lang-d prettyprint-override"><code>int factorial( int n ){\n\n  int result = 1;\n\n  for( ; n &gt; 0 ; n-- ){\n    result *= n;\n  }\n\n  return result;\n}\n</code></pre>\n<hr />\n<p>#Functional:#</p>\n<ul>\n<li>Often recursive.</li>\n<li>Always returns the same output for a given input.</li>\n<li>Order of evaluation is usually undefined.</li>\n<li>Must be stateless. i.e. No operation can have side effects.</li>\n<li>Good fit for parallel execution</li>\n<li>Tends to emphasize a divide and conquer approach.</li>\n<li>May have the feature of Lazy Evaluation.</li>\n</ul>\n<p>##<a href="https://en.wikipedia.org/wiki/Haskell_(programming_language)" rel="noreferrer">Haskell</a>##\n( copied from <a href="https://en.wikipedia.org/wiki/Haskell_(programming_language)" rel="noreferrer">Wikipedia</a> );</p>\n<pre class="lang-haskell prettyprint-override"><code>fac :: Integer -&gt; Integer\n\nfac 0 = 1\nfac n | n &gt; 0 = n * fac (n-1)\n</code></pre>\n<p>or in one line:</p>\n<pre class="lang-haskell prettyprint-override"><code>fac n = if n &gt; 0 then n * fac (n-1) else 1\n</code></pre>\n<p>##<a href="https://raku.org/" rel="noreferrer">Perl 6</a>   <a href="https://raw.githubusercontent.com/Raku/mu/master/misc/camelia.txt" rel="noreferrer" title="Why a butterfly?"><img src="https://i.stack.imgur.com/anPVL.png" width="26" height="24" ></a>##</p>\n<pre class="lang-perl6 prettyprint-override"><code>proto sub factorial ( UInt:D $n ) returns UInt {*}\n\nmulti sub factorial (  0 ) { 1 }\nmulti sub factorial ( $n ) { $n * samewith $n-1 } # { $n * factorial $n-1 }\n</code></pre>\n<p>##<a href="https://dlang.org/" rel="noreferrer">D 2</a>##</p>\n<pre class="lang-d prettyprint-override"><code>pure int factorial( invariant int n ){\n  if( n &lt;= 1 ){\n    return 1;\n  }else{\n    return n * factorial( n-1 );\n  }\n}\n</code></pre>\n<hr />\n<p>#Side note:#</p>\n<p>Factorial is actually a common example to show how easy it is to create new operators in Perl 6 the same way you would create a subroutine. This feature is so ingrained into Perl 6 that most operators in the Rakudo implementation are defined this way. It also allows you to add your own multi candidates to existing operators.</p>\n<pre class="lang-perl6 prettyprint-override"><code>sub postfix:&lt; ! &gt; ( UInt:D $n --&gt; UInt )\n  is tighter(&amp;infix:&lt;*&gt;)\n  { [*] 2 .. $n }\n\nsay 5!; # 120␤\n</code></pre>\n<p>This example also shows range creation (<code>2..$n</code>) and the list reduction meta-operator (<code>[\xa0OPERATOR\xa0]\xa0LIST</code>) combined with the numeric infix multiplication operator. (<code>*</code>)<br />\nIt also shows that you can put <code>--&gt;\xa0UInt</code> in the signature instead of <code>returns\xa0UInt</code> after it.</p>\n<p>( You can get away with starting the range with <code>2</code> as the multiply &quot;operator&quot; will return <code>1</code> when called without any arguments )</p>\n'}, {'answer_id': 25003, 'author': 'C Hogg', 'author_id': 634, 'author_profile': 'https://Stackoverflow.com/users/634', 'pm_score': 4, 'selected': False, 'text': "<p>One thing I hadn't seen really emphasized here is that modern functional languages such as Haskell really more on first class functions for flow control than explicit recursion.  You don't need to define factorial recursively in Haskell, as was done above.  I think something like </p>\n\n<pre><code>fac n = foldr (*) 1 [1..n]\n</code></pre>\n\n<p>is a perfectly idiomatic construction, and much closer in spirit to using a loop than to using explicit recursion.</p>\n"}, {'answer_id': 28306, 'author': 'Jared Updike', 'author_id': 2543, 'author_profile': 'https://Stackoverflow.com/users/2543', 'pm_score': 3, 'selected': False, 'text': '<p>Konrad said:</p>\n\n<blockquote>\n  <p>As a consequence, a purely functional program always yields the same value for an input, \n     and the order of evaluation is not well-defined; which means that uncertain values like \n     user input or random values are hard to model in purely functional languages.</p>\n</blockquote>\n\n<p>The order of evaluation in a purely functional program may be hard(er) to reason about (especially with laziness) or even unimportant but I think that saying it is not well defined makes it sound like you can\'t tell if your program is going to work at all!</p>\n\n<p>Perhaps a better explanation would be that control flow in functional programs is based on when the value of a function\'s arguments are needed. The Good Thing about this that in well written programs, state becomes explicit: each function lists its inputs as parameters instead of arbitrarily <a href="http://en.wikipedia.org/wiki/Mung" rel="noreferrer">munging</a> global state. So on some level, <i>it is easier to reason about order of evaluation with respect to one function at a time</i>. Each function can ignore the rest of the universe and focus on what it needs to do. When combined, functions are guaranteed to work the same[1] as they would in isolation.</p>\n\n<blockquote>\n  <p>... uncertain values like user input or random values are hard to model in purely \n    functional languages.</p>\n</blockquote>\n\n<p>The solution to the input problem in purely functional programs is to embed an imperative language as a <a href="http://en.wikipedia.org/wiki/Domain_Specific_Language" rel="noreferrer">DSL</a> using <a href="http://en.wikipedia.org/wiki/Monads_in_functional_programming" rel="noreferrer">a sufficiently powerful abstraction</a>. In imperative (or non-pure functional) languages this is not needed because you can "cheat" and pass state implicitly and order of evaluation is explicit (whether you like it or not). Because of this "cheating" and forced evaluation of all parameters to every function, in imperative languages 1) you lose the ability to create your own control flow mechanisms (without macros), 2) code isn\'t inherently thread safe and/or parallelizable <i>by default</i>, 3) and implementing something like undo (time travel) takes careful work (imperative programmer must store a recipe for getting the old value(s) back!), whereas pure functional programming buys you all these things&mdash;and a few more I may have forgotten&mdash;"for free".</p>\n\n<p>I hope this doesn\'t sound like zealotry, I just wanted to add some perspective. Imperative programming and especially mixed paradigm programming in powerful languages like C# 3.0 are  still totally effective ways to get things done and <a href="http://en.wikipedia.org/wiki/No_Silver_Bullet" rel="noreferrer">there is no silver bullet</a>.</p>\n\n<p>[1] ... except possibly  with respect memory usage (cf. foldl and foldl\' in Haskell).</p>\n'}, {'answer_id': 28339, 'author': 'Jared Updike', 'author_id': 2543, 'author_profile': 'https://Stackoverflow.com/users/2543', 'pm_score': 2, 'selected': False, 'text': '<p>@Creighton:</p>\n\n<p>In Haskell there is a library function called <b>product</b>:</p>\n\n<pre><code>prouduct list = foldr 1 (*) list\n</code></pre>\n\n<p>or simply:</p>\n\n<pre><code>product = foldr 1 (*)\n</code></pre>\n\n<p>so the "idiomatic" factorial</p>\n\n<pre><code>fac n = foldr 1 (*)  [1..n]\n</code></pre>\n\n<p>would simply be</p>\n\n<pre><code>fac n = product [1..n]\n</code></pre>\n'}, {'answer_id': 216023, 'author': 'J D', 'author_id': 13924, 'author_profile': 'https://Stackoverflow.com/users/13924', 'pm_score': 2, 'selected': False, 'text': '<p>Procedural programming divides sequences of statements and conditional constructs into separate blocks called procedures that are parameterized over arguments that are (non-functional) values.</p>\n\n<p>Functional programming is the same except that functions are first-class values, so they can be passed as arguments to other functions and returned as results from function calls.</p>\n\n<p>Note that functional programming is a generalization of procedural programming in this interpretation. However, a minority interpret "functional programming" to mean side-effect-free which is quite different but irrelevant for all major functional languages except Haskell.</p>\n'}, {'answer_id': 389088, 'author': 'Mike Dunlavey', 'author_id': 23771, 'author_profile': 'https://Stackoverflow.com/users/23771', 'pm_score': 2, 'selected': False, 'text': "<p>If you have a chance, I would recommand getting a copy of Lisp/Scheme, and doing some projects in it. Most of the ideas that have lately become bandwagons were expressed in Lisp decades ago: functional programming, continuations (as closures), garbage collection, even XML.</p>\n\n<p>So that would be a good way to get a head start on all these current ideas, and a few more besides, like symbolic computation.</p>\n\n<p>You should know what functional programming is good for, and what it isn't good for. It isn't good for everything. Some problems are best expressed in terms of side-effects, where the same question gives differet answers depending on when it is asked.</p>\n"}, {'answer_id': 13600858, 'author': 'Omnimike', 'author_id': 960483, 'author_profile': 'https://Stackoverflow.com/users/960483', 'pm_score': 7, 'selected': False, 'text': '<p>I\'ve never seen this definition given elsewhere, but I think this sums up the differences given here fairly well:</p>\n\n<p><strong>Functional</strong> programming focuses on <strong>expressions</strong></p>\n\n<p><strong>Procedural</strong> programming focuses on <strong>statements</strong></p>\n\n<p>Expressions have values. A functional program is an expression who\'s value is a sequence of instructions for the computer to carry out.</p>\n\n<p>Statements don\'t have values and instead modify the state of some conceptual machine.</p>\n\n<p>In a purely functional language there would be no statements, in the sense that there\'s no way to manipulate state (they might still have a syntactic construct named "statement", but unless it manipulates state I wouldn\'t call it a statement in this sense). In a purely procedural language there would be no expressions, everything would be an instruction which manipulates the state of the machine.</p>\n\n<p>Haskell would be an example of a purely functional language because there is no way to manipulate state. Machine code would be an example of a purely procedural language because everything in a program is a statement which manipulates the state of the registers and memory of the machine.</p>\n\n<p>The confusing part is that the vast majority of programming languages contain <strong>both</strong> expressions and statements, allowing you to mix paradigms. Languages can be classified as more functional or more procedural based on how much they encourage the use of statements vs expressions.</p>\n\n<p>For example, C would be more functional than COBOL because a function call is an expression, whereas calling a sub program in COBOL is a statement (that manipulates the state of shared variables and doesn\'t return a value). Python would be more functional than C because it allows you to express conditional logic as an expression using short circuit evaluation (test &amp;&amp; path1 || path2 as opposed to if statements). Scheme would be more functional than Python because everything in scheme is an expression.</p>\n\n<p>You can still write in a functional style in a language which encourages the procedural paradigm and vice versa. It\'s just harder and/or more awkward to write in a paradigm which isn\'t encouraged by the language.</p>\n'}, {'answer_id': 42581726, 'author': 'Nir O.', 'author_id': 582821, 'author_profile': 'https://Stackoverflow.com/users/582821', 'pm_score': 4, 'selected': False, 'text': '<p>A functional programming is identical to procedural programming in which global variables are <em>not</em> being used.</p>\n'}, {'answer_id': 53093783, 'author': 'Nicholas Pipitone', 'author_id': 2574612, 'author_profile': 'https://Stackoverflow.com/users/2574612', 'pm_score': 2, 'selected': False, 'text': '<p>None of the answers here show idiomatic functional programming. The recursive factorial answer is great for representing recursion in FP, but the majority of code is not recursive so I don\'t think that answer is fully representative.</p>\n\n<p>Say you have an arrays of strings, and each string represents an integer like "5" or "-200". You want to check this input array of strings against your internal test case (Using integer comparison). Both solutions are shown below</p>\n\n<h1>Procedural</h1>\n\n<pre><code>arr_equal(a : [Int], b : [Str]) -&gt; Bool {\n    if(a.len != b.len) {\n        return false;\n    }\n\n    bool ret = true;\n    for( int i = 0; i &lt; a.len /* Optimized with &amp;&amp; ret*/; i++ ) {\n        int a_int = a[i];\n        int b_int = parseInt(b[i]);\n        ret &amp;= a_int == b_int;  \n    }\n    return ret;\n}\n</code></pre>\n\n<h1>Functional</h1>\n\n<pre><code>eq = i, j =&gt; i == j # This is usually a built-in\ntoInt = i =&gt; parseInt(i) # Of course, parseInt === toInt here, but this is for visualization\n\narr_equal(a : [Int], b : [Str]) -&gt; Bool =\n    zip(a, b.map(toInt)) # Combines into [Int, Int]\n   .map(eq)\n   .reduce(true, (i, j) =&gt; i &amp;&amp; j) # Start with true, and continuously &amp;&amp; it with each value\n</code></pre>\n\n<p>While pure functional languages are generally research languages (As the real-world likes free side-effects), real-world procedural languages will use the much simpler functional syntax when appropriate.</p>\n\n<p>This is usually implemented with an external library like <a href="https://lodash.com/docs/4.17.11#after" rel="nofollow noreferrer">Lodash</a>, or available built-in with newer languages like <a href="https://doc.rust-lang.org/book/second-edition/ch13-02-iterators.html" rel="nofollow noreferrer">Rust</a>. The heavy lifting of functional programming is done with functions/concepts like <code>map</code>, <code>filter</code>, <code>reduce</code>, <code>currying</code>, <code>partial</code>, the last three of which you can look up for further understanding.</p>\n\n<h2>Addendum</h2>\n\n<p>In order to be used in the wild, the compiler will normally have to work out how to convert the functional version into the procedural version internally, as function call overhead is too high. Recursive cases such as the factorial shown will use tricks such as <a href="https://en.wikipedia.org/wiki/Tail_call" rel="nofollow noreferrer">tail call</a> to remove O(n) memory usage. The fact that there are no side effects allows functional compilers to implement the <code>&amp;&amp; ret</code> optimization even when the <code>.reduce</code> is done last. Using Lodash in JS, obviously does not allow for any optimization, so it is a hit to performance (Which isn\'t usually a concern with web development). Languages like Rust will optimize internally (And have functions such as <code>try_fold</code> to assist <code>&amp;&amp; ret</code> optimization).</p>\n'}, {'answer_id': 53437551, 'author': 'Fouad Boukredine', 'author_id': 7594095, 'author_profile': 'https://Stackoverflow.com/users/7594095', 'pm_score': 1, 'selected': False, 'text': '<p>To Understand the difference, one needs to to understand that "the godfather" paradigm of both procedural and functional programming is the <strong>imperative programming</strong>.</p>\n\n<p>Basically procedural programming is merely a way of structuring imperative programs in which the primary method of abstraction is the "procedure." (or "function" in some programming languages). Even Object Oriented Programming is just another way of structuring an imperative program, where the state is encapsulated in objects, becoming an object with a "current state," plus this object has a set of functions, methods, and other stuff that let you the programmer manipulate or update the state.</p>\n\n<p>Now, in regards to functional programming, the <em>gist</em> in its approach is that it identifies what values to take and how these values should be transferred. (so there is no state, and no mutable data as it takes functions as first class values and pass them as parameters to other functions).</p>\n\n<p>PS: understanding every programming paradigm is used for should clarify the differences between all of them.</p>\n\n<p>PSS: In the end of the day, programming paradigms are just different approaches to solving problems.</p>\n\n<p>PSS: <a href="https://www.quora.com/Are-procedural-and-imperative-programming-the-same/answer/Mark-Sheldon-15" rel="nofollow noreferrer">this</a> quora answer has a great explanation.</p>\n'}, {'answer_id': 54253067, 'author': 'Hamza Zubair', 'author_id': 5202586, 'author_profile': 'https://Stackoverflow.com/users/5202586', 'pm_score': 6, 'selected': False, 'text': '<h3>Funtional Programming</h3>\n<pre class="lang-py prettyprint-override"><code>num = 1 \ndef function_to_add_one(num):\n    num += 1\n    return num\n\n\nfunction_to_add_one(num)\nfunction_to_add_one(num)\nfunction_to_add_one(num)\nfunction_to_add_one(num)\nfunction_to_add_one(num)\n\n#Final Output: 2\n</code></pre>\n<h3>Procedural Programming</h3>\n<pre class="lang-py prettyprint-override"><code>num = 1 \ndef procedure_to_add_one():\n    global num\n    num += 1\n    return num\n\n\nprocedure_to_add_one()\nprocedure_to_add_one()\nprocedure_to_add_one()\nprocedure_to_add_one()\nprocedure_to_add_one()\n\n#Final Output: 6\n</code></pre>\n<p><code>function_to_add_one</code> is a function</p>\n<p><code>procedure_to_add_one</code> is a procedure</p>\n<p>Even if you run the <strong>function</strong> five times, every time it will return <strong>2</strong></p>\n<p>If you run the <strong>procedure</strong> five times, at the end of fifth run it will give you <strong>6</strong>.</p>\n<p>DISCLAIMER: Obviously this is a hyper-simplified view of reality. This answer just gives a taste of &quot;functions&quot; as opposed to &quot;procedures&quot;. Nothing more. Once you have tasted this superficial yet deeply penetrative intuition, start exploring the two paradigms, and you will start to see the difference quite clearly.</p>\n<p>Helps my students, hope it helps you too.</p>\n'}]
['https://Stackoverflow.com/questions/23277', 'https://Stackoverflow.com', 'https://Stackoverflow.com/users/572/']