I have been too used to Imperative Programming which is the usual way of telling the computer to perform step by step the procedure to get the final result. On the other han
Think of c filters. Where you read from stdin and write to stdout. The code may be imperative but thr program is used like a a function. Say you have a program 'function, then piping to it:
cat foo |function |tee bar
Will filter the contents of foo through function then through the filter tee to both write to stdout and create bar . Think also of grep and awk the iterator in both is implied and they are used like functions.
Your example of declarative programming above is not an actual program, so it's not a good example.
The main difference is between imperative and declarative. Functional is a particular kind of declarative.
C, C++, Java, Javascript, BASIC, Python, Ruby, and most other programming languages are imperative. As a rule, if it has explicit loops (for, while, repeat) that change variables with explicit assignment operations at each loop, then it's imperative.
SQL and XSLT are two well-known examples of declarative programming. Markup languages such as HTML and CSS are declarative too, although they are usually not powerful enough to describe arbitrary algorithms.
Here is an example computation (summing the income by gender, from a suitable data source) first written in an imperative language (Javascript) and then in a declarative language (SQL).
var income_m = 0, income_f = 0;
for (var i = 0; i < income_list.length; i++) {
if (income_list[i].gender == 'M')
income_m += income_list[i].income;
else
income_f += income_list[i].income;
}
Notice:
i
) and the running totals at each iteration;if
s) are only used to choose the code path at each iteration.select gender, sum(income)
from income_list
group by gender;
Notice:
case
in SQL) are used in a functional way to specify the output value you want based on the input values, not to choose a code path.As I mentioned above, SQL's case
is a great example of the functional way of programming, which is a restricted subset of Declarative programming in which the desired computation is specified by composing functions.
Functions are things that accept inputs and return outputs (eg. case
, sum()
…)
Composition means chaining two or more together by specifying how the output of one is fed as the input to the next (typically by writing one inside the other.) Finally the whole composition, which is still itself a big function, is applied to the available inputs to get the desired output.
In this snippet I am declaring the output I want by composing the functions sum()
and case
. This is called functional programming:
select
sum(case when some_flag = 'X' then some_column
else some_other_column end)
from
...
If the composition of two or more functions and their application to the input data are the only constructs available in a given laguage, that language is said to be purely functional. In those languages you will notice the complete absence of loops, variable assignment and other typically imperative statements.
Edit: I recommend watching some of Anjana Vakil's talks on functional programming in Javascript, to get a better idea of what it's about.
Another useful explanation I found in the Pro XAML with C#:
In declarative programming, the source code is written in a way that expresses the desired outcome of the code with little or no emphasis on the actual implementation.
Imperative programming is the opposite of declarative programming. If declarative programming can be thought of as declaring what the desired outcome is, imperative programming can be viewed as writing lines of code that represent the instructions of how to achieve the desired outcome.
It is an erroneous oversimplification to claim that imperative programming is distinguished from declarative programming by erroneously assuming a lack of ordering in the latter.
Pure functional programming is not prevented from expressing order and implementation, rather it is less able to express random accidental order at the operational semantics level. Also it has the advantage of "Don't repeat yourself" (DRY), which is a form of declarative style (see below).
However, pure functional programming does not guarantee declarative high-level semantics. For this, you need to apply the correct definition of declarative vs. imperative.