Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2012/ch2a 2w11 aa

2012-10-30T02:57:27Z

Dmcarmon: /* More Examples */

=Introduction=
Test driven development (TDD) is a process that tries to create the minimal amount of code while meeting customer's expectations. TDD is a component of [http://en.wikipedia.org/wiki/Extreme_programming Extreme Programming] and often used in conjunction with [http://en.wikipedia.org/wiki/Integration_test integration tests]. The premise of TDD is to test first, code second, and improve (or [http://en.wikipedia.org/wiki/Refactoring refactor]) last. This forces the software developers to focus on customer specifications first. After each iteration of testing, coding, and refactoring the programmer has a piece of ready to ship code. The rest of this chapter gives the motivation for TDD, shows the steps for TDD, outlines the principles of TDD, provides examples using TDD, and compares the pros and cons of TDD.

=Motivation for TDD=

There are two main motivations for TDD.

[[File:CostofChange.png|550px|Thumb:Figure 1: Traditional "Cost of Change" curve with the waterfall model superimposed]]

*Testing is the one activity that improves the quality of code. In various design scenarios, like waterfall model, testing occurs towards the end of the project development activity. As shown in the figure 1, introducing testing as a latter phase increases the cost incurred for implementing the changes. From this we infer that there is a high chance of reducing the costs by moving the Test phase to the initial part.
*The client can also be well informed about the design and can suggest changes which can be incorporated well in advance. This approach also known as TDD helps achieve flexibility to achieve the client’s ever-changing requirements

=Principles=

TDD follows several principles:

*Tests serve as examples of how to use a class or method. Once used to having tests that show how things work (and that they work), developers start inquiring if a test was already there for the piece of code to be developed
*Developer tests are distinctly different from QA (Quality Analysis) tests and should be kept separate. QA tests target features and treat the system as a black box. Unit tests created by the developer operate at a lower level and test different things.
*Name the tests carefully. For Example, name test packages like the package being tested with a suffix. For example, the "DataAccess" project/package is tested by "DataAccess.Test". Also, name test classes the same as the class under test with the suffix "Test". For example, the class "PrintManager" is tested by the test class "PrintManagerTest". This convention makes it easy to find the related class and keeps the class name a noun. You should also name test methods the same as the method being tested with the prefix "Test". For example, the method "PrintProductOrder()" is tested by the method "TestPrintProductOrder()". This convention keeps the method name a verb that reads as an english phrase.
*Write each test before writing the method under test. It encourages the developer to think as a user of the target method before thinking about implementation, which usually results in a cleaner, easier-to-use interface.
*Follow the "3-As" pattern for test methods: Arrange, Act, Assert. Specifically, use separate code paragraphs (groups of lines of code separated by a blank line) for each of the As. Arrange is variable declaration and initialization. Act is invoking the code under test. Assert is using the Assert.* methods to verify that expectations were met.
*When writing application code, only write enough code to make a test work. This technique prevents gold-plating and ensures that you always have a test for the code you write.
*When you find you need to refractor working code, refractor and re-test prior to writing new code. This technique ensures your refractoring is correct prior to adding new functionality and applies to creating new methods, introducing inheritance, everything.

=Steps=
[[File:TDD_Steps.png|550px|Thumb:Figure 1: Traditional "Cost of Change" curve with the waterfall model superimposed]]

Follow these steps:
*Understand the requirements of the story, work item, or feature that you are working on.
*Red:Create a test and make it fail.
Imagine how the new code should be called and write the test as if the code already existed.
Create the new production code stub. Write just enough code so that it compiles.
Run the test. It should fail. This is a calibration measure to ensure that your test is calling the correct code and that the code is not working by accident. This is a meaningful failure, and you expect it to fail.
*Green: Make the test pass by any means necessary.
Write the production code to make the test pass. Keep it simple.
Some advocate the hard-coding of the expected return value first to verify that the test correctly detects success. This varies from practitioner to practitioner.If you've written the code so that the test passes as intended, you are finished. You do not have to write more code speculatively. If new functionality is still needed, then another test is needed. Make this one test pass and continue.
When the test passes, you might want to run all tests up to this point to build confidence that everything else is still working.
*Refactor: Change the code to remove duplication in your project and to improve the design while ensuring that all tests still pass.
Remove duplication caused by the addition of the new functionality.
Make design changes to improve the overall solution.
After each refactoring, rerun all the tests to ensure that they all still pass.
*Repeat the cycle. Each cycle should be very short, and a typical hour should contain many Red/Green/ Refractor cycles.

=Examples=

==Homework Grades Program==

===Setup===
As a simple example, we are creating a program that keeps track of our homework grades. We envision that we would be able to get the average of these homework grades. Step one: write a test . Let's test an average function

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
assert(myHomework.average(myHomework.grades) == 75);
</pre>

We will get multiple errors - this test won't even compile (but, that's ok for now). Let's take a look at what will generate error messages:

* class <code>Homework</code> not declared
* <code>Homework</code> constructor not declared
* field <code>grades</code> not declared
* method <code>average</code> not declared

Now, we fix the first error:

<pre>
class Homework {

}
</pre>

Second error:

<pre>
Homework(void) {

}
</pre>

Third error:

<pre>
int * grades;
</pre>

Fourth error:

<pre>
int average(int * grades) {
return 0; // default return value
}
</pre>

Finally, the test compiles! The code now looks like this:

<pre>
class Homework {

int * grades;

Homework(void) {

}

int average(int * grades) {

return 0; // default return value

}

}
</pre>

===Red Step===
Now, we run the test, and the familar red bar of failure greets us (remember the mantra red-green-refactor). The assert fails. The average function needs to actually average something (not just return 0). As we think about averaging the grades, we realize we need to know how many grades are in the int array <code>grades</code>. So, we add to the code:

<pre>
class Homework {

int * grades;
int numGrades; // new

Homework(void) {

}

int average(int * grades) {

int avg = 0; // new

for(int i = 0; i < numGrades; i++) { // new
avg += grades[i]; // new
} // new

return avg/numGrades; // new

}

}
</pre>

Of course, we must remember to change the test to:

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
myHomework.numGrades = 2;
assert(myHomework.average(myHomework.grades) == 75);
</pre>

===Green Step===
Success! We have a green bar when we run it.

===Refactoring Step===
The last step is refactoring. Perhaps we don't want a grade to be an <code>int</code>? Should it be an <code>unsigned int</code>? For this simple example, there isn't much refactoring to do, but in a larger example there may be multiple areas for improvement.

==Refactoring Example==
The following example is take from Test-Driven Development by Example by Kent Beck.

Using the TDD process the author created an object with the following structure:

<pre>
class Dollar {

Dollar(int amount) {
this.amount = amount;
}

void times(int mulitplier) {
amount *= multiplier;
}

}
</pre>

What's wrong with the code above? Look at the following test:

<pre>
public void testMultiplication() {

Dollar five = new Dollar(5);
five.times(2);
assertEquals(10, five.amount);
five.times(3);
assertEquals(15, five.amount);

}
</pre>

Whenever we perform an operation on a <code>Dollar</code> the value of the <code>Dollar</code> changes. In the test above <code>five</code> isn't 5 after we multiply it by 2, and thus the name <code>five</code> doesn't make sense anymore. How do we change this?

===Red Step===

First, we change the test.

<pre>
public void testMultiplication() {
Dollar five = new Dollar(5);
Dollar product = five.times(2);
assertEquals(10, product.amount);
product = five.times(3);
assertEquals(15, product.amount);
}
</pre>

The new test won't compile until we change the code:

<pre>
Dollar times(int multiplier) {
amount *= multiplier;
return null;
}
</pre>

Now the test compiles, but fails. Once again, we change the code:

<pre>
Dollar times(int multiplier) {
return new Dollar(amount * multiplier);
}
</pre>

===Green Step===

The test succeeds. So we see that even when we are refactoring we change the test first, then the code. This way we know our refactoring is an improvement.

==More Examples==
[http://catalog.lib.ncsu.edu/record/NCSU1601963 See] Test-Driven Development by Example by Kent Beck for more examples.

=Characteristics of a Good Unit Test=
A good unit test has the following characteristics.
*It is important that the test executes fast. If the tests are slow, they will not be run often.
*Environmental dependencies such as databases, file systems, networks, queues, and so on which will slow down the tests are either separated or simulated. Tests that exercise these will not run fast, and a failure does not give meaningful feedback about what the problem actually is.
*The scope of testing is very limited. If the test fails, it's obvious where to look for the problem. It's important to only test one aspect in a single test.
*The test should run and pass in isolation (on any machine). If the tests require special environmental setup or fail unexpectedly, then they are not good unit tests.
*Such a test often uses stubs and mock objects. If the code being tested typically calls out to a database or file system, these dependencies must be simulated, or mocked. These dependencies will ordinarily be abstracted away by using interfaces.
*The intention of testing is clearly revealed. Another developer can look at the test and understand what is expected of the production code.

=Benefits of TDD=

Using TDD has many benefits.

*Automated testing: Automated system makes the testing much more easier and faster. Manual testing is slower and needs human interaction which is error-prone. Automated testing makes sure any particular test is not missing every time we test the system, whereas humans may leave a test out mistakenly during testing process.
*Better to test New/Modified Functionality: With manual testing whenever you add new functionality or modify existing functionality, QA personal needs to test all systems that may be affected due to the modification which may be time-consuming. This may also leave a hidden bug in the system after modification. With TDD whenever a new functionality is added or existing functionality is modified, the whole set of tests in the system is run to make sure existing tests are passed. This makes sure that existing functionality is not broken.
*Developer’s confidence: With TDD, developers are more safe to change the system as any inappropriate changes will make some tests to fail. With non-TDD system developers needs to take more care to change existing system as the new change may fail other functionality. But with TDD developers can do so easily as after modification if developer runs the test he/she will find immediately that the change has failed some other tests (i.e. some other part of the system).
*Manual testing stage is shortened: In non-TDD development, as soon as developers prepare a build, QA personal starts testing. This manual testing takes a reasonable amount of time and increases the time to deliver the product from the build time. With TDD, a major part of the system is tested during development and needs lesser QA involvement in the time between build and final delivery of the product.
*Alternative Documentation: Unit tests are kind of documentation to system. Each unit test tells about an individual requirement to the module or system. For example, the following test ensures that only a logged in user with proper balance can buy an item when the item exists in stock. This test reflects a user aspect scenario of the system.

public void CheckUserCanNotPurchaseItemWithoutBalance(){
LoginToTheSystem();
SelectAnItemToBuy();
MakeSureItemExsitsInStock();
MakeSureUserHasBalanceToBuy();
RunTheTransaction();
}
*Better way to fix bugs: In TDD approach when QA finds a bug, developer first writes a test that generates the bug (that is the test will fail due to this bug). Then developer modifies code to make sure that the test is passed (i.e., the bug is fixed). This approach makes sure that next time the bug will not appear in the system as a test is written in the system to take care of the bug.
*Repetition of the same bug reduced: With TDD once a bug is found, it's put under test. So every time you run the whole test in the system, the tests associated with the bug are run and make sure the bugs are not generated again.

=Shortcomings Of TDD=

TDD has a few shortcomings:

*The actual database or external file is never tested directly by TDD (only production code can test it)
*If not used carefully, it can add to the total project costs and complexity of the project
*TDD is unable to test UI.
*TDD is highly reliant on Refactoring and Programmer Skills.

=Conclusion=

TDD fundamentaly changes how a developer approaches a programming project. It forces him to focus on the design requirements first by mandating that the developer must write a test for anything before he writes code to do it. It has many benefits including ensuring that the project is well tested and, in some cases, reducing development time. However, it is limited in that it can't test user interfaces or databases directly. Overall, it is a very effective tool for quickly writing well tested code.

=References=
*[http://catalog.lib.ncsu.edu/record/NCSU1601963 Beck, K. (2002). Test-driven development by example. Addison-Wesley.]
*[http://en.wikipedia.org/wiki/Test_driven_development (n.d.). Test-driven development. website: http://en.wikipedia.org/wiki/Test_driven_development]
*[http://c2.com/cgi/wiki?TestDrivenDevelopment (2012, January 11). Test driven development. website: http://c2.com/cgi/wiki?TestDrivenDevelopment]
*[http://www.agiledata.org/essays/tdd.html Ambler, S. W. (2002). Introduction to test driven development (tdd). Retrieved from Agile Data website: http://www.agiledata.org/essays/tdd.html]
*[http://www.methodsandtools.com/archive/archive.php?id=20 Murphy, Craig. (n. d.). Methods and Tools Archives website: http://www.methodsandtools.com/archive/archive.php?id=20]
*[http://www.martinfowler.com/bliki/TestDrivenDevelopment.html Fowler, Martin. (n. d.). Test Driven Development website: www.martinfowler.com/bliki/TestDrivenDevelopment]
*[http://www.codeproject.com/Articles/47747/Test-Driven-Development-TDD-Step-by-Step-Part-1-In Sohel, Rana. (2009 December, 17). TDD Step by Step Code Project website: http://www.codeproject.com/Articles/47747/Test-Driven-Development-TDD-Step-by-Step-Part-1-In]
*[http://integralpath.blogs.com/thinkingoutloud/2005/09/principles_of_t.html Girvin, T.(2005, September 9) Principles for Test-Driven Development website: http://integralpath.blogs.com/thinkingoutloud/2005/09/principles_of_t.html]

CSC/ECE 517 Fall 2012/ch2a 2w11 aa

2012-10-30T02:57:05Z

Dmcarmon: /* References */

=Introduction=
Test driven development (TDD) is a process that tries to create the minimal amount of code while meeting customer's expectations. TDD is a component of [http://en.wikipedia.org/wiki/Extreme_programming Extreme Programming] and often used in conjunction with [http://en.wikipedia.org/wiki/Integration_test integration tests]. The premise of TDD is to test first, code second, and improve (or [http://en.wikipedia.org/wiki/Refactoring refactor]) last. This forces the software developers to focus on customer specifications first. After each iteration of testing, coding, and refactoring the programmer has a piece of ready to ship code. The rest of this chapter gives the motivation for TDD, shows the steps for TDD, outlines the principles of TDD, provides examples using TDD, and compares the pros and cons of TDD.

=Motivation for TDD=

There are two main motivations for TDD.

[[File:CostofChange.png|550px|Thumb:Figure 1: Traditional "Cost of Change" curve with the waterfall model superimposed]]

*Testing is the one activity that improves the quality of code. In various design scenarios, like waterfall model, testing occurs towards the end of the project development activity. As shown in the figure 1, introducing testing as a latter phase increases the cost incurred for implementing the changes. From this we infer that there is a high chance of reducing the costs by moving the Test phase to the initial part.
*The client can also be well informed about the design and can suggest changes which can be incorporated well in advance. This approach also known as TDD helps achieve flexibility to achieve the client’s ever-changing requirements

=Principles=

TDD follows several principles:

*Tests serve as examples of how to use a class or method. Once used to having tests that show how things work (and that they work), developers start inquiring if a test was already there for the piece of code to be developed
*Developer tests are distinctly different from QA (Quality Analysis) tests and should be kept separate. QA tests target features and treat the system as a black box. Unit tests created by the developer operate at a lower level and test different things.
*Name the tests carefully. For Example, name test packages like the package being tested with a suffix. For example, the "DataAccess" project/package is tested by "DataAccess.Test". Also, name test classes the same as the class under test with the suffix "Test". For example, the class "PrintManager" is tested by the test class "PrintManagerTest". This convention makes it easy to find the related class and keeps the class name a noun. You should also name test methods the same as the method being tested with the prefix "Test". For example, the method "PrintProductOrder()" is tested by the method "TestPrintProductOrder()". This convention keeps the method name a verb that reads as an english phrase.
*Write each test before writing the method under test. It encourages the developer to think as a user of the target method before thinking about implementation, which usually results in a cleaner, easier-to-use interface.
*Follow the "3-As" pattern for test methods: Arrange, Act, Assert. Specifically, use separate code paragraphs (groups of lines of code separated by a blank line) for each of the As. Arrange is variable declaration and initialization. Act is invoking the code under test. Assert is using the Assert.* methods to verify that expectations were met.
*When writing application code, only write enough code to make a test work. This technique prevents gold-plating and ensures that you always have a test for the code you write.
*When you find you need to refractor working code, refractor and re-test prior to writing new code. This technique ensures your refractoring is correct prior to adding new functionality and applies to creating new methods, introducing inheritance, everything.

=Steps=
[[File:TDD_Steps.png|550px|Thumb:Figure 1: Traditional "Cost of Change" curve with the waterfall model superimposed]]

Follow these steps:
*Understand the requirements of the story, work item, or feature that you are working on.
*Red:Create a test and make it fail.
Imagine how the new code should be called and write the test as if the code already existed.
Create the new production code stub. Write just enough code so that it compiles.
Run the test. It should fail. This is a calibration measure to ensure that your test is calling the correct code and that the code is not working by accident. This is a meaningful failure, and you expect it to fail.
*Green: Make the test pass by any means necessary.
Write the production code to make the test pass. Keep it simple.
Some advocate the hard-coding of the expected return value first to verify that the test correctly detects success. This varies from practitioner to practitioner.If you've written the code so that the test passes as intended, you are finished. You do not have to write more code speculatively. If new functionality is still needed, then another test is needed. Make this one test pass and continue.
When the test passes, you might want to run all tests up to this point to build confidence that everything else is still working.
*Refactor: Change the code to remove duplication in your project and to improve the design while ensuring that all tests still pass.
Remove duplication caused by the addition of the new functionality.
Make design changes to improve the overall solution.
After each refactoring, rerun all the tests to ensure that they all still pass.
*Repeat the cycle. Each cycle should be very short, and a typical hour should contain many Red/Green/ Refractor cycles.

=Examples=

==Homework Grades Program==

===Setup===
As a simple example, we are creating a program that keeps track of our homework grades. We envision that we would be able to get the average of these homework grades. Step one: write a test . Let's test an average function

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
assert(myHomework.average(myHomework.grades) == 75);
</pre>

We will get multiple errors - this test won't even compile (but, that's ok for now). Let's take a look at what will generate error messages:

* class <code>Homework</code> not declared
* <code>Homework</code> constructor not declared
* field <code>grades</code> not declared
* method <code>average</code> not declared

Now, we fix the first error:

<pre>
class Homework {

}
</pre>

Second error:

<pre>
Homework(void) {

}
</pre>

Third error:

<pre>
int * grades;
</pre>

Fourth error:

<pre>
int average(int * grades) {
return 0; // default return value
}
</pre>

Finally, the test compiles! The code now looks like this:

<pre>
class Homework {

int * grades;

Homework(void) {

}

int average(int * grades) {

return 0; // default return value

}

}
</pre>

===Red Step===
Now, we run the test, and the familar red bar of failure greets us (remember the mantra red-green-refactor). The assert fails. The average function needs to actually average something (not just return 0). As we think about averaging the grades, we realize we need to know how many grades are in the int array <code>grades</code>. So, we add to the code:

<pre>
class Homework {

int * grades;
int numGrades; // new

Homework(void) {

}

int average(int * grades) {

int avg = 0; // new

for(int i = 0; i < numGrades; i++) { // new
avg += grades[i]; // new
} // new

return avg/numGrades; // new

}

}
</pre>

Of course, we must remember to change the test to:

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
myHomework.numGrades = 2;
assert(myHomework.average(myHomework.grades) == 75);
</pre>

===Green Step===
Success! We have a green bar when we run it.

===Refactoring Step===
The last step is refactoring. Perhaps we don't want a grade to be an <code>int</code>? Should it be an <code>unsigned int</code>? For this simple example, there isn't much refactoring to do, but in a larger example there may be multiple areas for improvement.

==Refactoring Example==
The following example is take from Test-Driven Development by Example by Kent Beck.

Using the TDD process the author created an object with the following structure:

<pre>
class Dollar {

Dollar(int amount) {
this.amount = amount;
}

void times(int mulitplier) {
amount *= multiplier;
}

}
</pre>

What's wrong with the code above? Look at the following test:

<pre>
public void testMultiplication() {

Dollar five = new Dollar(5);
five.times(2);
assertEquals(10, five.amount);
five.times(3);
assertEquals(15, five.amount);

}
</pre>

Whenever we perform an operation on a <code>Dollar</code> the value of the <code>Dollar</code> changes. In the test above <code>five</code> isn't 5 after we multiply it by 2, and thus the name <code>five</code> doesn't make sense anymore. How do we change this?

===Red Step===

First, we change the test.

<pre>
public void testMultiplication() {
Dollar five = new Dollar(5);
Dollar product = five.times(2);
assertEquals(10, product.amount);
product = five.times(3);
assertEquals(15, product.amount);
}
</pre>

The new test won't compile until we change the code:

<pre>
Dollar times(int multiplier) {
amount *= multiplier;
return null;
}
</pre>

Now the test compiles, but fails. Once again, we change the code:

<pre>
Dollar times(int multiplier) {
return new Dollar(amount * multiplier);
}
</pre>

===Green Step===

The test succeeds. So we see that even when we are refactoring we change the test first, then the code. This way we know our refactoring is an improvement.

==More Examples==
See Test-Driven Development by Example by Kent Beck for more examples.

=Characteristics of a Good Unit Test=
A good unit test has the following characteristics.
*It is important that the test executes fast. If the tests are slow, they will not be run often.
*Environmental dependencies such as databases, file systems, networks, queues, and so on which will slow down the tests are either separated or simulated. Tests that exercise these will not run fast, and a failure does not give meaningful feedback about what the problem actually is.
*The scope of testing is very limited. If the test fails, it's obvious where to look for the problem. It's important to only test one aspect in a single test.
*The test should run and pass in isolation (on any machine). If the tests require special environmental setup or fail unexpectedly, then they are not good unit tests.
*Such a test often uses stubs and mock objects. If the code being tested typically calls out to a database or file system, these dependencies must be simulated, or mocked. These dependencies will ordinarily be abstracted away by using interfaces.
*The intention of testing is clearly revealed. Another developer can look at the test and understand what is expected of the production code.

=Benefits of TDD=

Using TDD has many benefits.

*Automated testing: Automated system makes the testing much more easier and faster. Manual testing is slower and needs human interaction which is error-prone. Automated testing makes sure any particular test is not missing every time we test the system, whereas humans may leave a test out mistakenly during testing process.
*Better to test New/Modified Functionality: With manual testing whenever you add new functionality or modify existing functionality, QA personal needs to test all systems that may be affected due to the modification which may be time-consuming. This may also leave a hidden bug in the system after modification. With TDD whenever a new functionality is added or existing functionality is modified, the whole set of tests in the system is run to make sure existing tests are passed. This makes sure that existing functionality is not broken.
*Developer’s confidence: With TDD, developers are more safe to change the system as any inappropriate changes will make some tests to fail. With non-TDD system developers needs to take more care to change existing system as the new change may fail other functionality. But with TDD developers can do so easily as after modification if developer runs the test he/she will find immediately that the change has failed some other tests (i.e. some other part of the system).
*Manual testing stage is shortened: In non-TDD development, as soon as developers prepare a build, QA personal starts testing. This manual testing takes a reasonable amount of time and increases the time to deliver the product from the build time. With TDD, a major part of the system is tested during development and needs lesser QA involvement in the time between build and final delivery of the product.
*Alternative Documentation: Unit tests are kind of documentation to system. Each unit test tells about an individual requirement to the module or system. For example, the following test ensures that only a logged in user with proper balance can buy an item when the item exists in stock. This test reflects a user aspect scenario of the system.

public void CheckUserCanNotPurchaseItemWithoutBalance(){
LoginToTheSystem();
SelectAnItemToBuy();
MakeSureItemExsitsInStock();
MakeSureUserHasBalanceToBuy();
RunTheTransaction();
}
*Better way to fix bugs: In TDD approach when QA finds a bug, developer first writes a test that generates the bug (that is the test will fail due to this bug). Then developer modifies code to make sure that the test is passed (i.e., the bug is fixed). This approach makes sure that next time the bug will not appear in the system as a test is written in the system to take care of the bug.
*Repetition of the same bug reduced: With TDD once a bug is found, it's put under test. So every time you run the whole test in the system, the tests associated with the bug are run and make sure the bugs are not generated again.

=Shortcomings Of TDD=

TDD has a few shortcomings:

*The actual database or external file is never tested directly by TDD (only production code can test it)
*If not used carefully, it can add to the total project costs and complexity of the project
*TDD is unable to test UI.
*TDD is highly reliant on Refactoring and Programmer Skills.

=Conclusion=

TDD fundamentaly changes how a developer approaches a programming project. It forces him to focus on the design requirements first by mandating that the developer must write a test for anything before he writes code to do it. It has many benefits including ensuring that the project is well tested and, in some cases, reducing development time. However, it is limited in that it can't test user interfaces or databases directly. Overall, it is a very effective tool for quickly writing well tested code.

=References=
*[http://catalog.lib.ncsu.edu/record/NCSU1601963 Beck, K. (2002). Test-driven development by example. Addison-Wesley.]
*[http://en.wikipedia.org/wiki/Test_driven_development (n.d.). Test-driven development. website: http://en.wikipedia.org/wiki/Test_driven_development]
*[http://c2.com/cgi/wiki?TestDrivenDevelopment (2012, January 11). Test driven development. website: http://c2.com/cgi/wiki?TestDrivenDevelopment]
*[http://www.agiledata.org/essays/tdd.html Ambler, S. W. (2002). Introduction to test driven development (tdd). Retrieved from Agile Data website: http://www.agiledata.org/essays/tdd.html]
*[http://www.methodsandtools.com/archive/archive.php?id=20 Murphy, Craig. (n. d.). Methods and Tools Archives website: http://www.methodsandtools.com/archive/archive.php?id=20]
*[http://www.martinfowler.com/bliki/TestDrivenDevelopment.html Fowler, Martin. (n. d.). Test Driven Development website: www.martinfowler.com/bliki/TestDrivenDevelopment]
*[http://www.codeproject.com/Articles/47747/Test-Driven-Development-TDD-Step-by-Step-Part-1-In Sohel, Rana. (2009 December, 17). TDD Step by Step Code Project website: http://www.codeproject.com/Articles/47747/Test-Driven-Development-TDD-Step-by-Step-Part-1-In]
*[http://integralpath.blogs.com/thinkingoutloud/2005/09/principles_of_t.html Girvin, T.(2005, September 9) Principles for Test-Driven Development website: http://integralpath.blogs.com/thinkingoutloud/2005/09/principles_of_t.html]

CSC/ECE 517 Fall 2012/ch2a 2w11 aa

2012-10-30T02:12:19Z

Dmcarmon: Updated page based on review feedback

=Introduction=
Test driven development (TDD) is a process that tries to create the minimal amount of code while meeting customer's expectations. TDD is a component of [http://en.wikipedia.org/wiki/Extreme_programming Extreme Programming] and often used in conjunction with [http://en.wikipedia.org/wiki/Integration_test integration tests]. The premise of TDD is to test first, code second, and improve (or [http://en.wikipedia.org/wiki/Refactoring refactor]) last. This forces the software developers to focus on customer specifications first. After each iteration of testing, coding, and refactoring the programmer has a piece of ready to ship code. The rest of this chapter gives the motivation for TDD, shows the steps for TDD, outlines the principles of TDD, provides examples using TDD, and compares the pros and cons of TDD.

=Motivation for TDD=

There are two main motivations for TDD.

[[File:CostofChange.png|550px|Thumb:Figure 1: Traditional "Cost of Change" curve with the waterfall model superimposed]]

*Testing is the one activity that improves the quality of code. In various design scenarios, like waterfall model, testing occurs towards the end of the project development activity. As shown in the figure 1, introducing testing as a latter phase increases the cost incurred for implementing the changes. From this we infer that there is a high chance of reducing the costs by moving the Test phase to the initial part.
*The client can also be well informed about the design and can suggest changes which can be incorporated well in advance. This approach also known as TDD helps achieve flexibility to achieve the client’s ever-changing requirements

=Principles=

TDD follows several principles:

*Tests serve as examples of how to use a class or method. Once used to having tests that show how things work (and that they work), developers start inquiring if a test was already there for the piece of code to be developed
*Developer tests are distinctly different from QA (Quality Analysis) tests and should be kept separate. QA tests target features and treat the system as a black box. Unit tests created by the developer operate at a lower level and test different things.
*Name the tests carefully. For Example, name test packages like the package being tested with a suffix. For example, the "DataAccess" project/package is tested by "DataAccess.Test". Also, name test classes the same as the class under test with the suffix "Test". For example, the class "PrintManager" is tested by the test class "PrintManagerTest". This convention makes it easy to find the related class and keeps the class name a noun. You should also name test methods the same as the method being tested with the prefix "Test". For example, the method "PrintProductOrder()" is tested by the method "TestPrintProductOrder()". This convention keeps the method name a verb that reads as an english phrase.
*Write each test before writing the method under test. It encourages the developer to think as a user of the target method before thinking about implementation, which usually results in a cleaner, easier-to-use interface.
*Follow the "3-As" pattern for test methods: Arrange, Act, Assert. Specifically, use separate code paragraphs (groups of lines of code separated by a blank line) for each of the As. Arrange is variable declaration and initialization. Act is invoking the code under test. Assert is using the Assert.* methods to verify that expectations were met.
*When writing application code, only write enough code to make a test work. This technique prevents gold-plating and ensures that you always have a test for the code you write.
*When you find you need to refractor working code, refractor and re-test prior to writing new code. This technique ensures your refractoring is correct prior to adding new functionality and applies to creating new methods, introducing inheritance, everything.

=Steps=
[[File:TDD_Steps.png|550px|Thumb:Figure 1: Traditional "Cost of Change" curve with the waterfall model superimposed]]

Follow these steps:
*Understand the requirements of the story, work item, or feature that you are working on.
*Red:Create a test and make it fail.
Imagine how the new code should be called and write the test as if the code already existed.
Create the new production code stub. Write just enough code so that it compiles.
Run the test. It should fail. This is a calibration measure to ensure that your test is calling the correct code and that the code is not working by accident. This is a meaningful failure, and you expect it to fail.
*Green: Make the test pass by any means necessary.
Write the production code to make the test pass. Keep it simple.
Some advocate the hard-coding of the expected return value first to verify that the test correctly detects success. This varies from practitioner to practitioner.If you've written the code so that the test passes as intended, you are finished. You do not have to write more code speculatively. If new functionality is still needed, then another test is needed. Make this one test pass and continue.
When the test passes, you might want to run all tests up to this point to build confidence that everything else is still working.
*Refactor: Change the code to remove duplication in your project and to improve the design while ensuring that all tests still pass.
Remove duplication caused by the addition of the new functionality.
Make design changes to improve the overall solution.
After each refactoring, rerun all the tests to ensure that they all still pass.
*Repeat the cycle. Each cycle should be very short, and a typical hour should contain many Red/Green/ Refractor cycles.

=Examples=

==Homework Grades Program==

===Setup===
As a simple example, we are creating a program that keeps track of our homework grades. We envision that we would be able to get the average of these homework grades. Step one: write a test . Let's test an average function

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
assert(myHomework.average(myHomework.grades) == 75);
</pre>

We will get multiple errors - this test won't even compile (but, that's ok for now). Let's take a look at what will generate error messages:

* class <code>Homework</code> not declared
* <code>Homework</code> constructor not declared
* field <code>grades</code> not declared
* method <code>average</code> not declared

Now, we fix the first error:

<pre>
class Homework {

}
</pre>

Second error:

<pre>
Homework(void) {

}
</pre>

Third error:

<pre>
int * grades;
</pre>

Fourth error:

<pre>
int average(int * grades) {
return 0; // default return value
}
</pre>

Finally, the test compiles! The code now looks like this:

<pre>
class Homework {

int * grades;

Homework(void) {

}

int average(int * grades) {

return 0; // default return value

}

}
</pre>

===Red Step===
Now, we run the test, and the familar red bar of failure greets us (remember the mantra red-green-refactor). The assert fails. The average function needs to actually average something (not just return 0). As we think about averaging the grades, we realize we need to know how many grades are in the int array <code>grades</code>. So, we add to the code:

<pre>
class Homework {

int * grades;
int numGrades; // new

Homework(void) {

}

int average(int * grades) {

int avg = 0; // new

for(int i = 0; i < numGrades; i++) { // new
avg += grades[i]; // new
} // new

return avg/numGrades; // new

}

}
</pre>

Of course, we must remember to change the test to:

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
myHomework.numGrades = 2;
assert(myHomework.average(myHomework.grades) == 75);
</pre>

===Green Step===
Success! We have a green bar when we run it.

===Refactoring Step===
The last step is refactoring. Perhaps we don't want a grade to be an <code>int</code>? Should it be an <code>unsigned int</code>? For this simple example, there isn't much refactoring to do, but in a larger example there may be multiple areas for improvement.

==Refactoring Example==
The following example is take from Test-Driven Development by Example by Kent Beck.

Using the TDD process the author created an object with the following structure:

<pre>
class Dollar {

Dollar(int amount) {
this.amount = amount;
}

void times(int mulitplier) {
amount *= multiplier;
}

}
</pre>

What's wrong with the code above? Look at the following test:

<pre>
public void testMultiplication() {

Dollar five = new Dollar(5);
five.times(2);
assertEquals(10, five.amount);
five.times(3);
assertEquals(15, five.amount);

}
</pre>

Whenever we perform an operation on a <code>Dollar</code> the value of the <code>Dollar</code> changes. In the test above <code>five</code> isn't 5 after we multiply it by 2, and thus the name <code>five</code> doesn't make sense anymore. How do we change this?

===Red Step===

First, we change the test.

<pre>
public void testMultiplication() {
Dollar five = new Dollar(5);
Dollar product = five.times(2);
assertEquals(10, product.amount);
product = five.times(3);
assertEquals(15, product.amount);
}
</pre>

The new test won't compile until we change the code:

<pre>
Dollar times(int multiplier) {
amount *= multiplier;
return null;
}
</pre>

Now the test compiles, but fails. Once again, we change the code:

<pre>
Dollar times(int multiplier) {
return new Dollar(amount * multiplier);
}
</pre>

===Green Step===

The test succeeds. So we see that even when we are refactoring we change the test first, then the code. This way we know our refactoring is an improvement.

==More Examples==
See Test-Driven Development by Example by Kent Beck for more examples.

=Characteristics of a Good Unit Test=
A good unit test has the following characteristics.
*It is important that the test executes fast. If the tests are slow, they will not be run often.
*Environmental dependencies such as databases, file systems, networks, queues, and so on which will slow down the tests are either separated or simulated. Tests that exercise these will not run fast, and a failure does not give meaningful feedback about what the problem actually is.
*The scope of testing is very limited. If the test fails, it's obvious where to look for the problem. It's important to only test one aspect in a single test.
*The test should run and pass in isolation (on any machine). If the tests require special environmental setup or fail unexpectedly, then they are not good unit tests.
*Such a test often uses stubs and mock objects. If the code being tested typically calls out to a database or file system, these dependencies must be simulated, or mocked. These dependencies will ordinarily be abstracted away by using interfaces.
*The intention of testing is clearly revealed. Another developer can look at the test and understand what is expected of the production code.

=Benefits of TDD=

Using TDD has many benefits.

*Automated testing: Automated system makes the testing much more easier and faster. Manual testing is slower and needs human interaction which is error-prone. Automated testing makes sure any particular test is not missing every time we test the system, whereas humans may leave a test out mistakenly during testing process.
*Better to test New/Modified Functionality: With manual testing whenever you add new functionality or modify existing functionality, QA personal needs to test all systems that may be affected due to the modification which may be time-consuming. This may also leave a hidden bug in the system after modification. With TDD whenever a new functionality is added or existing functionality is modified, the whole set of tests in the system is run to make sure existing tests are passed. This makes sure that existing functionality is not broken.
*Developer’s confidence: With TDD, developers are more safe to change the system as any inappropriate changes will make some tests to fail. With non-TDD system developers needs to take more care to change existing system as the new change may fail other functionality. But with TDD developers can do so easily as after modification if developer runs the test he/she will find immediately that the change has failed some other tests (i.e. some other part of the system).
*Manual testing stage is shortened: In non-TDD development, as soon as developers prepare a build, QA personal starts testing. This manual testing takes a reasonable amount of time and increases the time to deliver the product from the build time. With TDD, a major part of the system is tested during development and needs lesser QA involvement in the time between build and final delivery of the product.
*Alternative Documentation: Unit tests are kind of documentation to system. Each unit test tells about an individual requirement to the module or system. For example, the following test ensures that only a logged in user with proper balance can buy an item when the item exists in stock. This test reflects a user aspect scenario of the system.

public void CheckUserCanNotPurchaseItemWithoutBalance(){
LoginToTheSystem();
SelectAnItemToBuy();
MakeSureItemExsitsInStock();
MakeSureUserHasBalanceToBuy();
RunTheTransaction();
}
*Better way to fix bugs: In TDD approach when QA finds a bug, developer first writes a test that generates the bug (that is the test will fail due to this bug). Then developer modifies code to make sure that the test is passed (i.e., the bug is fixed). This approach makes sure that next time the bug will not appear in the system as a test is written in the system to take care of the bug.
*Repetition of the same bug reduced: With TDD once a bug is found, it's put under test. So every time you run the whole test in the system, the tests associated with the bug are run and make sure the bugs are not generated again.

=Shortcomings Of TDD=

TDD has a few shortcomings:

*The actual database or external file is never tested directly by TDD (only production code can test it)
*If not used carefully, it can add to the total project costs and complexity of the project
*TDD is unable to test UI.
*TDD is highly reliant on Refactoring and Programmer Skills.

=Conclusion=

TDD fundamentaly changes how a developer approaches a programming project. It forces him to focus on the design requirements first by mandating that the developer must write a test for anything before he writes code to do it. It has many benefits including ensuring that the project is well tested and, in some cases, reducing development time. However, it is limited in that it can't test user interfaces or databases directly. Overall, it is a very effective tool for quickly writing well tested code.

=References=
*[http://catalog.lib.ncsu.edu/record/NCSU1601963 Beck, K. (2002). Test-driven development by example. Addison-Wesley.]
*[http://en.wikipedia.org/wiki/Test_driven_development (n.d.). Test-driven development. website: http://en.wikipedia.org/wiki/Test_driven_development]
*[http://c2.com/cgi/wiki?TestDrivenDevelopment (2012, January 11). Test driven development. website: http://c2.com/cgi/wiki?TestDrivenDevelopment]
*[http://www.agiledata.org/essays/tdd.html Ambler, S. W. (2002). Introduction to test driven development (tdd). Retrieved from Agile Data website: http://www.agiledata.org/essays/tdd.html]
*[http://www.methodsandtools.com/archive/archive.php?id=20 Murphy, Craig. (n. d.). Methods and Tools Archives website http://www.methodsandtools.com/archive/archive.php?id=20]
*[http://www.martinfowler.com/bliki/TestDrivenDevelopment.html www.martinfowler.com/bliki/TestDrivenDevelopment]
*[http://www.codeproject.com/Articles/47747/Test-Driven-Development-TDD-Step-by-Step-Part-1-In TDD Step by Step Code Project]
*[http://integralpath.blogs.com/thinkingoutloud/2005/09/principles_of_t.html Principles of Testing]

CSC/ECE 517 Fall 2012/ch2a 2w11 aa

2012-10-30T01:00:38Z

Dmcarmon: /* Introduction */

=Introduction=
Test driven development (TDD) is a process that tries to create the minimal amount of code to meet customer's expectations. The idea is to test first, code second, then improve (or [http://en.wikipedia.org/wiki/Refactoring refactor]) last. This process forces the software developers to focus on customer specifications and validation first. Since at each step of the way the programmer proves to himself that the code meets specifications, TDD gives the programmer confidence. The rest of this chapter gives the motivation for TDD, shows the steps for TDD, outlines the principles of TDD, provides examples using TDD, and compares the pros and cons of TDD.

=Motivation for TDD=

There are two main motivations for TDD.

[[File:CostofChange.png|550px|Thumb:Figure 1: Traditional "Cost of Change" curve with the waterfall model superimposed]]

*Testing is the one activity that improves the quality of code. In various design scenarios, like waterfall model, testing occurs towards the end of the project development activity. As shown in the figure 1, introducing testing as a latter phase increases the cost incurred for implementing the changes. From this we infer that there is a high chance of reducing the costs by moving the Test phase to the initial part.
*The client can also be well informed about the design and can suggest changes which can be incorporated well in advance. This approach also known as TDD helps achieve flexibility to achieve the client’s ever-changing requirements

=Principles=

TDD follows several principles:

*Tests serve as examples of how to use a class or method. Once used to having tests that show how things work (and that they work), developers start inquiring if a test was already there for the piece of code to be developed
*Developer tests are distinctly different from QA (Quality Analysis) tests and should be kept separate. QA tests target features and treat the system as a black box. Unit tests created by the developer operate at a lower level and test different things.
*Name the tests carefully. For Example, name test packages like the package being tested with a suffix. For example, the "DataAccess" project/package is tested by "DataAccess.Test". Also, name test classes the same as the class under test with the suffix "Test". For example, the class "PrintManager" is tested by the test class "PrintManagerTest". This convention makes it easy to find the related class and keeps the class name a noun. You should also name test methods the same as the method being tested with the prefix "Test". For example, the method "PrintProductOrder()" is tested by the method "TestPrintProductOrder()". This convention keeps the method name a verb that reads as an english phrase.
*Write each test before writing the method under test. It encourages the developer to think as a user of the target method before thinking about implementation, which usually results in a cleaner, easier-to-use interface.
*Follow the "3-As" pattern for test methods: Arrange, Act, Assert. Specifically, use separate code paragraphs (groups of lines of code separated by a blank line) for each of the As. Arrange is variable declaration and initialization. Act is invoking the code under test. Assert is using the Assert.* methods to verify that expectations were met.
*When writing application code, only write enough code to make a test work. This technique prevents gold-plating and ensures that you always have a test for the code you write.
*When you find you need to refractor working code, refractor and re-test prior to writing new code. This technique ensures your refractoring is correct prior to adding new functionality and applies to creating new methods, introducing inheritance, everything.

=Steps=
[[File:TDD_Steps.png|550px|Thumb:Figure 1: Traditional "Cost of Change" curve with the waterfall model superimposed]]

Follow these steps:
*Understand the requirements of the story, work item, or feature that you are working on.
*Red:Create a test and make it fail.
Imagine how the new code should be called and write the test as if the code already existed.
Create the new production code stub. Write just enough code so that it compiles.
Run the test. It should fail. This is a calibration measure to ensure that your test is calling the correct code and that the code is not working by accident. This is a meaningful failure, and you expect it to fail.
*Green: Make the test pass by any means necessary.
Write the production code to make the test pass. Keep it simple.
Some advocate the hard-coding of the expected return value first to verify that the test correctly detects success. This varies from practitioner to practitioner.If you've written the code so that the test passes as intended, you are finished. You do not have to write more code speculatively. If new functionality is still needed, then another test is needed. Make this one test pass and continue.
When the test passes, you might want to run all tests up to this point to build confidence that everything else is still working.
*Refractor: Change the code to remove duplication in your project and to improve the design while ensuring that all tests still pass.
Remove duplication caused by the addition of the new functionality.
Make design changes to improve the overall solution.
After each refactoring, rerun all the tests to ensure that they all still pass.
*Repeat the cycle. Each cycle should be very short, and a typical hour should contain many Red/Green/ Refractor cycles.

=Examples=

==Homework Grades Program==

===Setup===
As a simple example, we are creating a program that keeps track of our homework grades. We envision that we would be able to get the average of these homework grades. Step one: write a test . Let's test an average function

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
assert(myHomework.average(myHomework.grades) == 75);
</pre>

We will get multiple errors - this test won't even compile (but, that's ok for now). Let's take a look at what will generate error messages:

* class <code>Homework</code> not declared
* <code>Homework</code> constructor not declared
* field <code>grades</code> not declared
* method <code>average</code> not declared

Now, we fix the first error:

<pre>
class Homework {

}
</pre>

Second error:

<pre>
Homework(void) {

}
</pre>

Third error:

<pre>
int * grades;
</pre>

Fourth error:

<pre>
int average(int * grades) {
return 0; // default return value
}
</pre>

Finally, the test compiles! The code now looks like this:

<pre>
class Homework {

int * grades;

Homework(void) {

}

int average(int * grades) {

return 0; // default return value

}

}
</pre>

===Red===
Now, we run the test, and the familar red bar of failure greets us (remember the mantra red-green-refactor). The assert fails. The average function needs to actually average something (not just return 0). As we think about averaging the grades, we realize we need to know how many grades are in the int array <code>grades</code>. So, we add to the code:

<pre>
class Homework {

int * grades;
int numGrades; // new

Homework(void) {

}

int average(int * grades) {

int avg = 0; // new

for(int i = 0; i < numGrades; i++) { // new
avg += grades[i]; // new
} // new

return avg/numGrades; // new

}

}
</pre>

Of course, we must remember to change the test to:

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
myHomework.numGrades = 2;
assert(myHomework.average(myHomework.grades) == 75);
</pre>

===Green===
Success! We have a green bar when we run it.

===Refactor===
The last step is refactoring. Perhaps we don't want a grade to be an <code>int</code>? Should it be an <code>unsigned int</code>? For this simple example, there isn't much refactoring to do, but in a larger example there may be multiple areas for improvement.

==Refactoring Example==
The following example is take from Test-Driven Development by Example by Kent Beck.

Using the TDD process the author created an object with the following structure:

<pre>
class Dollar {

Dollar(int amount) {
this.amount = amount;
}

void times(int mulitplier) {
amount *= multiplier;
}

}
</pre>

What's wrong with the code above? Look at the following test:

<pre>
public void testMultiplication() {

Dollar five = new Dollar(5);
five.times(2);
assertEquals(10, five.amount);
five.times(3);
assertEquals(15, five.amount);

}
</pre>

Whenever we perform an operation on a <code>Dollar</code> the value of the <code>Dollar</code> changes. In the test above <code>five</code> isn't 5 after we multiply it by 2, and thus the name <code>five</code> doesn't make sense anymore. How do we change this?

===Red===

First, we change the test.

<pre>
public void testMultiplication() {
Dollar five = new Dollar(5);
Dollar product = five.times(2);
assertEquals(10, product.amount);
product = five.times(3);
assertEquals(15, product.amount);
}
</pre>

The new test won't compile until we change the code:

<pre>
Dollar times(int multiplier) {
amount *= multiplier;
return null;
}
</pre>

Now the test compiles, but fails. Once again, we change the code:

<pre>
Dollar times(int multiplier) {
return new Dollar(amount * multiplier);
}
</pre>

===Green===

The test succeeds. So we see that even when we are refactoring we change the test first, then the code. This way we know our refactoring is an improvement.

==More Examples==
See Test-Driven Development by Example by Kent Beck for more examples.

=Characteristics Of A Good Unit Test=
A good unit test has the following characteristics.
*It is important that the test executes fast. If the tests are slow, they will not be run often.
*Environmental dependencies such as databases, file systems, networks, queues, and so on which will slow down the tests are either separated or simulated. Tests that exercise these will not run fast, and a failure does not give meaningful feedback about what the problem actually is.
*The scope of testing is very limited. If the test fails, it's obvious where to look for the problem. It's important to only test one aspect in a single test.
*The test should run and pass in isolation (on any machine). If the tests require special environmental setup or fail unexpectedly, then they are not good unit tests.
*Such a test often uses stubs and mock objects. If the code being tested typically calls out to a database or file system, these dependencies must be simulated, or mocked. These dependencies will ordinarily be abstracted away by using interfaces.
*The intention of testing is clearly revealed. Another developer can look at the test and understand what is expected of the production code.

=Benefits Of TDD=

Using TDD has many benefits.

*Automated testing: Automated system makes the testing much more easier and faster. Manual testing is slower and needs human interaction which is error-prone. Automated testing makes sure any particular test is not missing every time we test the system, whereas humans may leave a test out mistakenly during testing process.
*Better to test New/Modified Functionality: With manual testing whenever you add new functionality or modify existing functionality, QA personal needs to test all systems that may be affected due to the modification which may be time-consuming. This may also leave a hidden bug in the system after modification. With TDD whenever a new functionality is added or existing functionality is modified, the whole set of tests in the system is run to make sure existing tests are passed. This makes sure that existing functionality is not broken.
*Developer’s confidence: With TDD, developers are more safe to change the system as any inappropriate changes will make some tests to fail. With non-TDD system developers needs to take more care to change existing system as the new change may fail other functionality. But with TDD developers can do so easily as after modification if developer runs the test he/she will find immediately that the change has failed some other tests (i.e. some other part of the system).
*Manual testing stage is shortened: In non-TDD development, as soon as developers prepare a build, QA personal starts testing. This manual testing takes a reasonable amount of time and increases the time to deliver the product from the build time. With TDD, a major part of the system is tested during development and needs lesser QA involvement in the time between build and final delivery of the product.
*Alternative Documentation: Unit tests are kind of documentation to system. Each unit test tells about an individual requirement to the module or system. For example, the following test ensures that only a logged in user with proper balance can buy an item when the item exists in stock. This test reflects a user aspect scenario of the system.

public void CheckUserCanNotPurchaseItemWithoutBalance(){
LoginToTheSystem();
SelectAnItemToBuy();
MakeSureItemExsitsInStock();
MakeSureUserHasBalanceToBuy();
RunTheTransaction();
}
*Better way to fix bugs: In TDD approach when QA finds a bug, developer first writes a test that generates the bug (that is the test will fail due to this bug). Then developer modifies code to make sure that the test is passed (i.e., the bug is fixed). This approach makes sure that next time the bug will not appear in the system as a test is written in the system to take care of the bug.
*Repetition of the same bug reduced: With TDD once a bug is found, it's put under test. So every time you run the whole test in the system, the tests associated with the bug are run and make sure the bugs are not generated again.

=Shortcomings Of TDD=

TDD has a few shortcomings:

*The actual database or external file is never tested directly by TDD (only production code can test it)
*If not used carefully, it can add to the total project costs and complexity of the project
*TDD is unable to test UI.
*TDD is highly reliant on Refactoring and Programmer Skills.

=Conclusion=

TDD fundamentaly changes how a developer approaches a programming project. It forces him to focus on the design requirements first by mandating that the developer must write a test for anything before he writes code to do it. It has many benefits including ensuring that the project is well tested and, in some cases, reducing development time. However, it is limited in that it can't test user interfaces or databases directly. TDD is a component of [http://en.wikipedia.org/wiki/Extreme_programming Extreme Programming] and often used in conjunction with integration tests. Overall, it is a very effective tool for quickly writing well tested code.

=References=
*[http://catalog.lib.ncsu.edu/record/NCSU1601963 Beck, K. (2002). Test-driven development by example. Addison-Wesley.]
*[http://en.wikipedia.org/wiki/Test_driven_development (n.d.). Test-driven development. website: http://en.wikipedia.org/wiki/Test_driven_development]
*[http://c2.com/cgi/wiki?TestDrivenDevelopment (2012, January 11). Test driven development. website: http://c2.com/cgi/wiki?TestDrivenDevelopment]
*[http://www.agiledata.org/essays/tdd.html Ambler, S. W. (2002). Introduction to test driven development (tdd). Retrieved from Agile Data website: http://www.agiledata.org/essays/tdd.html]
*[http://www.methodsandtools.com/archive/archive.php?id=20. Methods and Tools Archives]
*[http://www.martinfowler.com/bliki/TestDrivenDevelopment.html www.martinfowler.com/bliki/TestDrivenDevelopment]
*[http://www.codeproject.com/Articles/47747/Test-Driven-Development-TDD-Step-by-Step-Part-1-In TDD Step by Step Code Project]
*[http://integralpath.blogs.com/thinkingoutloud/2005/09/principles_of_t.html Principles of Testing]

CSC/ECE 517 Fall 2012/ch2a 2w11 aa

2012-10-25T17:02:56Z

Dmcarmon: /* Conclusion */

=Introduction=
Test driven development (TDD) is a process that tries to create the minimal amount of code to meet customer's expectations. The idea is to test first, code second, then improve (or refactor) last. This process forces the software developers to focus on customer specifications and validation first. Since at each step of the way the programmer proves to himself that the code meets specifications, TDD gives the programmer confidence. The rest of this chapter gives the motivation for TDD, shows the steps for TDD, outlines the principles of TDD, provides examples using TDD, and compares the pros and cons of TDD.

=Motivation for TDD=

There are two main motivations for TDD.

[[File:TimevsCostDev.png|350px|Thumb:Figure 1: Traditional "Cost of Change" curve with the waterfall model superimposed]]

*Testing is the one activity that improves the quality of code. In various design scenarios, like waterfall model, testing occurs towards the end of the project development activity. As shown in the figure 1, introducing testing as a latter phase increases the cost incurred for implementing the changes. From this we infer that there is a high chance of reducing the costs by moving the Test phase to the initial part.
*The client can also be well informed about the design and can suggest changes which can be incorporated well in advance. This approach also known as TDD helps achieve flexibility to achieve the client’s ever-changing requirements

=Principles=

TDD follows several principles:

*Tests serve as examples of how to use a class or method. Once used to having tests that show how things work (and that they work), developers start inquiring if a test was already there for the piece of code to be developed
*Developer tests are distinctly different from QA (Quality Analysis) tests and should be kept separate. QA tests target features and treat the system as a black box. Unit tests created by the developer operate at a lower level and test different things.
*Name the tests carefully. For Example, name test packages like the package being tested with a suffix. For example, the "DataAccess" project/package is tested by "DataAccess.Test". Also, name test classes the same as the class under test with the suffix "Test". For example, the class "PrintManager" is tested by the test class "PrintManagerTest". This convention makes it easy to find the related class and keeps the class name a noun. You should also name test methods the same as the method being tested with the prefix "Test". For example, the method "PrintProductOrder()" is tested by the method "TestPrintProductOrder()". This convention keeps the method name a verb that reads as an english phrase.
*Write each test before writing the method under test. It encourages the developer to think as a user of the target method before thinking about implementation, which usually results in a cleaner, easier-to-use interface.
*Follow the "3-As" pattern for test methods: Arrange, Act, Assert. Specifically, use separate code paragraphs (groups of lines of code separated by a blank line) for each of the As. Arrange is variable declaration and initialization. Act is invoking the code under test. Assert is using the Assert.* methods to verify that expectations were met.
*When writing application code, only write enough code to make a test work. This technique prevents gold-plating and ensures that you always have a test for the code you write.
*When you find you need to refractor working code, refractor and re-test prior to writing new code. This technique ensures your refractoring is correct prior to adding new functionality and applies to creating new methods, introducing inheritance, everything.

=Steps=

[[Image:PureFab.gif]]

Follow these steps:
*Understand the requirements of the story, work item, or feature that you are working on.
*Red:Create a test and make it fail.
Imagine how the new code should be called and write the test as if the code already existed.
Create the new production code stub. Write just enough code so that it compiles.
Run the test. It should fail. This is a calibration measure to ensure that your test is calling the correct code and that the code is not working by accident. This is a meaningful failure, and you expect it to fail.
*Green: Make the test pass by any means necessary.
Write the production code to make the test pass. Keep it simple.
Some advocate the hard-coding of the expected return value first to verify that the test correctly detects success. This varies from practitioner to practitioner.If you've written the code so that the test passes as intended, you are finished. You do not have to write more code speculatively. If new functionality is still needed, then another test is needed. Make this one test pass and continue.
When the test passes, you might want to run all tests up to this point to build confidence that everything else is still working.
*Refractor: Change the code to remove duplication in your project and to improve the design while ensuring that all tests still pass.
Remove duplication caused by the addition of the new functionality.
Make design changes to improve the overall solution.
After each refactoring, rerun all the tests to ensure that they all still pass.
*Repeat the cycle. Each cycle should be very short, and a typical hour should contain many Red/Green/ Refractor cycles.

=Examples=

==Homework Grades Program==

===Setup===
As a simple example, we are creating a program that keeps track of our homework grades. We envision that we would be able to get the average of these homework grades. Step one: write a test . Let's test an average function

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
assert(myHomework.average(myHomework.grades) == 75);
</pre>

We will get multiple errors - this test won't even compile (but, that's ok for now). Let's take a look at what will generate error messages:

* class <code>Homework</code> not declared
* <code>Homework</code> constructor not declared
* field <code>grades</code> not declared
* method <code>average</code> not declared

Now, we fix the first error:

<pre>
class Homework {

}
</pre>

Second error:

<pre>
Homework(void) {

}
</pre>

Third error:

<pre>
int * grades;
</pre>

Fourth error:

<pre>
int average(int * grades) {
return 0; // default return value
}
</pre>

Finally, the test compiles! The code now looks like this:

<pre>
class Homework {

int * grades;

Homework(void) {

}

int average(int * grades) {

return 0; // default return value

}

}
</pre>

===Red===
Now, we run the test, and the familar red bar of failure greets us (remember the mantra red-green-refactor). The assert fails. The average function needs to actually average something (not just return 0). As we think about averaging the grades, we realize we need to know how many grades are in the int array <code>grades</code>. So, we add to the code:

<pre>
class Homework {

int * grades;
int numGrades; // new

Homework(void) {

}

int average(int * grades) {

int avg = 0; // new

for(int i = 0; i < numGrades; i++) { // new
avg += grades[i]; // new
} // new

return avg/numGrades; // new

}

}
</pre>

Of course, we must remember to change the test to:

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
myHomework.numGrades = 2;
assert(myHomework.average(myHomework.grades) == 75);
</pre>

===Green===
Success! We have a green bar when we run it.

===Refactor===
The last step is refactoring. Perhaps we don't want a grade to be an <code>int</code>? Should it be an <code>unsigned int</code>? For this simple example, there isn't much refactoring to do, but in a larger example there may be multiple areas for improvement.

==Refactoring Example==
The following example is take from Test-Driven Development by Example by Kent Beck.

Using the TDD process the author created an object with the following structure:

<pre>
class Dollar {

Dollar(int amount) {
this.amount = amount;
}

void times(int mulitplier) {
amount *= multiplier;
}

}
</pre>

What's wrong with the code above? Look at the following test:

<pre>
public void testMultiplication() {

Dollar five = new Dollar(5);
five.times(2);
assertEquals(10, five.amount);
five.times(3);
assertEquals(15, five.amount);

}
</pre>

Whenever we perform an operation on a <code>Dollar</code> the value of the <code>Dollar</code> changes. In the test above <code>five</code> isn't 5 after we multiply it by 2, and thus the name <code>five</code> doesn't make sense anymore. How do we change this?

===Red===

First, we change the test.

<pre>
public void testMultiplication() {
Dollar five = new Dollar(5);
Dollar product = five.times(2);
assertEquals(10, product.amount);
product = five.times(3);
assertEquals(15, product.amount);
}
</pre>

The new test won't compile until we change the code:

<pre>
Dollar times(int multiplier) {
amount *= multiplier;
return null;
}
</pre>

Now the test compiles, but fails. Once again, we change the code:

<pre>
Dollar times(int multiplier) {
return new Dollar(amount * multiplier);
}
</pre>

===Green===

The test succeeds. So we see that even when we are refactoring we change the test first, then the code. This way we know our refactoring is an improvement.

==More Examples==
See Test-Driven Development by Example by Kent Beck for more examples.

=Characteristics Of A Good Unit Test=
A good unit test has the following characteristics.
*It is important that the test executes fast. If the tests are slow, they will not be run often.
*Environmental dependencies such as databases, file systems, networks, queues, and so on which will slow down the tests are either separated or simulated. Tests that exercise these will not run fast, and a failure does not give meaningful feedback about what the problem actually is.
*The scope of testing is very limited. If the test fails, it's obvious where to look for the problem. It's important to only test one aspect in a single test.
*The test should run and pass in isolation (on any machine). If the tests require special environmental setup or fail unexpectedly, then they are not good unit tests.
*Such a test often uses stubs and mock objects. If the code being tested typically calls out to a database or file system, these dependencies must be simulated, or mocked. These dependencies will ordinarily be abstracted away by using interfaces.
*The intention of testing is clearly revealed. Another developer can look at the test and understand what is expected of the production code.

=Benefits Of TDD=

Using TDD has many benefits.

*Automated testing: Automated system makes the testing much more easier and faster. Manual testing is slower and needs human interaction which is error-prone. Automated testing makes sure any particular test is not missing every time we test the system, whereas humans may leave a test out mistakenly during testing process.
*Better to test New/Modified Functionality: With manual testing whenever you add new functionality or modify existing functionality, QA personal needs to test all systems that may be affected due to the modification which may be time-consuming. This may also leave a hidden bug in the system after modification. With TDD whenever a new functionality is added or existing functionality is modified, the whole set of tests in the system is run to make sure existing tests are passed. This makes sure that existing functionality is not broken.
*Developer’s confidence: With TDD, developers are more safe to change the system as any inappropriate changes will make some tests to fail. With non-TDD system developers needs to take more care to change existing system as the new change may fail other functionality. But with TDD developers can do so easily as after modification if developer runs the test he/she will find immediately that the change has failed some other tests (i.e. some other part of the system).
*Manual testing stage is shortened: In non-TDD development, as soon as developers prepare a build, QA personal starts testing. This manual testing takes a reasonable amount of time and increases the time to deliver the product from the build time. With TDD, a major part of the system is tested during development and needs lesser QA involvement in the time between build and final delivery of the product.
*Alternative Documentation: Unit tests are kind of documentation to system. Each unit test tells about an individual requirement to the module or system. For example, the following test ensures that only a logged in user with proper balance can buy an item when the item exists in stock. This test reflects a user aspect scenario of the system.

public void CheckUserCanNotPurchaseItemWithoutBalance(){
LoginToTheSystem();
SelectAnItemToBuy();
MakeSureItemExsitsInStock();
MakeSureUserHasBalanceToBuy();
RunTheTransaction();
}
*Better way to fix bugs: In TDD approach when QA finds a bug, developer first writes a test that generates the bug (that is the test will fail due to this bug). Then developer modifies code to make sure that the test is passed (i.e., the bug is fixed). This approach makes sure that next time the bug will not appear in the system as a test is written in the system to take care of the bug.
*Repetition of the same bug reduced: With TDD once a bug is found, it's put under test. So every time you run the whole test in the system, the tests associated with the bug are run and make sure the bugs are not generated again.

=Shortcomings Of TDD=

TDD has a few shortcomings:

*The actual database or external file is never tested directly by TDD (only production code can test it)
*If not used carefully, it can add to the total project costs and complexity of the project
*TDD is unable to test UI.
*TDD is highly reliant on Refactoring and Programmer Skills.

=Conclusion=

TDD fundamentaly changes how a developer approaches a programming project. It forces him to focus on the design requirements first by mandating that the developer must write a test for anything before he writes code to do it. It has many benefits including ensuring that the project is well tested and, in some cases, reducing development time. However, it is limited in that it can't test user interfaces or databases directly. TDD is a component of [http://en.wikipedia.org/wiki/Extreme_programming Extreme Programming] and often used in conjunction with integration tests. Overall, it is a very effective tool for quickly writing well tested code.

=References=
*[http://catalog.lib.ncsu.edu/record/NCSU1601963 Beck, K. (2002). Test-driven development by example. Addison-Wesley.]
*[http://en.wikipedia.org/wiki/Test_driven_development (n.d.). Test-driven development. website: http://en.wikipedia.org/wiki/Test_driven_development]
*[http://c2.com/cgi/wiki?TestDrivenDevelopment (2012, January 11). Test driven development. website: http://c2.com/cgi/wiki?TestDrivenDevelopment]
*[http://www.agiledata.org/essays/tdd.html Ambler, S. W. (2002). Introduction to test driven development (tdd). Retrieved from Agile Data website: http://www.agiledata.org/essays/tdd.html]
*[http://www.methodsandtools.com/archive/archive.php?id=20. Methods and Tools Archives]
*[http://www.martinfowler.com/bliki/TestDrivenDevelopment.html www.martinfowler.com/bliki/TestDrivenDevelopment]
*[http://www.codeproject.com/Articles/47747/Test-Driven-Development-TDD-Step-by-Step-Part-1-In TDD Step by Step Code Project]
*[http://integralpath.blogs.com/thinkingoutloud/2005/09/principles_of_t.html Principles of Testing]

CSC/ECE 517 Fall 2012/ch2a 2w11 aa

2012-10-25T16:57:40Z

Dmcarmon: /* Shortcomings Of TDD */

=Introduction=
Test driven development (TDD) is a process that tries to create the minimal amount of code to meet customer's expectations. The idea is to test first, code second, then improve (or refactor) last. This process forces the software developers to focus on customer specifications and validation first. Since at each step of the way the programmer proves to himself that the code meets specifications, TDD gives the programmer confidence. The rest of this chapter gives the motivation for TDD, shows the steps for TDD, outlines the principles of TDD, provides examples using TDD, and compares the pros and cons of TDD.

=Motivation for TDD=

There are two main motivations for TDD.

[[File:TimevsCostDev.png|350px|Thumb:Figure 1: Traditional "Cost of Change" curve with the waterfall model superimposed]]

*Testing is the one activity that improves the quality of code. In various design scenarios, like waterfall model, testing occurs towards the end of the project development activity. As shown in the figure 1, introducing testing as a latter phase increases the cost incurred for implementing the changes. From this we infer that there is a high chance of reducing the costs by moving the Test phase to the initial part.
*The client can also be well informed about the design and can suggest changes which can be incorporated well in advance. This approach also known as TDD helps achieve flexibility to achieve the client’s ever-changing requirements

=Principles=

TDD follows several principles:

*Tests serve as examples of how to use a class or method. Once used to having tests that show how things work (and that they work), developers start inquiring if a test was already there for the piece of code to be developed
*Developer tests are distinctly different from QA (Quality Analysis) tests and should be kept separate. QA tests target features and treat the system as a black box. Unit tests created by the developer operate at a lower level and test different things.
*Name the tests carefully. For Example, name test packages like the package being tested with a suffix. For example, the "DataAccess" project/package is tested by "DataAccess.Test". Also, name test classes the same as the class under test with the suffix "Test". For example, the class "PrintManager" is tested by the test class "PrintManagerTest". This convention makes it easy to find the related class and keeps the class name a noun. You should also name test methods the same as the method being tested with the prefix "Test". For example, the method "PrintProductOrder()" is tested by the method "TestPrintProductOrder()". This convention keeps the method name a verb that reads as an english phrase.
*Write each test before writing the method under test. It encourages the developer to think as a user of the target method before thinking about implementation, which usually results in a cleaner, easier-to-use interface.
*Follow the "3-As" pattern for test methods: Arrange, Act, Assert. Specifically, use separate code paragraphs (groups of lines of code separated by a blank line) for each of the As. Arrange is variable declaration and initialization. Act is invoking the code under test. Assert is using the Assert.* methods to verify that expectations were met.
*When writing application code, only write enough code to make a test work. This technique prevents gold-plating and ensures that you always have a test for the code you write.
*When you find you need to refractor working code, refractor and re-test prior to writing new code. This technique ensures your refractoring is correct prior to adding new functionality and applies to creating new methods, introducing inheritance, everything.

=Steps=

[[Image:PureFab.gif]]

Follow these steps:
*Understand the requirements of the story, work item, or feature that you are working on.
*Red:Create a test and make it fail.
Imagine how the new code should be called and write the test as if the code already existed.
Create the new production code stub. Write just enough code so that it compiles.
Run the test. It should fail. This is a calibration measure to ensure that your test is calling the correct code and that the code is not working by accident. This is a meaningful failure, and you expect it to fail.
*Green: Make the test pass by any means necessary.
Write the production code to make the test pass. Keep it simple.
Some advocate the hard-coding of the expected return value first to verify that the test correctly detects success. This varies from practitioner to practitioner.If you've written the code so that the test passes as intended, you are finished. You do not have to write more code speculatively. If new functionality is still needed, then another test is needed. Make this one test pass and continue.
When the test passes, you might want to run all tests up to this point to build confidence that everything else is still working.
*Refractor: Change the code to remove duplication in your project and to improve the design while ensuring that all tests still pass.
Remove duplication caused by the addition of the new functionality.
Make design changes to improve the overall solution.
After each refactoring, rerun all the tests to ensure that they all still pass.
*Repeat the cycle. Each cycle should be very short, and a typical hour should contain many Red/Green/ Refractor cycles.

=Examples=

==Homework Grades Program==

===Setup===
As a simple example, we are creating a program that keeps track of our homework grades. We envision that we would be able to get the average of these homework grades. Step one: write a test . Let's test an average function

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
assert(myHomework.average(myHomework.grades) == 75);
</pre>

We will get multiple errors - this test won't even compile (but, that's ok for now). Let's take a look at what will generate error messages:

* class <code>Homework</code> not declared
* <code>Homework</code> constructor not declared
* field <code>grades</code> not declared
* method <code>average</code> not declared

Now, we fix the first error:

<pre>
class Homework {

}
</pre>

Second error:

<pre>
Homework(void) {

}
</pre>

Third error:

<pre>
int * grades;
</pre>

Fourth error:

<pre>
int average(int * grades) {
return 0; // default return value
}
</pre>

Finally, the test compiles! The code now looks like this:

<pre>
class Homework {

int * grades;

Homework(void) {

}

int average(int * grades) {

return 0; // default return value

}

}
</pre>

===Red===
Now, we run the test, and the familar red bar of failure greets us (remember the mantra red-green-refactor). The assert fails. The average function needs to actually average something (not just return 0). As we think about averaging the grades, we realize we need to know how many grades are in the int array <code>grades</code>. So, we add to the code:

<pre>
class Homework {

int * grades;
int numGrades; // new

Homework(void) {

}

int average(int * grades) {

int avg = 0; // new

for(int i = 0; i < numGrades; i++) { // new
avg += grades[i]; // new
} // new

return avg/numGrades; // new

}

}
</pre>

Of course, we must remember to change the test to:

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
myHomework.numGrades = 2;
assert(myHomework.average(myHomework.grades) == 75);
</pre>

===Green===
Success! We have a green bar when we run it.

===Refactor===
The last step is refactoring. Perhaps we don't want a grade to be an <code>int</code>? Should it be an <code>unsigned int</code>? For this simple example, there isn't much refactoring to do, but in a larger example there may be multiple areas for improvement.

==Refactoring Example==
The following example is take from Test-Driven Development by Example by Kent Beck.

Using the TDD process the author created an object with the following structure:

<pre>
class Dollar {

Dollar(int amount) {
this.amount = amount;
}

void times(int mulitplier) {
amount *= multiplier;
}

}
</pre>

What's wrong with the code above? Look at the following test:

<pre>
public void testMultiplication() {

Dollar five = new Dollar(5);
five.times(2);
assertEquals(10, five.amount);
five.times(3);
assertEquals(15, five.amount);

}
</pre>

Whenever we perform an operation on a <code>Dollar</code> the value of the <code>Dollar</code> changes. In the test above <code>five</code> isn't 5 after we multiply it by 2, and thus the name <code>five</code> doesn't make sense anymore. How do we change this?

===Red===

First, we change the test.

<pre>
public void testMultiplication() {
Dollar five = new Dollar(5);
Dollar product = five.times(2);
assertEquals(10, product.amount);
product = five.times(3);
assertEquals(15, product.amount);
}
</pre>

The new test won't compile until we change the code:

<pre>
Dollar times(int multiplier) {
amount *= multiplier;
return null;
}
</pre>

Now the test compiles, but fails. Once again, we change the code:

<pre>
Dollar times(int multiplier) {
return new Dollar(amount * multiplier);
}
</pre>

===Green===

The test succeeds. So we see that even when we are refactoring we change the test first, then the code. This way we know our refactoring is an improvement.

==More Examples==
See Test-Driven Development by Example by Kent Beck for more examples.

=Characteristics Of A Good Unit Test=
A good unit test has the following characteristics.
*It is important that the test executes fast. If the tests are slow, they will not be run often.
*Environmental dependencies such as databases, file systems, networks, queues, and so on which will slow down the tests are either separated or simulated. Tests that exercise these will not run fast, and a failure does not give meaningful feedback about what the problem actually is.
*The scope of testing is very limited. If the test fails, it's obvious where to look for the problem. It's important to only test one aspect in a single test.
*The test should run and pass in isolation (on any machine). If the tests require special environmental setup or fail unexpectedly, then they are not good unit tests.
*Such a test often uses stubs and mock objects. If the code being tested typically calls out to a database or file system, these dependencies must be simulated, or mocked. These dependencies will ordinarily be abstracted away by using interfaces.
*The intention of testing is clearly revealed. Another developer can look at the test and understand what is expected of the production code.

=Benefits Of TDD=

Using TDD has many benefits.

*Automated testing: Automated system makes the testing much more easier and faster. Manual testing is slower and needs human interaction which is error-prone. Automated testing makes sure any particular test is not missing every time we test the system, whereas humans may leave a test out mistakenly during testing process.
*Better to test New/Modified Functionality: With manual testing whenever you add new functionality or modify existing functionality, QA personal needs to test all systems that may be affected due to the modification which may be time-consuming. This may also leave a hidden bug in the system after modification. With TDD whenever a new functionality is added or existing functionality is modified, the whole set of tests in the system is run to make sure existing tests are passed. This makes sure that existing functionality is not broken.
*Developer’s confidence: With TDD, developers are more safe to change the system as any inappropriate changes will make some tests to fail. With non-TDD system developers needs to take more care to change existing system as the new change may fail other functionality. But with TDD developers can do so easily as after modification if developer runs the test he/she will find immediately that the change has failed some other tests (i.e. some other part of the system).
*Manual testing stage is shortened: In non-TDD development, as soon as developers prepare a build, QA personal starts testing. This manual testing takes a reasonable amount of time and increases the time to deliver the product from the build time. With TDD, a major part of the system is tested during development and needs lesser QA involvement in the time between build and final delivery of the product.
*Alternative Documentation: Unit tests are kind of documentation to system. Each unit test tells about an individual requirement to the module or system. For example, the following test ensures that only a logged in user with proper balance can buy an item when the item exists in stock. This test reflects a user aspect scenario of the system.

public void CheckUserCanNotPurchaseItemWithoutBalance(){
LoginToTheSystem();
SelectAnItemToBuy();
MakeSureItemExsitsInStock();
MakeSureUserHasBalanceToBuy();
RunTheTransaction();
}
*Better way to fix bugs: In TDD approach when QA finds a bug, developer first writes a test that generates the bug (that is the test will fail due to this bug). Then developer modifies code to make sure that the test is passed (i.e., the bug is fixed). This approach makes sure that next time the bug will not appear in the system as a test is written in the system to take care of the bug.
*Repetition of the same bug reduced: With TDD once a bug is found, it's put under test. So every time you run the whole test in the system, the tests associated with the bug are run and make sure the bugs are not generated again.

=Shortcomings Of TDD=

TDD has a few shortcomings:

*The actual database or external file is never tested directly by TDD (only production code can test it)
*If not used carefully, it can add to the total project costs and complexity of the project
*TDD is unable to test UI.
*TDD is highly reliant on Refactoring and Programmer Skills.

=Conclusion=
Danielle
=References=
*[http://catalog.lib.ncsu.edu/record/NCSU1601963 Beck, K. (2002). Test-driven development by example. Addison-Wesley.]
*[http://en.wikipedia.org/wiki/Test_driven_development (n.d.). Test-driven development. website: http://en.wikipedia.org/wiki/Test_driven_development]
*[http://c2.com/cgi/wiki?TestDrivenDevelopment (2012, January 11). Test driven development. website: http://c2.com/cgi/wiki?TestDrivenDevelopment]
*[http://www.agiledata.org/essays/tdd.html Ambler, S. W. (2002). Introduction to test driven development (tdd). Retrieved from Agile Data website: http://www.agiledata.org/essays/tdd.html]
*[http://www.methodsandtools.com/archive/archive.php?id=20. Methods and Tools Archives]
*[http://www.martinfowler.com/bliki/TestDrivenDevelopment.html www.martinfowler.com/bliki/TestDrivenDevelopment]
*[http://www.codeproject.com/Articles/47747/Test-Driven-Development-TDD-Step-by-Step-Part-1-In TDD Step by Step Code Project]
*[http://integralpath.blogs.com/thinkingoutloud/2005/09/principles_of_t.html Principles of Testing]

CSC/ECE 517 Fall 2012/ch2a 2w11 aa

2012-10-25T16:57:13Z

Dmcarmon: /* Benefits Of TDD */

=Introduction=
Test driven development (TDD) is a process that tries to create the minimal amount of code to meet customer's expectations. The idea is to test first, code second, then improve (or refactor) last. This process forces the software developers to focus on customer specifications and validation first. Since at each step of the way the programmer proves to himself that the code meets specifications, TDD gives the programmer confidence. The rest of this chapter gives the motivation for TDD, shows the steps for TDD, outlines the principles of TDD, provides examples using TDD, and compares the pros and cons of TDD.

=Motivation for TDD=

There are two main motivations for TDD.

[[File:TimevsCostDev.png|350px|Thumb:Figure 1: Traditional "Cost of Change" curve with the waterfall model superimposed]]

*Testing is the one activity that improves the quality of code. In various design scenarios, like waterfall model, testing occurs towards the end of the project development activity. As shown in the figure 1, introducing testing as a latter phase increases the cost incurred for implementing the changes. From this we infer that there is a high chance of reducing the costs by moving the Test phase to the initial part.
*The client can also be well informed about the design and can suggest changes which can be incorporated well in advance. This approach also known as TDD helps achieve flexibility to achieve the client’s ever-changing requirements

=Principles=

TDD follows several principles:

*Tests serve as examples of how to use a class or method. Once used to having tests that show how things work (and that they work), developers start inquiring if a test was already there for the piece of code to be developed
*Developer tests are distinctly different from QA (Quality Analysis) tests and should be kept separate. QA tests target features and treat the system as a black box. Unit tests created by the developer operate at a lower level and test different things.
*Name the tests carefully. For Example, name test packages like the package being tested with a suffix. For example, the "DataAccess" project/package is tested by "DataAccess.Test". Also, name test classes the same as the class under test with the suffix "Test". For example, the class "PrintManager" is tested by the test class "PrintManagerTest". This convention makes it easy to find the related class and keeps the class name a noun. You should also name test methods the same as the method being tested with the prefix "Test". For example, the method "PrintProductOrder()" is tested by the method "TestPrintProductOrder()". This convention keeps the method name a verb that reads as an english phrase.
*Write each test before writing the method under test. It encourages the developer to think as a user of the target method before thinking about implementation, which usually results in a cleaner, easier-to-use interface.
*Follow the "3-As" pattern for test methods: Arrange, Act, Assert. Specifically, use separate code paragraphs (groups of lines of code separated by a blank line) for each of the As. Arrange is variable declaration and initialization. Act is invoking the code under test. Assert is using the Assert.* methods to verify that expectations were met.
*When writing application code, only write enough code to make a test work. This technique prevents gold-plating and ensures that you always have a test for the code you write.
*When you find you need to refractor working code, refractor and re-test prior to writing new code. This technique ensures your refractoring is correct prior to adding new functionality and applies to creating new methods, introducing inheritance, everything.

=Steps=

[[Image:PureFab.gif]]

Follow these steps:
*Understand the requirements of the story, work item, or feature that you are working on.
*Red:Create a test and make it fail.
Imagine how the new code should be called and write the test as if the code already existed.
Create the new production code stub. Write just enough code so that it compiles.
Run the test. It should fail. This is a calibration measure to ensure that your test is calling the correct code and that the code is not working by accident. This is a meaningful failure, and you expect it to fail.
*Green: Make the test pass by any means necessary.
Write the production code to make the test pass. Keep it simple.
Some advocate the hard-coding of the expected return value first to verify that the test correctly detects success. This varies from practitioner to practitioner.If you've written the code so that the test passes as intended, you are finished. You do not have to write more code speculatively. If new functionality is still needed, then another test is needed. Make this one test pass and continue.
When the test passes, you might want to run all tests up to this point to build confidence that everything else is still working.
*Refractor: Change the code to remove duplication in your project and to improve the design while ensuring that all tests still pass.
Remove duplication caused by the addition of the new functionality.
Make design changes to improve the overall solution.
After each refactoring, rerun all the tests to ensure that they all still pass.
*Repeat the cycle. Each cycle should be very short, and a typical hour should contain many Red/Green/ Refractor cycles.

=Examples=

==Homework Grades Program==

===Setup===
As a simple example, we are creating a program that keeps track of our homework grades. We envision that we would be able to get the average of these homework grades. Step one: write a test . Let's test an average function

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
assert(myHomework.average(myHomework.grades) == 75);
</pre>

We will get multiple errors - this test won't even compile (but, that's ok for now). Let's take a look at what will generate error messages:

* class <code>Homework</code> not declared
* <code>Homework</code> constructor not declared
* field <code>grades</code> not declared
* method <code>average</code> not declared

Now, we fix the first error:

<pre>
class Homework {

}
</pre>

Second error:

<pre>
Homework(void) {

}
</pre>

Third error:

<pre>
int * grades;
</pre>

Fourth error:

<pre>
int average(int * grades) {
return 0; // default return value
}
</pre>

Finally, the test compiles! The code now looks like this:

<pre>
class Homework {

int * grades;

Homework(void) {

}

int average(int * grades) {

return 0; // default return value

}

}
</pre>

===Red===
Now, we run the test, and the familar red bar of failure greets us (remember the mantra red-green-refactor). The assert fails. The average function needs to actually average something (not just return 0). As we think about averaging the grades, we realize we need to know how many grades are in the int array <code>grades</code>. So, we add to the code:

<pre>
class Homework {

int * grades;
int numGrades; // new

Homework(void) {

}

int average(int * grades) {

int avg = 0; // new

for(int i = 0; i < numGrades; i++) { // new
avg += grades[i]; // new
} // new

return avg/numGrades; // new

}

}
</pre>

Of course, we must remember to change the test to:

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
myHomework.numGrades = 2;
assert(myHomework.average(myHomework.grades) == 75);
</pre>

===Green===
Success! We have a green bar when we run it.

===Refactor===
The last step is refactoring. Perhaps we don't want a grade to be an <code>int</code>? Should it be an <code>unsigned int</code>? For this simple example, there isn't much refactoring to do, but in a larger example there may be multiple areas for improvement.

==Refactoring Example==
The following example is take from Test-Driven Development by Example by Kent Beck.

Using the TDD process the author created an object with the following structure:

<pre>
class Dollar {

Dollar(int amount) {
this.amount = amount;
}

void times(int mulitplier) {
amount *= multiplier;
}

}
</pre>

What's wrong with the code above? Look at the following test:

<pre>
public void testMultiplication() {

Dollar five = new Dollar(5);
five.times(2);
assertEquals(10, five.amount);
five.times(3);
assertEquals(15, five.amount);

}
</pre>

Whenever we perform an operation on a <code>Dollar</code> the value of the <code>Dollar</code> changes. In the test above <code>five</code> isn't 5 after we multiply it by 2, and thus the name <code>five</code> doesn't make sense anymore. How do we change this?

===Red===

First, we change the test.

<pre>
public void testMultiplication() {
Dollar five = new Dollar(5);
Dollar product = five.times(2);
assertEquals(10, product.amount);
product = five.times(3);
assertEquals(15, product.amount);
}
</pre>

The new test won't compile until we change the code:

<pre>
Dollar times(int multiplier) {
amount *= multiplier;
return null;
}
</pre>

Now the test compiles, but fails. Once again, we change the code:

<pre>
Dollar times(int multiplier) {
return new Dollar(amount * multiplier);
}
</pre>

===Green===

The test succeeds. So we see that even when we are refactoring we change the test first, then the code. This way we know our refactoring is an improvement.

==More Examples==
See Test-Driven Development by Example by Kent Beck for more examples.

=Characteristics Of A Good Unit Test=
A good unit test has the following characteristics.
*It is important that the test executes fast. If the tests are slow, they will not be run often.
*Environmental dependencies such as databases, file systems, networks, queues, and so on which will slow down the tests are either separated or simulated. Tests that exercise these will not run fast, and a failure does not give meaningful feedback about what the problem actually is.
*The scope of testing is very limited. If the test fails, it's obvious where to look for the problem. It's important to only test one aspect in a single test.
*The test should run and pass in isolation (on any machine). If the tests require special environmental setup or fail unexpectedly, then they are not good unit tests.
*Such a test often uses stubs and mock objects. If the code being tested typically calls out to a database or file system, these dependencies must be simulated, or mocked. These dependencies will ordinarily be abstracted away by using interfaces.
*The intention of testing is clearly revealed. Another developer can look at the test and understand what is expected of the production code.

=Benefits Of TDD=

Using TDD has many benefits.

*Automated testing: Automated system makes the testing much more easier and faster. Manual testing is slower and needs human interaction which is error-prone. Automated testing makes sure any particular test is not missing every time we test the system, whereas humans may leave a test out mistakenly during testing process.
*Better to test New/Modified Functionality: With manual testing whenever you add new functionality or modify existing functionality, QA personal needs to test all systems that may be affected due to the modification which may be time-consuming. This may also leave a hidden bug in the system after modification. With TDD whenever a new functionality is added or existing functionality is modified, the whole set of tests in the system is run to make sure existing tests are passed. This makes sure that existing functionality is not broken.
*Developer’s confidence: With TDD, developers are more safe to change the system as any inappropriate changes will make some tests to fail. With non-TDD system developers needs to take more care to change existing system as the new change may fail other functionality. But with TDD developers can do so easily as after modification if developer runs the test he/she will find immediately that the change has failed some other tests (i.e. some other part of the system).
*Manual testing stage is shortened: In non-TDD development, as soon as developers prepare a build, QA personal starts testing. This manual testing takes a reasonable amount of time and increases the time to deliver the product from the build time. With TDD, a major part of the system is tested during development and needs lesser QA involvement in the time between build and final delivery of the product.
*Alternative Documentation: Unit tests are kind of documentation to system. Each unit test tells about an individual requirement to the module or system. For example, the following test ensures that only a logged in user with proper balance can buy an item when the item exists in stock. This test reflects a user aspect scenario of the system.

public void CheckUserCanNotPurchaseItemWithoutBalance(){
LoginToTheSystem();
SelectAnItemToBuy();
MakeSureItemExsitsInStock();
MakeSureUserHasBalanceToBuy();
RunTheTransaction();
}
*Better way to fix bugs: In TDD approach when QA finds a bug, developer first writes a test that generates the bug (that is the test will fail due to this bug). Then developer modifies code to make sure that the test is passed (i.e., the bug is fixed). This approach makes sure that next time the bug will not appear in the system as a test is written in the system to take care of the bug.
*Repetition of the same bug reduced: With TDD once a bug is found, it's put under test. So every time you run the whole test in the system, the tests associated with the bug are run and make sure the bugs are not generated again.

=Shortcomings Of TDD=
*The actual database or external file is never tested directly by TDD (only production code can test it)
*If not used carefully, it can add to the total project costs and complexity of the project
*TDD is unable to test UI.
*TDD is highly reliant on Refactoring and Programmer Skills.

=Conclusion=
Danielle
=References=
*[http://catalog.lib.ncsu.edu/record/NCSU1601963 Beck, K. (2002). Test-driven development by example. Addison-Wesley.]
*[http://en.wikipedia.org/wiki/Test_driven_development (n.d.). Test-driven development. website: http://en.wikipedia.org/wiki/Test_driven_development]
*[http://c2.com/cgi/wiki?TestDrivenDevelopment (2012, January 11). Test driven development. website: http://c2.com/cgi/wiki?TestDrivenDevelopment]
*[http://www.agiledata.org/essays/tdd.html Ambler, S. W. (2002). Introduction to test driven development (tdd). Retrieved from Agile Data website: http://www.agiledata.org/essays/tdd.html]
*[http://www.methodsandtools.com/archive/archive.php?id=20. Methods and Tools Archives]
*[http://www.martinfowler.com/bliki/TestDrivenDevelopment.html www.martinfowler.com/bliki/TestDrivenDevelopment]
*[http://www.codeproject.com/Articles/47747/Test-Driven-Development-TDD-Step-by-Step-Part-1-In TDD Step by Step Code Project]
*[http://integralpath.blogs.com/thinkingoutloud/2005/09/principles_of_t.html Principles of Testing]

CSC/ECE 517 Fall 2012/ch2a 2w11 aa

2012-10-25T16:56:33Z

Dmcarmon: /* Principles */

=Introduction=
Test driven development (TDD) is a process that tries to create the minimal amount of code to meet customer's expectations. The idea is to test first, code second, then improve (or refactor) last. This process forces the software developers to focus on customer specifications and validation first. Since at each step of the way the programmer proves to himself that the code meets specifications, TDD gives the programmer confidence. The rest of this chapter gives the motivation for TDD, shows the steps for TDD, outlines the principles of TDD, provides examples using TDD, and compares the pros and cons of TDD.

=Motivation for TDD=

There are two main motivations for TDD.

[[File:TimevsCostDev.png|350px|Thumb:Figure 1: Traditional "Cost of Change" curve with the waterfall model superimposed]]

*Testing is the one activity that improves the quality of code. In various design scenarios, like waterfall model, testing occurs towards the end of the project development activity. As shown in the figure 1, introducing testing as a latter phase increases the cost incurred for implementing the changes. From this we infer that there is a high chance of reducing the costs by moving the Test phase to the initial part.
*The client can also be well informed about the design and can suggest changes which can be incorporated well in advance. This approach also known as TDD helps achieve flexibility to achieve the client’s ever-changing requirements

=Principles=

TDD follows several principles:

*Tests serve as examples of how to use a class or method. Once used to having tests that show how things work (and that they work), developers start inquiring if a test was already there for the piece of code to be developed
*Developer tests are distinctly different from QA (Quality Analysis) tests and should be kept separate. QA tests target features and treat the system as a black box. Unit tests created by the developer operate at a lower level and test different things.
*Name the tests carefully. For Example, name test packages like the package being tested with a suffix. For example, the "DataAccess" project/package is tested by "DataAccess.Test". Also, name test classes the same as the class under test with the suffix "Test". For example, the class "PrintManager" is tested by the test class "PrintManagerTest". This convention makes it easy to find the related class and keeps the class name a noun. You should also name test methods the same as the method being tested with the prefix "Test". For example, the method "PrintProductOrder()" is tested by the method "TestPrintProductOrder()". This convention keeps the method name a verb that reads as an english phrase.
*Write each test before writing the method under test. It encourages the developer to think as a user of the target method before thinking about implementation, which usually results in a cleaner, easier-to-use interface.
*Follow the "3-As" pattern for test methods: Arrange, Act, Assert. Specifically, use separate code paragraphs (groups of lines of code separated by a blank line) for each of the As. Arrange is variable declaration and initialization. Act is invoking the code under test. Assert is using the Assert.* methods to verify that expectations were met.
*When writing application code, only write enough code to make a test work. This technique prevents gold-plating and ensures that you always have a test for the code you write.
*When you find you need to refractor working code, refractor and re-test prior to writing new code. This technique ensures your refractoring is correct prior to adding new functionality and applies to creating new methods, introducing inheritance, everything.

=Steps=

[[Image:PureFab.gif]]

Follow these steps:
*Understand the requirements of the story, work item, or feature that you are working on.
*Red:Create a test and make it fail.
Imagine how the new code should be called and write the test as if the code already existed.
Create the new production code stub. Write just enough code so that it compiles.
Run the test. It should fail. This is a calibration measure to ensure that your test is calling the correct code and that the code is not working by accident. This is a meaningful failure, and you expect it to fail.
*Green: Make the test pass by any means necessary.
Write the production code to make the test pass. Keep it simple.
Some advocate the hard-coding of the expected return value first to verify that the test correctly detects success. This varies from practitioner to practitioner.If you've written the code so that the test passes as intended, you are finished. You do not have to write more code speculatively. If new functionality is still needed, then another test is needed. Make this one test pass and continue.
When the test passes, you might want to run all tests up to this point to build confidence that everything else is still working.
*Refractor: Change the code to remove duplication in your project and to improve the design while ensuring that all tests still pass.
Remove duplication caused by the addition of the new functionality.
Make design changes to improve the overall solution.
After each refactoring, rerun all the tests to ensure that they all still pass.
*Repeat the cycle. Each cycle should be very short, and a typical hour should contain many Red/Green/ Refractor cycles.

=Examples=

==Homework Grades Program==

===Setup===
As a simple example, we are creating a program that keeps track of our homework grades. We envision that we would be able to get the average of these homework grades. Step one: write a test . Let's test an average function

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
assert(myHomework.average(myHomework.grades) == 75);
</pre>

We will get multiple errors - this test won't even compile (but, that's ok for now). Let's take a look at what will generate error messages:

* class <code>Homework</code> not declared
* <code>Homework</code> constructor not declared
* field <code>grades</code> not declared
* method <code>average</code> not declared

Now, we fix the first error:

<pre>
class Homework {

}
</pre>

Second error:

<pre>
Homework(void) {

}
</pre>

Third error:

<pre>
int * grades;
</pre>

Fourth error:

<pre>
int average(int * grades) {
return 0; // default return value
}
</pre>

Finally, the test compiles! The code now looks like this:

<pre>
class Homework {

int * grades;

Homework(void) {

}

int average(int * grades) {

return 0; // default return value

}

}
</pre>

===Red===
Now, we run the test, and the familar red bar of failure greets us (remember the mantra red-green-refactor). The assert fails. The average function needs to actually average something (not just return 0). As we think about averaging the grades, we realize we need to know how many grades are in the int array <code>grades</code>. So, we add to the code:

<pre>
class Homework {

int * grades;
int numGrades; // new

Homework(void) {

}

int average(int * grades) {

int avg = 0; // new

for(int i = 0; i < numGrades; i++) { // new
avg += grades[i]; // new
} // new

return avg/numGrades; // new

}

}
</pre>

Of course, we must remember to change the test to:

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
myHomework.numGrades = 2;
assert(myHomework.average(myHomework.grades) == 75);
</pre>

===Green===
Success! We have a green bar when we run it.

===Refactor===
The last step is refactoring. Perhaps we don't want a grade to be an <code>int</code>? Should it be an <code>unsigned int</code>? For this simple example, there isn't much refactoring to do, but in a larger example there may be multiple areas for improvement.

==Refactoring Example==
The following example is take from Test-Driven Development by Example by Kent Beck.

Using the TDD process the author created an object with the following structure:

<pre>
class Dollar {

Dollar(int amount) {
this.amount = amount;
}

void times(int mulitplier) {
amount *= multiplier;
}

}
</pre>

What's wrong with the code above? Look at the following test:

<pre>
public void testMultiplication() {

Dollar five = new Dollar(5);
five.times(2);
assertEquals(10, five.amount);
five.times(3);
assertEquals(15, five.amount);

}
</pre>

Whenever we perform an operation on a <code>Dollar</code> the value of the <code>Dollar</code> changes. In the test above <code>five</code> isn't 5 after we multiply it by 2, and thus the name <code>five</code> doesn't make sense anymore. How do we change this?

===Red===

First, we change the test.

<pre>
public void testMultiplication() {
Dollar five = new Dollar(5);
Dollar product = five.times(2);
assertEquals(10, product.amount);
product = five.times(3);
assertEquals(15, product.amount);
}
</pre>

The new test won't compile until we change the code:

<pre>
Dollar times(int multiplier) {
amount *= multiplier;
return null;
}
</pre>

Now the test compiles, but fails. Once again, we change the code:

<pre>
Dollar times(int multiplier) {
return new Dollar(amount * multiplier);
}
</pre>

===Green===

The test succeeds. So we see that even when we are refactoring we change the test first, then the code. This way we know our refactoring is an improvement.

==More Examples==
See Test-Driven Development by Example by Kent Beck for more examples.

=Characteristics Of A Good Unit Test=
A good unit test has the following characteristics.
*It is important that the test executes fast. If the tests are slow, they will not be run often.
*Environmental dependencies such as databases, file systems, networks, queues, and so on which will slow down the tests are either separated or simulated. Tests that exercise these will not run fast, and a failure does not give meaningful feedback about what the problem actually is.
*The scope of testing is very limited. If the test fails, it's obvious where to look for the problem. It's important to only test one aspect in a single test.
*The test should run and pass in isolation (on any machine). If the tests require special environmental setup or fail unexpectedly, then they are not good unit tests.
*Such a test often uses stubs and mock objects. If the code being tested typically calls out to a database or file system, these dependencies must be simulated, or mocked. These dependencies will ordinarily be abstracted away by using interfaces.
*The intention of testing is clearly revealed. Another developer can look at the test and understand what is expected of the production code.

=Benefits Of TDD=
*Automated testing: Automated system makes the testing much more easier and faster. Manual testing is slower and needs human interaction which is error-prone. Automated testing makes sure any particular test is not missing every time we test the system, whereas humans may leave a test out mistakenly during testing process.
*Better to test New/Modified Functionality: With manual testing whenever you add new functionality or modify existing functionality, QA personal needs to test all systems that may be affected due to the modification which may be time-consuming. This may also leave a hidden bug in the system after modification. With TDD whenever a new functionality is added or existing functionality is modified, the whole set of tests in the system is run to make sure existing tests are passed. This makes sure that existing functionality is not broken.
*Developer’s confidence: With TDD, developers are more safe to change the system as any inappropriate changes will make some tests to fail. With non-TDD system developers needs to take more care to change existing system as the new change may fail other functionality. But with TDD developers can do so easily as after modification if developer runs the test he/she will find immediately that the change has failed some other tests (i.e. some other part of the system).
*Manual testing stage is shortened: In non-TDD development, as soon as developers prepare a build, QA personal starts testing. This manual testing takes a reasonable amount of time and increases the time to deliver the product from the build time. With TDD, a major part of the system is tested during development and needs lesser QA involvement in the time between build and final delivery of the product.
*Alternative Documentation: Unit tests are kind of documentation to system. Each unit test tells about an individual requirement to the module or system. For example, the following test ensures that only a logged in user with proper balance can buy an item when the item exists in stock. This test reflects a user aspect scenario of the system.

public void CheckUserCanNotPurchaseItemWithoutBalance(){
LoginToTheSystem();
SelectAnItemToBuy();
MakeSureItemExsitsInStock();
MakeSureUserHasBalanceToBuy();
RunTheTransaction();
}
*Better way to fix bugs: In TDD approach when QA finds a bug, developer first writes a test that generates the bug (that is the test will fail due to this bug). Then developer modifies code to make sure that the test is passed (i.e., the bug is fixed). This approach makes sure that next time the bug will not appear in the system as a test is written in the system to take care of the bug.
*Repetition of the same bug reduced: With TDD once a bug is found, it's put under test. So every time you run the whole test in the system, the tests associated with the bug are run and make sure the bugs are not generated again.

=Shortcomings Of TDD=
*The actual database or external file is never tested directly by TDD (only production code can test it)
*If not used carefully, it can add to the total project costs and complexity of the project
*TDD is unable to test UI.
*TDD is highly reliant on Refactoring and Programmer Skills.

=Conclusion=
Danielle
=References=
*[http://catalog.lib.ncsu.edu/record/NCSU1601963 Beck, K. (2002). Test-driven development by example. Addison-Wesley.]
*[http://en.wikipedia.org/wiki/Test_driven_development (n.d.). Test-driven development. website: http://en.wikipedia.org/wiki/Test_driven_development]
*[http://c2.com/cgi/wiki?TestDrivenDevelopment (2012, January 11). Test driven development. website: http://c2.com/cgi/wiki?TestDrivenDevelopment]
*[http://www.agiledata.org/essays/tdd.html Ambler, S. W. (2002). Introduction to test driven development (tdd). Retrieved from Agile Data website: http://www.agiledata.org/essays/tdd.html]
*[http://www.methodsandtools.com/archive/archive.php?id=20. Methods and Tools Archives]
*[http://www.martinfowler.com/bliki/TestDrivenDevelopment.html www.martinfowler.com/bliki/TestDrivenDevelopment]
*[http://www.codeproject.com/Articles/47747/Test-Driven-Development-TDD-Step-by-Step-Part-1-In TDD Step by Step Code Project]
*[http://integralpath.blogs.com/thinkingoutloud/2005/09/principles_of_t.html Principles of Testing]

CSC/ECE 517 Fall 2012/ch2a 2w11 aa

2012-10-25T16:56:08Z

Dmcarmon: /* Motivation for TDD */

=Introduction=
Test driven development (TDD) is a process that tries to create the minimal amount of code to meet customer's expectations. The idea is to test first, code second, then improve (or refactor) last. This process forces the software developers to focus on customer specifications and validation first. Since at each step of the way the programmer proves to himself that the code meets specifications, TDD gives the programmer confidence. The rest of this chapter gives the motivation for TDD, shows the steps for TDD, outlines the principles of TDD, provides examples using TDD, and compares the pros and cons of TDD.

=Motivation for TDD=

There are two main motivations for TDD.

[[File:TimevsCostDev.png|350px|Thumb:Figure 1: Traditional "Cost of Change" curve with the waterfall model superimposed]]

*Testing is the one activity that improves the quality of code. In various design scenarios, like waterfall model, testing occurs towards the end of the project development activity. As shown in the figure 1, introducing testing as a latter phase increases the cost incurred for implementing the changes. From this we infer that there is a high chance of reducing the costs by moving the Test phase to the initial part.
*The client can also be well informed about the design and can suggest changes which can be incorporated well in advance. This approach also known as TDD helps achieve flexibility to achieve the client’s ever-changing requirements

=Principles=
*Tests serve as examples of how to use a class or method. Once used to having tests that show how things work (and that they work), developers start inquiring if a test was already there for the piece of code to be developed
*Developer tests are distinctly different from QA (Quality Analysis) tests and should be kept separate. QA tests target features and treat the system as a black box. Unit tests created by the developer operate at a lower level and test different things.
*Name the tests carefully. For Example, name test packages like the package being tested with a suffix. For example, the "DataAccess" project/package is tested by "DataAccess.Test". Also, name test classes the same as the class under test with the suffix "Test". For example, the class "PrintManager" is tested by the test class "PrintManagerTest". This convention makes it easy to find the related class and keeps the class name a noun. You should also name test methods the same as the method being tested with the prefix "Test". For example, the method "PrintProductOrder()" is tested by the method "TestPrintProductOrder()". This convention keeps the method name a verb that reads as an english phrase.
*Write each test before writing the method under test. It encourages the developer to think as a user of the target method before thinking about implementation, which usually results in a cleaner, easier-to-use interface.
*Follow the "3-As" pattern for test methods: Arrange, Act, Assert. Specifically, use separate code paragraphs (groups of lines of code separated by a blank line) for each of the As. Arrange is variable declaration and initialization. Act is invoking the code under test. Assert is using the Assert.* methods to verify that expectations were met.
*When writing application code, only write enough code to make a test work. This technique prevents gold-plating and ensures that you always have a test for the code you write.
*When you find you need to refractor working code, refractor and re-test prior to writing new code. This technique ensures your refractoring is correct prior to adding new functionality and applies to creating new methods, introducing inheritance, everything.
=Steps=

[[Image:PureFab.gif]]

Follow these steps:
*Understand the requirements of the story, work item, or feature that you are working on.
*Red:Create a test and make it fail.
Imagine how the new code should be called and write the test as if the code already existed.
Create the new production code stub. Write just enough code so that it compiles.
Run the test. It should fail. This is a calibration measure to ensure that your test is calling the correct code and that the code is not working by accident. This is a meaningful failure, and you expect it to fail.
*Green: Make the test pass by any means necessary.
Write the production code to make the test pass. Keep it simple.
Some advocate the hard-coding of the expected return value first to verify that the test correctly detects success. This varies from practitioner to practitioner.If you've written the code so that the test passes as intended, you are finished. You do not have to write more code speculatively. If new functionality is still needed, then another test is needed. Make this one test pass and continue.
When the test passes, you might want to run all tests up to this point to build confidence that everything else is still working.
*Refractor: Change the code to remove duplication in your project and to improve the design while ensuring that all tests still pass.
Remove duplication caused by the addition of the new functionality.
Make design changes to improve the overall solution.
After each refactoring, rerun all the tests to ensure that they all still pass.
*Repeat the cycle. Each cycle should be very short, and a typical hour should contain many Red/Green/ Refractor cycles.

=Examples=

==Homework Grades Program==

===Setup===
As a simple example, we are creating a program that keeps track of our homework grades. We envision that we would be able to get the average of these homework grades. Step one: write a test . Let's test an average function

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
assert(myHomework.average(myHomework.grades) == 75);
</pre>

We will get multiple errors - this test won't even compile (but, that's ok for now). Let's take a look at what will generate error messages:

* class <code>Homework</code> not declared
* <code>Homework</code> constructor not declared
* field <code>grades</code> not declared
* method <code>average</code> not declared

Now, we fix the first error:

<pre>
class Homework {

}
</pre>

Second error:

<pre>
Homework(void) {

}
</pre>

Third error:

<pre>
int * grades;
</pre>

Fourth error:

<pre>
int average(int * grades) {
return 0; // default return value
}
</pre>

Finally, the test compiles! The code now looks like this:

<pre>
class Homework {

int * grades;

Homework(void) {

}

int average(int * grades) {

return 0; // default return value

}

}
</pre>

===Red===
Now, we run the test, and the familar red bar of failure greets us (remember the mantra red-green-refactor). The assert fails. The average function needs to actually average something (not just return 0). As we think about averaging the grades, we realize we need to know how many grades are in the int array <code>grades</code>. So, we add to the code:

<pre>
class Homework {

int * grades;
int numGrades; // new

Homework(void) {

}

int average(int * grades) {

int avg = 0; // new

for(int i = 0; i < numGrades; i++) { // new
avg += grades[i]; // new
} // new

return avg/numGrades; // new

}

}
</pre>

Of course, we must remember to change the test to:

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
myHomework.numGrades = 2;
assert(myHomework.average(myHomework.grades) == 75);
</pre>

===Green===
Success! We have a green bar when we run it.

===Refactor===
The last step is refactoring. Perhaps we don't want a grade to be an <code>int</code>? Should it be an <code>unsigned int</code>? For this simple example, there isn't much refactoring to do, but in a larger example there may be multiple areas for improvement.

==Refactoring Example==
The following example is take from Test-Driven Development by Example by Kent Beck.

Using the TDD process the author created an object with the following structure:

<pre>
class Dollar {

Dollar(int amount) {
this.amount = amount;
}

void times(int mulitplier) {
amount *= multiplier;
}

}
</pre>

What's wrong with the code above? Look at the following test:

<pre>
public void testMultiplication() {

Dollar five = new Dollar(5);
five.times(2);
assertEquals(10, five.amount);
five.times(3);
assertEquals(15, five.amount);

}
</pre>

Whenever we perform an operation on a <code>Dollar</code> the value of the <code>Dollar</code> changes. In the test above <code>five</code> isn't 5 after we multiply it by 2, and thus the name <code>five</code> doesn't make sense anymore. How do we change this?

===Red===

First, we change the test.

<pre>
public void testMultiplication() {
Dollar five = new Dollar(5);
Dollar product = five.times(2);
assertEquals(10, product.amount);
product = five.times(3);
assertEquals(15, product.amount);
}
</pre>

The new test won't compile until we change the code:

<pre>
Dollar times(int multiplier) {
amount *= multiplier;
return null;
}
</pre>

Now the test compiles, but fails. Once again, we change the code:

<pre>
Dollar times(int multiplier) {
return new Dollar(amount * multiplier);
}
</pre>

===Green===

The test succeeds. So we see that even when we are refactoring we change the test first, then the code. This way we know our refactoring is an improvement.

==More Examples==
See Test-Driven Development by Example by Kent Beck for more examples.

=Characteristics Of A Good Unit Test=
A good unit test has the following characteristics.
*It is important that the test executes fast. If the tests are slow, they will not be run often.
*Environmental dependencies such as databases, file systems, networks, queues, and so on which will slow down the tests are either separated or simulated. Tests that exercise these will not run fast, and a failure does not give meaningful feedback about what the problem actually is.
*The scope of testing is very limited. If the test fails, it's obvious where to look for the problem. It's important to only test one aspect in a single test.
*The test should run and pass in isolation (on any machine). If the tests require special environmental setup or fail unexpectedly, then they are not good unit tests.
*Such a test often uses stubs and mock objects. If the code being tested typically calls out to a database or file system, these dependencies must be simulated, or mocked. These dependencies will ordinarily be abstracted away by using interfaces.
*The intention of testing is clearly revealed. Another developer can look at the test and understand what is expected of the production code.

=Benefits Of TDD=
*Automated testing: Automated system makes the testing much more easier and faster. Manual testing is slower and needs human interaction which is error-prone. Automated testing makes sure any particular test is not missing every time we test the system, whereas humans may leave a test out mistakenly during testing process.
*Better to test New/Modified Functionality: With manual testing whenever you add new functionality or modify existing functionality, QA personal needs to test all systems that may be affected due to the modification which may be time-consuming. This may also leave a hidden bug in the system after modification. With TDD whenever a new functionality is added or existing functionality is modified, the whole set of tests in the system is run to make sure existing tests are passed. This makes sure that existing functionality is not broken.
*Developer’s confidence: With TDD, developers are more safe to change the system as any inappropriate changes will make some tests to fail. With non-TDD system developers needs to take more care to change existing system as the new change may fail other functionality. But with TDD developers can do so easily as after modification if developer runs the test he/she will find immediately that the change has failed some other tests (i.e. some other part of the system).
*Manual testing stage is shortened: In non-TDD development, as soon as developers prepare a build, QA personal starts testing. This manual testing takes a reasonable amount of time and increases the time to deliver the product from the build time. With TDD, a major part of the system is tested during development and needs lesser QA involvement in the time between build and final delivery of the product.
*Alternative Documentation: Unit tests are kind of documentation to system. Each unit test tells about an individual requirement to the module or system. For example, the following test ensures that only a logged in user with proper balance can buy an item when the item exists in stock. This test reflects a user aspect scenario of the system.

public void CheckUserCanNotPurchaseItemWithoutBalance(){
LoginToTheSystem();
SelectAnItemToBuy();
MakeSureItemExsitsInStock();
MakeSureUserHasBalanceToBuy();
RunTheTransaction();
}
*Better way to fix bugs: In TDD approach when QA finds a bug, developer first writes a test that generates the bug (that is the test will fail due to this bug). Then developer modifies code to make sure that the test is passed (i.e., the bug is fixed). This approach makes sure that next time the bug will not appear in the system as a test is written in the system to take care of the bug.
*Repetition of the same bug reduced: With TDD once a bug is found, it's put under test. So every time you run the whole test in the system, the tests associated with the bug are run and make sure the bugs are not generated again.

=Shortcomings Of TDD=
*The actual database or external file is never tested directly by TDD (only production code can test it)
*If not used carefully, it can add to the total project costs and complexity of the project
*TDD is unable to test UI.
*TDD is highly reliant on Refactoring and Programmer Skills.

=Conclusion=
Danielle
=References=
*[http://catalog.lib.ncsu.edu/record/NCSU1601963 Beck, K. (2002). Test-driven development by example. Addison-Wesley.]
*[http://en.wikipedia.org/wiki/Test_driven_development (n.d.). Test-driven development. website: http://en.wikipedia.org/wiki/Test_driven_development]
*[http://c2.com/cgi/wiki?TestDrivenDevelopment (2012, January 11). Test driven development. website: http://c2.com/cgi/wiki?TestDrivenDevelopment]
*[http://www.agiledata.org/essays/tdd.html Ambler, S. W. (2002). Introduction to test driven development (tdd). Retrieved from Agile Data website: http://www.agiledata.org/essays/tdd.html]
*[http://www.methodsandtools.com/archive/archive.php?id=20. Methods and Tools Archives]
*[http://www.martinfowler.com/bliki/TestDrivenDevelopment.html www.martinfowler.com/bliki/TestDrivenDevelopment]
*[http://www.codeproject.com/Articles/47747/Test-Driven-Development-TDD-Step-by-Step-Part-1-In TDD Step by Step Code Project]
*[http://integralpath.blogs.com/thinkingoutloud/2005/09/principles_of_t.html Principles of Testing]

CSC/ECE 517 Fall 2012/ch2a 2w11 aa

2012-10-25T16:54:57Z

Dmcarmon: /* References */

=Introduction=
Test driven development (TDD) is a process that tries to create the minimal amount of code to meet customer's expectations. The idea is to test first, code second, then improve (or refactor) last. This process forces the software developers to focus on customer specifications and validation first. Since at each step of the way the programmer proves to himself that the code meets specifications, TDD gives the programmer confidence. The rest of this chapter gives the motivation for TDD, shows the steps for TDD, outlines the principles of TDD, provides examples using TDD, and compares the pros and cons of TDD.

=Motivation for TDD=
[[File:TimevsCostDev.png|350px|Thumb:Figure 1: Traditional "Cost of Change" curve with the waterfall model superimposed]]

*Testing is the one activity that improves the quality of code. In various design scenarios, like waterfall model, testing occurs towards the end of the project development activity. As shown in the figure 1, introducing testing as a latter phase increases the cost incurred for implementing the changes. From this we infer that there is a high chance of reducing the costs by moving the Test phase to the initial part.
*The client can also be well informed about the design and can suggest changes which can be incorporated well in advance. This approach also known as TDD helps achieve flexibility to achieve the client’s ever-changing requirements

=Principles=
*Tests serve as examples of how to use a class or method. Once used to having tests that show how things work (and that they work), developers start inquiring if a test was already there for the piece of code to be developed
*Developer tests are distinctly different from QA (Quality Analysis) tests and should be kept separate. QA tests target features and treat the system as a black box. Unit tests created by the developer operate at a lower level and test different things.
*Name the tests carefully. For Example, name test packages like the package being tested with a suffix. For example, the "DataAccess" project/package is tested by "DataAccess.Test". Also, name test classes the same as the class under test with the suffix "Test". For example, the class "PrintManager" is tested by the test class "PrintManagerTest". This convention makes it easy to find the related class and keeps the class name a noun. You should also name test methods the same as the method being tested with the prefix "Test". For example, the method "PrintProductOrder()" is tested by the method "TestPrintProductOrder()". This convention keeps the method name a verb that reads as an english phrase.
*Write each test before writing the method under test. It encourages the developer to think as a user of the target method before thinking about implementation, which usually results in a cleaner, easier-to-use interface.
*Follow the "3-As" pattern for test methods: Arrange, Act, Assert. Specifically, use separate code paragraphs (groups of lines of code separated by a blank line) for each of the As. Arrange is variable declaration and initialization. Act is invoking the code under test. Assert is using the Assert.* methods to verify that expectations were met.
*When writing application code, only write enough code to make a test work. This technique prevents gold-plating and ensures that you always have a test for the code you write.
*When you find you need to refractor working code, refractor and re-test prior to writing new code. This technique ensures your refractoring is correct prior to adding new functionality and applies to creating new methods, introducing inheritance, everything.
=Steps=

[[Image:PureFab.gif]]

Follow these steps:
*Understand the requirements of the story, work item, or feature that you are working on.
*Red:Create a test and make it fail.
Imagine how the new code should be called and write the test as if the code already existed.
Create the new production code stub. Write just enough code so that it compiles.
Run the test. It should fail. This is a calibration measure to ensure that your test is calling the correct code and that the code is not working by accident. This is a meaningful failure, and you expect it to fail.
*Green: Make the test pass by any means necessary.
Write the production code to make the test pass. Keep it simple.
Some advocate the hard-coding of the expected return value first to verify that the test correctly detects success. This varies from practitioner to practitioner.If you've written the code so that the test passes as intended, you are finished. You do not have to write more code speculatively. If new functionality is still needed, then another test is needed. Make this one test pass and continue.
When the test passes, you might want to run all tests up to this point to build confidence that everything else is still working.
*Refractor: Change the code to remove duplication in your project and to improve the design while ensuring that all tests still pass.
Remove duplication caused by the addition of the new functionality.
Make design changes to improve the overall solution.
After each refactoring, rerun all the tests to ensure that they all still pass.
*Repeat the cycle. Each cycle should be very short, and a typical hour should contain many Red/Green/ Refractor cycles.

=Examples=

==Homework Grades Program==

===Setup===
As a simple example, we are creating a program that keeps track of our homework grades. We envision that we would be able to get the average of these homework grades. Step one: write a test . Let's test an average function

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
assert(myHomework.average(myHomework.grades) == 75);
</pre>

We will get multiple errors - this test won't even compile (but, that's ok for now). Let's take a look at what will generate error messages:

* class <code>Homework</code> not declared
* <code>Homework</code> constructor not declared
* field <code>grades</code> not declared
* method <code>average</code> not declared

Now, we fix the first error:

<pre>
class Homework {

}
</pre>

Second error:

<pre>
Homework(void) {

}
</pre>

Third error:

<pre>
int * grades;
</pre>

Fourth error:

<pre>
int average(int * grades) {
return 0; // default return value
}
</pre>

Finally, the test compiles! The code now looks like this:

<pre>
class Homework {

int * grades;

Homework(void) {

}

int average(int * grades) {

return 0; // default return value

}

}
</pre>

===Red===
Now, we run the test, and the familar red bar of failure greets us (remember the mantra red-green-refactor). The assert fails. The average function needs to actually average something (not just return 0). As we think about averaging the grades, we realize we need to know how many grades are in the int array <code>grades</code>. So, we add to the code:

<pre>
class Homework {

int * grades;
int numGrades; // new

Homework(void) {

}

int average(int * grades) {

int avg = 0; // new

for(int i = 0; i < numGrades; i++) { // new
avg += grades[i]; // new
} // new

return avg/numGrades; // new

}

}
</pre>

Of course, we must remember to change the test to:

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
myHomework.numGrades = 2;
assert(myHomework.average(myHomework.grades) == 75);
</pre>

===Green===
Success! We have a green bar when we run it.

===Refactor===
The last step is refactoring. Perhaps we don't want a grade to be an <code>int</code>? Should it be an <code>unsigned int</code>? For this simple example, there isn't much refactoring to do, but in a larger example there may be multiple areas for improvement.

==Refactoring Example==
The following example is take from Test-Driven Development by Example by Kent Beck.

Using the TDD process the author created an object with the following structure:

<pre>
class Dollar {

Dollar(int amount) {
this.amount = amount;
}

void times(int mulitplier) {
amount *= multiplier;
}

}
</pre>

What's wrong with the code above? Look at the following test:

<pre>
public void testMultiplication() {

Dollar five = new Dollar(5);
five.times(2);
assertEquals(10, five.amount);
five.times(3);
assertEquals(15, five.amount);

}
</pre>

Whenever we perform an operation on a <code>Dollar</code> the value of the <code>Dollar</code> changes. In the test above <code>five</code> isn't 5 after we multiply it by 2, and thus the name <code>five</code> doesn't make sense anymore. How do we change this?

===Red===

First, we change the test.

<pre>
public void testMultiplication() {
Dollar five = new Dollar(5);
Dollar product = five.times(2);
assertEquals(10, product.amount);
product = five.times(3);
assertEquals(15, product.amount);
}
</pre>

The new test won't compile until we change the code:

<pre>
Dollar times(int multiplier) {
amount *= multiplier;
return null;
}
</pre>

Now the test compiles, but fails. Once again, we change the code:

<pre>
Dollar times(int multiplier) {
return new Dollar(amount * multiplier);
}
</pre>

===Green===

The test succeeds. So we see that even when we are refactoring we change the test first, then the code. This way we know our refactoring is an improvement.

==More Examples==
See Test-Driven Development by Example by Kent Beck for more examples.

=Characteristics Of A Good Unit Test=
A good unit test has the following characteristics.
*It is important that the test executes fast. If the tests are slow, they will not be run often.
*Environmental dependencies such as databases, file systems, networks, queues, and so on which will slow down the tests are either separated or simulated. Tests that exercise these will not run fast, and a failure does not give meaningful feedback about what the problem actually is.
*The scope of testing is very limited. If the test fails, it's obvious where to look for the problem. It's important to only test one aspect in a single test.
*The test should run and pass in isolation (on any machine). If the tests require special environmental setup or fail unexpectedly, then they are not good unit tests.
*Such a test often uses stubs and mock objects. If the code being tested typically calls out to a database or file system, these dependencies must be simulated, or mocked. These dependencies will ordinarily be abstracted away by using interfaces.
*The intention of testing is clearly revealed. Another developer can look at the test and understand what is expected of the production code.

=Benefits Of TDD=
*Automated testing: Automated system makes the testing much more easier and faster. Manual testing is slower and needs human interaction which is error-prone. Automated testing makes sure any particular test is not missing every time we test the system, whereas humans may leave a test out mistakenly during testing process.
*Better to test New/Modified Functionality: With manual testing whenever you add new functionality or modify existing functionality, QA personal needs to test all systems that may be affected due to the modification which may be time-consuming. This may also leave a hidden bug in the system after modification. With TDD whenever a new functionality is added or existing functionality is modified, the whole set of tests in the system is run to make sure existing tests are passed. This makes sure that existing functionality is not broken.
*Developer’s confidence: With TDD, developers are more safe to change the system as any inappropriate changes will make some tests to fail. With non-TDD system developers needs to take more care to change existing system as the new change may fail other functionality. But with TDD developers can do so easily as after modification if developer runs the test he/she will find immediately that the change has failed some other tests (i.e. some other part of the system).
*Manual testing stage is shortened: In non-TDD development, as soon as developers prepare a build, QA personal starts testing. This manual testing takes a reasonable amount of time and increases the time to deliver the product from the build time. With TDD, a major part of the system is tested during development and needs lesser QA involvement in the time between build and final delivery of the product.
*Alternative Documentation: Unit tests are kind of documentation to system. Each unit test tells about an individual requirement to the module or system. For example, the following test ensures that only a logged in user with proper balance can buy an item when the item exists in stock. This test reflects a user aspect scenario of the system.

public void CheckUserCanNotPurchaseItemWithoutBalance(){
LoginToTheSystem();
SelectAnItemToBuy();
MakeSureItemExsitsInStock();
MakeSureUserHasBalanceToBuy();
RunTheTransaction();
}
*Better way to fix bugs: In TDD approach when QA finds a bug, developer first writes a test that generates the bug (that is the test will fail due to this bug). Then developer modifies code to make sure that the test is passed (i.e., the bug is fixed). This approach makes sure that next time the bug will not appear in the system as a test is written in the system to take care of the bug.
*Repetition of the same bug reduced: With TDD once a bug is found, it's put under test. So every time you run the whole test in the system, the tests associated with the bug are run and make sure the bugs are not generated again.

=Shortcomings Of TDD=
*The actual database or external file is never tested directly by TDD (only production code can test it)
*If not used carefully, it can add to the total project costs and complexity of the project
*TDD is unable to test UI.
*TDD is highly reliant on Refactoring and Programmer Skills.

=Conclusion=
Danielle
=References=
*[http://catalog.lib.ncsu.edu/record/NCSU1601963 Beck, K. (2002). Test-driven development by example. Addison-Wesley.]
*[http://en.wikipedia.org/wiki/Test_driven_development (n.d.). Test-driven development. website: http://en.wikipedia.org/wiki/Test_driven_development]
*[http://c2.com/cgi/wiki?TestDrivenDevelopment (2012, January 11). Test driven development. website: http://c2.com/cgi/wiki?TestDrivenDevelopment]
*[http://www.agiledata.org/essays/tdd.html Ambler, S. W. (2002). Introduction to test driven development (tdd). Retrieved from Agile Data website: http://www.agiledata.org/essays/tdd.html]
*[http://www.methodsandtools.com/archive/archive.php?id=20. Methods and Tools Archives]
*[http://www.martinfowler.com/bliki/TestDrivenDevelopment.html www.martinfowler.com/bliki/TestDrivenDevelopment]
*[http://www.codeproject.com/Articles/47747/Test-Driven-Development-TDD-Step-by-Step-Part-1-In TDD Step by Step Code Project]
*[http://integralpath.blogs.com/thinkingoutloud/2005/09/principles_of_t.html Principles of Testing]

CSC/ECE 517 Fall 2012/ch2a 2w11 aa

2012-10-25T16:54:11Z

Dmcarmon: /* Introduction */

=Introduction=
Test driven development (TDD) is a process that tries to create the minimal amount of code to meet customer's expectations. The idea is to test first, code second, then improve (or refactor) last. This process forces the software developers to focus on customer specifications and validation first. Since at each step of the way the programmer proves to himself that the code meets specifications, TDD gives the programmer confidence. The rest of this chapter gives the motivation for TDD, shows the steps for TDD, outlines the principles of TDD, provides examples using TDD, and compares the pros and cons of TDD.

=Motivation for TDD=
[[File:TimevsCostDev.png|350px|Thumb:Figure 1: Traditional "Cost of Change" curve with the waterfall model superimposed]]

*Testing is the one activity that improves the quality of code. In various design scenarios, like waterfall model, testing occurs towards the end of the project development activity. As shown in the figure 1, introducing testing as a latter phase increases the cost incurred for implementing the changes. From this we infer that there is a high chance of reducing the costs by moving the Test phase to the initial part.
*The client can also be well informed about the design and can suggest changes which can be incorporated well in advance. This approach also known as TDD helps achieve flexibility to achieve the client’s ever-changing requirements

=Principles=
*Tests serve as examples of how to use a class or method. Once used to having tests that show how things work (and that they work), developers start inquiring if a test was already there for the piece of code to be developed
*Developer tests are distinctly different from QA (Quality Analysis) tests and should be kept separate. QA tests target features and treat the system as a black box. Unit tests created by the developer operate at a lower level and test different things.
*Name the tests carefully. For Example, name test packages like the package being tested with a suffix. For example, the "DataAccess" project/package is tested by "DataAccess.Test". Also, name test classes the same as the class under test with the suffix "Test". For example, the class "PrintManager" is tested by the test class "PrintManagerTest". This convention makes it easy to find the related class and keeps the class name a noun. You should also name test methods the same as the method being tested with the prefix "Test". For example, the method "PrintProductOrder()" is tested by the method "TestPrintProductOrder()". This convention keeps the method name a verb that reads as an english phrase.
*Write each test before writing the method under test. It encourages the developer to think as a user of the target method before thinking about implementation, which usually results in a cleaner, easier-to-use interface.
*Follow the "3-As" pattern for test methods: Arrange, Act, Assert. Specifically, use separate code paragraphs (groups of lines of code separated by a blank line) for each of the As. Arrange is variable declaration and initialization. Act is invoking the code under test. Assert is using the Assert.* methods to verify that expectations were met.
*When writing application code, only write enough code to make a test work. This technique prevents gold-plating and ensures that you always have a test for the code you write.
*When you find you need to refractor working code, refractor and re-test prior to writing new code. This technique ensures your refractoring is correct prior to adding new functionality and applies to creating new methods, introducing inheritance, everything.
=Steps=

[[Image:PureFab.gif]]

Follow these steps:
*Understand the requirements of the story, work item, or feature that you are working on.
*Red:Create a test and make it fail.
Imagine how the new code should be called and write the test as if the code already existed.
Create the new production code stub. Write just enough code so that it compiles.
Run the test. It should fail. This is a calibration measure to ensure that your test is calling the correct code and that the code is not working by accident. This is a meaningful failure, and you expect it to fail.
*Green: Make the test pass by any means necessary.
Write the production code to make the test pass. Keep it simple.
Some advocate the hard-coding of the expected return value first to verify that the test correctly detects success. This varies from practitioner to practitioner.If you've written the code so that the test passes as intended, you are finished. You do not have to write more code speculatively. If new functionality is still needed, then another test is needed. Make this one test pass and continue.
When the test passes, you might want to run all tests up to this point to build confidence that everything else is still working.
*Refractor: Change the code to remove duplication in your project and to improve the design while ensuring that all tests still pass.
Remove duplication caused by the addition of the new functionality.
Make design changes to improve the overall solution.
After each refactoring, rerun all the tests to ensure that they all still pass.
*Repeat the cycle. Each cycle should be very short, and a typical hour should contain many Red/Green/ Refractor cycles.

=Examples=

==Homework Grades Program==

===Setup===
As a simple example, we are creating a program that keeps track of our homework grades. We envision that we would be able to get the average of these homework grades. Step one: write a test . Let's test an average function

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
assert(myHomework.average(myHomework.grades) == 75);
</pre>

We will get multiple errors - this test won't even compile (but, that's ok for now). Let's take a look at what will generate error messages:

* class <code>Homework</code> not declared
* <code>Homework</code> constructor not declared
* field <code>grades</code> not declared
* method <code>average</code> not declared

Now, we fix the first error:

<pre>
class Homework {

}
</pre>

Second error:

<pre>
Homework(void) {

}
</pre>

Third error:

<pre>
int * grades;
</pre>

Fourth error:

<pre>
int average(int * grades) {
return 0; // default return value
}
</pre>

Finally, the test compiles! The code now looks like this:

<pre>
class Homework {

int * grades;

Homework(void) {

}

int average(int * grades) {

return 0; // default return value

}

}
</pre>

===Red===
Now, we run the test, and the familar red bar of failure greets us (remember the mantra red-green-refactor). The assert fails. The average function needs to actually average something (not just return 0). As we think about averaging the grades, we realize we need to know how many grades are in the int array <code>grades</code>. So, we add to the code:

<pre>
class Homework {

int * grades;
int numGrades; // new

Homework(void) {

}

int average(int * grades) {

int avg = 0; // new

for(int i = 0; i < numGrades; i++) { // new
avg += grades[i]; // new
} // new

return avg/numGrades; // new

}

}
</pre>

Of course, we must remember to change the test to:

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
myHomework.numGrades = 2;
assert(myHomework.average(myHomework.grades) == 75);
</pre>

===Green===
Success! We have a green bar when we run it.

===Refactor===
The last step is refactoring. Perhaps we don't want a grade to be an <code>int</code>? Should it be an <code>unsigned int</code>? For this simple example, there isn't much refactoring to do, but in a larger example there may be multiple areas for improvement.

==Refactoring Example==
The following example is take from Test-Driven Development by Example by Kent Beck.

Using the TDD process the author created an object with the following structure:

<pre>
class Dollar {

Dollar(int amount) {
this.amount = amount;
}

void times(int mulitplier) {
amount *= multiplier;
}

}
</pre>

What's wrong with the code above? Look at the following test:

<pre>
public void testMultiplication() {

Dollar five = new Dollar(5);
five.times(2);
assertEquals(10, five.amount);
five.times(3);
assertEquals(15, five.amount);

}
</pre>

Whenever we perform an operation on a <code>Dollar</code> the value of the <code>Dollar</code> changes. In the test above <code>five</code> isn't 5 after we multiply it by 2, and thus the name <code>five</code> doesn't make sense anymore. How do we change this?

===Red===

First, we change the test.

<pre>
public void testMultiplication() {
Dollar five = new Dollar(5);
Dollar product = five.times(2);
assertEquals(10, product.amount);
product = five.times(3);
assertEquals(15, product.amount);
}
</pre>

The new test won't compile until we change the code:

<pre>
Dollar times(int multiplier) {
amount *= multiplier;
return null;
}
</pre>

Now the test compiles, but fails. Once again, we change the code:

<pre>
Dollar times(int multiplier) {
return new Dollar(amount * multiplier);
}
</pre>

===Green===

The test succeeds. So we see that even when we are refactoring we change the test first, then the code. This way we know our refactoring is an improvement.

==More Examples==
See Test-Driven Development by Example by Kent Beck for more examples.

=Characteristics Of A Good Unit Test=
A good unit test has the following characteristics.
*It is important that the test executes fast. If the tests are slow, they will not be run often.
*Environmental dependencies such as databases, file systems, networks, queues, and so on which will slow down the tests are either separated or simulated. Tests that exercise these will not run fast, and a failure does not give meaningful feedback about what the problem actually is.
*The scope of testing is very limited. If the test fails, it's obvious where to look for the problem. It's important to only test one aspect in a single test.
*The test should run and pass in isolation (on any machine). If the tests require special environmental setup or fail unexpectedly, then they are not good unit tests.
*Such a test often uses stubs and mock objects. If the code being tested typically calls out to a database or file system, these dependencies must be simulated, or mocked. These dependencies will ordinarily be abstracted away by using interfaces.
*The intention of testing is clearly revealed. Another developer can look at the test and understand what is expected of the production code.

=Benefits Of TDD=
*Automated testing: Automated system makes the testing much more easier and faster. Manual testing is slower and needs human interaction which is error-prone. Automated testing makes sure any particular test is not missing every time we test the system, whereas humans may leave a test out mistakenly during testing process.
*Better to test New/Modified Functionality: With manual testing whenever you add new functionality or modify existing functionality, QA personal needs to test all systems that may be affected due to the modification which may be time-consuming. This may also leave a hidden bug in the system after modification. With TDD whenever a new functionality is added or existing functionality is modified, the whole set of tests in the system is run to make sure existing tests are passed. This makes sure that existing functionality is not broken.
*Developer’s confidence: With TDD, developers are more safe to change the system as any inappropriate changes will make some tests to fail. With non-TDD system developers needs to take more care to change existing system as the new change may fail other functionality. But with TDD developers can do so easily as after modification if developer runs the test he/she will find immediately that the change has failed some other tests (i.e. some other part of the system).
*Manual testing stage is shortened: In non-TDD development, as soon as developers prepare a build, QA personal starts testing. This manual testing takes a reasonable amount of time and increases the time to deliver the product from the build time. With TDD, a major part of the system is tested during development and needs lesser QA involvement in the time between build and final delivery of the product.
*Alternative Documentation: Unit tests are kind of documentation to system. Each unit test tells about an individual requirement to the module or system. For example, the following test ensures that only a logged in user with proper balance can buy an item when the item exists in stock. This test reflects a user aspect scenario of the system.

public void CheckUserCanNotPurchaseItemWithoutBalance(){
LoginToTheSystem();
SelectAnItemToBuy();
MakeSureItemExsitsInStock();
MakeSureUserHasBalanceToBuy();
RunTheTransaction();
}
*Better way to fix bugs: In TDD approach when QA finds a bug, developer first writes a test that generates the bug (that is the test will fail due to this bug). Then developer modifies code to make sure that the test is passed (i.e., the bug is fixed). This approach makes sure that next time the bug will not appear in the system as a test is written in the system to take care of the bug.
*Repetition of the same bug reduced: With TDD once a bug is found, it's put under test. So every time you run the whole test in the system, the tests associated with the bug are run and make sure the bugs are not generated again.

=Shortcomings Of TDD=
*The actual database or external file is never tested directly by TDD (only production code can test it)
*If not used carefully, it can add to the total project costs and complexity of the project
*TDD is unable to test UI.
*TDD is highly reliant on Refactoring and Programmer Skills.

=Conclusion=
Danielle
=References=
*[http://catalog.lib.ncsu.edu/record/NCSU1601963 Beck, K. (2002). Test-driven development by example. Addison-Wesley.]
*[http://en.wikipedia.org/wiki/Test_driven_development (n.d.). Test-driven development. website: http://en.wikipedia.org/wiki/Test_driven_development]
*[http://c2.com/cgi/wiki?TestDrivenDevelopment (2012, January 11). Test driven development. website: http://c2.com/cgi/wiki?TestDrivenDevelopment]
*[http://www.agiledata.org/essays/tdd.html Ambler, S. W. (2002). Introduction to test driven development (tdd). Retrieved from Agile Data website: http://www.agiledata.org/essays/tdd.html]
*[http://www.methodsandtools.com/archive/archive.php?id=20. Methods and Tools Archives]
*[http://www.martinfowler.com/bliki/TestDrivenDevelopment.html www.martinfowler.com/bliki/TestDrivenDevelopment]
*[http://www.codeproject.com/Articles/47747/Test-Driven-Development-TDD-Step-by-Step-Part-1-In TDD Step by Step Code Project]
*[http://integralpath.blogs.com/thinkingoutloud/2005/09/principles_of_t.html Principles of Testing]
*http://www.testdriven.com/ ?

CSC/ECE 517 Fall 2012/ch2a 2w11 aa

2012-10-25T16:51:25Z

Dmcarmon: /* Examples */

=Introduction=
Test driven development (TDD) is a process that tries to create the minimal amount of code to meet customer's expectations. The idea is to test first, code second, then improve (or refactor) last. This process forces the software developers to focus on customer specifications and validation first. Since at each step of the way the programmer proves to himself that the code meets specifications, TDD gives the programmer confidence. The rest of this chapter gives the motivation for TDD, shows the steps for TDD, outlines the principles of TDD, and provides examples using TDD.

=Motivation for TDD=
[[File:TimevsCostDev.png|350px|Thumb:Figure 1: Traditional "Cost of Change" curve with the waterfall model superimposed]]

*Testing is the one activity that improves the quality of code. In various design scenarios, like waterfall model, testing occurs towards the end of the project development activity. As shown in the figure 1, introducing testing as a latter phase increases the cost incurred for implementing the changes. From this we infer that there is a high chance of reducing the costs by moving the Test phase to the initial part.
*The client can also be well informed about the design and can suggest changes which can be incorporated well in advance. This approach also known as TDD helps achieve flexibility to achieve the client’s ever-changing requirements

=Principles=
*Tests serve as examples of how to use a class or method. Once used to having tests that show how things work (and that they work), developers start inquiring if a test was already there for the piece of code to be developed
*Developer tests are distinctly different from QA (Quality Analysis) tests and should be kept separate. QA tests target features and treat the system as a black box. Unit tests created by the developer operate at a lower level and test different things.
*Name the tests carefully. For Example, name test packages like the package being tested with a suffix. For example, the "DataAccess" project/package is tested by "DataAccess.Test". Also, name test classes the same as the class under test with the suffix "Test". For example, the class "PrintManager" is tested by the test class "PrintManagerTest". This convention makes it easy to find the related class and keeps the class name a noun. You should also name test methods the same as the method being tested with the prefix "Test". For example, the method "PrintProductOrder()" is tested by the method "TestPrintProductOrder()". This convention keeps the method name a verb that reads as an english phrase.
*Write each test before writing the method under test. It encourages the developer to think as a user of the target method before thinking about implementation, which usually results in a cleaner, easier-to-use interface.
*Follow the "3-As" pattern for test methods: Arrange, Act, Assert. Specifically, use separate code paragraphs (groups of lines of code separated by a blank line) for each of the As. Arrange is variable declaration and initialization. Act is invoking the code under test. Assert is using the Assert.* methods to verify that expectations were met.
*When writing application code, only write enough code to make a test work. This technique prevents gold-plating and ensures that you always have a test for the code you write.
*When you find you need to refractor working code, refractor and re-test prior to writing new code. This technique ensures your refractoring is correct prior to adding new functionality and applies to creating new methods, introducing inheritance, everything.
=Steps=

[[Image:PureFab.gif]]

Follow these steps:
*Understand the requirements of the story, work item, or feature that you are working on.
*Red:Create a test and make it fail.
Imagine how the new code should be called and write the test as if the code already existed.
Create the new production code stub. Write just enough code so that it compiles.
Run the test. It should fail. This is a calibration measure to ensure that your test is calling the correct code and that the code is not working by accident. This is a meaningful failure, and you expect it to fail.
*Green: Make the test pass by any means necessary.
Write the production code to make the test pass. Keep it simple.
Some advocate the hard-coding of the expected return value first to verify that the test correctly detects success. This varies from practitioner to practitioner.If you've written the code so that the test passes as intended, you are finished. You do not have to write more code speculatively. If new functionality is still needed, then another test is needed. Make this one test pass and continue.
When the test passes, you might want to run all tests up to this point to build confidence that everything else is still working.
*Refractor: Change the code to remove duplication in your project and to improve the design while ensuring that all tests still pass.
Remove duplication caused by the addition of the new functionality.
Make design changes to improve the overall solution.
After each refactoring, rerun all the tests to ensure that they all still pass.
*Repeat the cycle. Each cycle should be very short, and a typical hour should contain many Red/Green/ Refractor cycles.

=Examples=

==Homework Grades Program==

===Setup===
As a simple example, we are creating a program that keeps track of our homework grades. We envision that we would be able to get the average of these homework grades. Step one: write a test . Let's test an average function

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
assert(myHomework.average(myHomework.grades) == 75);
</pre>

We will get multiple errors - this test won't even compile (but, that's ok for now). Let's take a look at what will generate error messages:

* class <code>Homework</code> not declared
* <code>Homework</code> constructor not declared
* field <code>grades</code> not declared
* method <code>average</code> not declared

Now, we fix the first error:

<pre>
class Homework {

}
</pre>

Second error:

<pre>
Homework(void) {

}
</pre>

Third error:

<pre>
int * grades;
</pre>

Fourth error:

<pre>
int average(int * grades) {
return 0; // default return value
}
</pre>

Finally, the test compiles! The code now looks like this:

<pre>
class Homework {

int * grades;

Homework(void) {

}

int average(int * grades) {

return 0; // default return value

}

}
</pre>

===Red===
Now, we run the test, and the familar red bar of failure greets us (remember the mantra red-green-refactor). The assert fails. The average function needs to actually average something (not just return 0). As we think about averaging the grades, we realize we need to know how many grades are in the int array <code>grades</code>. So, we add to the code:

<pre>
class Homework {

int * grades;
int numGrades; // new

Homework(void) {

}

int average(int * grades) {

int avg = 0; // new

for(int i = 0; i < numGrades; i++) { // new
avg += grades[i]; // new
} // new

return avg/numGrades; // new

}

}
</pre>

Of course, we must remember to change the test to:

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
myHomework.numGrades = 2;
assert(myHomework.average(myHomework.grades) == 75);
</pre>

===Green===
Success! We have a green bar when we run it.

===Refactor===
The last step is refactoring. Perhaps we don't want a grade to be an <code>int</code>? Should it be an <code>unsigned int</code>? For this simple example, there isn't much refactoring to do, but in a larger example there may be multiple areas for improvement.

==Refactoring Example==
The following example is take from Test-Driven Development by Example by Kent Beck.

Using the TDD process the author created an object with the following structure:

<pre>
class Dollar {

Dollar(int amount) {
this.amount = amount;
}

void times(int mulitplier) {
amount *= multiplier;
}

}
</pre>

What's wrong with the code above? Look at the following test:

<pre>
public void testMultiplication() {

Dollar five = new Dollar(5);
five.times(2);
assertEquals(10, five.amount);
five.times(3);
assertEquals(15, five.amount);

}
</pre>

Whenever we perform an operation on a <code>Dollar</code> the value of the <code>Dollar</code> changes. In the test above <code>five</code> isn't 5 after we multiply it by 2, and thus the name <code>five</code> doesn't make sense anymore. How do we change this?

===Red===

First, we change the test.

<pre>
public void testMultiplication() {
Dollar five = new Dollar(5);
Dollar product = five.times(2);
assertEquals(10, product.amount);
product = five.times(3);
assertEquals(15, product.amount);
}
</pre>

The new test won't compile until we change the code:

<pre>
Dollar times(int multiplier) {
amount *= multiplier;
return null;
}
</pre>

Now the test compiles, but fails. Once again, we change the code:

<pre>
Dollar times(int multiplier) {
return new Dollar(amount * multiplier);
}
</pre>

===Green===

The test succeeds. So we see that even when we are refactoring we change the test first, then the code. This way we know our refactoring is an improvement.

==More Examples==
See Test-Driven Development by Example by Kent Beck for more examples.

=Characteristics Of A Good Unit Test=
A good unit test has the following characteristics.
*It is important that the test executes fast. If the tests are slow, they will not be run often.
*Environmental dependencies such as databases, file systems, networks, queues, and so on which will slow down the tests are either separated or simulated. Tests that exercise these will not run fast, and a failure does not give meaningful feedback about what the problem actually is.
*The scope of testing is very limited. If the test fails, it's obvious where to look for the problem. It's important to only test one aspect in a single test.
*The test should run and pass in isolation (on any machine). If the tests require special environmental setup or fail unexpectedly, then they are not good unit tests.
*Such a test often uses stubs and mock objects. If the code being tested typically calls out to a database or file system, these dependencies must be simulated, or mocked. These dependencies will ordinarily be abstracted away by using interfaces.
*The intention of testing is clearly revealed. Another developer can look at the test and understand what is expected of the production code.

=Benefits Of TDD=
*Automated testing: Automated system makes the testing much more easier and faster. Manual testing is slower and needs human interaction which is error-prone. Automated testing makes sure any particular test is not missing every time we test the system, whereas humans may leave a test out mistakenly during testing process.
*Better to test New/Modified Functionality: With manual testing whenever you add new functionality or modify existing functionality, QA personal needs to test all systems that may be affected due to the modification which may be time-consuming. This may also leave a hidden bug in the system after modification. With TDD whenever a new functionality is added or existing functionality is modified, the whole set of tests in the system is run to make sure existing tests are passed. This makes sure that existing functionality is not broken.
*Developer’s confidence: With TDD, developers are more safe to change the system as any inappropriate changes will make some tests to fail. With non-TDD system developers needs to take more care to change existing system as the new change may fail other functionality. But with TDD developers can do so easily as after modification if developer runs the test he/she will find immediately that the change has failed some other tests (i.e. some other part of the system).
*Manual testing stage is shortened: In non-TDD development, as soon as developers prepare a build, QA personal starts testing. This manual testing takes a reasonable amount of time and increases the time to deliver the product from the build time. With TDD, a major part of the system is tested during development and needs lesser QA involvement in the time between build and final delivery of the product.
*Alternative Documentation: Unit tests are kind of documentation to system. Each unit test tells about an individual requirement to the module or system. For example, the following test ensures that only a logged in user with proper balance can buy an item when the item exists in stock. This test reflects a user aspect scenario of the system.

public void CheckUserCanNotPurchaseItemWithoutBalance(){
LoginToTheSystem();
SelectAnItemToBuy();
MakeSureItemExsitsInStock();
MakeSureUserHasBalanceToBuy();
RunTheTransaction();
}
*Better way to fix bugs: In TDD approach when QA finds a bug, developer first writes a test that generates the bug (that is the test will fail due to this bug). Then developer modifies code to make sure that the test is passed (i.e., the bug is fixed). This approach makes sure that next time the bug will not appear in the system as a test is written in the system to take care of the bug.
*Repetition of the same bug reduced: With TDD once a bug is found, it's put under test. So every time you run the whole test in the system, the tests associated with the bug are run and make sure the bugs are not generated again.

=Shortcomings Of TDD=
*The actual database or external file is never tested directly by TDD (only production code can test it)
*If not used carefully, it can add to the total project costs and complexity of the project
*TDD is unable to test UI.
*TDD is highly reliant on Refactoring and Programmer Skills.

=Conclusion=
Danielle
=References=
*[http://catalog.lib.ncsu.edu/record/NCSU1601963 Beck, K. (2002). Test-driven development by example. Addison-Wesley.]
*[http://en.wikipedia.org/wiki/Test_driven_development (n.d.). Test-driven development. website: http://en.wikipedia.org/wiki/Test_driven_development]
*[http://c2.com/cgi/wiki?TestDrivenDevelopment (2012, January 11). Test driven development. website: http://c2.com/cgi/wiki?TestDrivenDevelopment]
*[http://www.agiledata.org/essays/tdd.html Ambler, S. W. (2002). Introduction to test driven development (tdd). Retrieved from Agile Data website: http://www.agiledata.org/essays/tdd.html]
*[http://www.methodsandtools.com/archive/archive.php?id=20. Methods and Tools Archives]
*[http://www.martinfowler.com/bliki/TestDrivenDevelopment.html www.martinfowler.com/bliki/TestDrivenDevelopment]
*[http://www.codeproject.com/Articles/47747/Test-Driven-Development-TDD-Step-by-Step-Part-1-In TDD Step by Step Code Project]
*[http://integralpath.blogs.com/thinkingoutloud/2005/09/principles_of_t.html Principles of Testing]
*http://www.testdriven.com/ ?

CSC/ECE 517 Fall 2012/ch2a 2w11 aa

2012-10-22T15:41:12Z

Dmcarmon: /* Examples */

=Introduction=
Test driven development (TDD) is a process that tries to create the minimal amount of code to meet customer's expectations. The idea is to test first, code second, then improve (or refactor) last. This process forces the software developers to focus on customer specifications and validation first. Since at each step of the way the programmer proves to himself that the code meets specifications, TDD gives the programmer confidence. The rest of this chapter gives the motivation for TDD, shows the steps for TDD, outlines the principles of TDD, and provides examples using TDD.

=Motivation for TDD=
Annice
=Steps=
Annice
=Principles=
Annice
=Examples=

==Homework Grades Program==

===Setup===
As a simple example, we are creating a program that keeps track of our homework grades. We envision that we would be able to get the average of these homework grades. Step one: write a test . Let's test an average function

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
assert(myHomework.average(myHomework.grades) == 75);
</pre>

We will get multiple errors - this test won't even compile (but, that's ok for now). Let's take a look at what will generate error messages:

* class <code>Homework</code> not declared
* <code>Homework</code> constructor not declared
* field <code>grades</code> not declared
* method <code>average</code> not declared

Now, we fix the first error:

<pre>
class Homework {

}
</pre>

Second error:

<pre>
Homework(void) {

}
</pre>

Third error:

<pre>
int * grades;
</pre>

Fourth error:

<pre>
int average(int * grades) {
return 0; // default return value
}
</pre>

Finally, the test compiles! The code now looks like this:

<pre>
class Homework {

int * grades;

Homework(void) {

}

int average(int * grades) {

return 0; // default return value

}

}
</pre>

===Red===
Now, we run the test, and the familar red bar of failure greets us (remember the mantra red-green-refactor). The assert fails. The average function needs to actually average something (not just return 0). As we think about averaging the grades, we realize we need to know how many grades are in the int array <code>grades</code>. So, we add to the code:

<pre>
class Homework {

int * grades;
int numGrades; // new

Homework(void) {

}

int average(int * grades) {

int avg = 0; // new

for(int i = 0; i < numGrades; i++) { // new
avg += grades[i]; // new
} // new

return avg/numGrades; // new

}

}
</pre>

Of course, we must remember to change the test to:

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
myHomework.numGrades = 2;
assert(myHomework.average(myHomework.grades) == 75);
</pre>

===Green===
Success! We have a green bar when we run it.

===Refactor===
The last step is refactoring. Perhaps we don't want a grade to be an <code>int</code>? Should it be an <code>unsigned int</code>? For this simple example, there isn't much refactoring to do, but in a larger example there may be multiple areas for improvement.

==More Examples==
See Test-Driven Development by Example by Kent Beck for more examples.

=Conclusion=
Danielle
=References=
*[http://catalog.lib.ncsu.edu/record/NCSU1601963 Beck, K. (2002). Test-driven development by example. Addison-Wesley.]
*[http://en.wikipedia.org/wiki/Test_driven_development (n.d.). Test-driven development. website: http://en.wikipedia.org/wiki/Test_driven_development]
*[http://c2.com/cgi/wiki?TestDrivenDevelopment (2012, January 11). Test driven development. website: http://c2.com/cgi/wiki?TestDrivenDevelopment]
*[http://www.agiledata.org/essays/tdd.html Ambler, S. W. (2002). Introduction to test driven development (tdd). Retrieved from Agile Data website: http://www.agiledata.org/essays/tdd.html]
*http://www.testdriven.com/ ?

CSC/ECE 517 Fall 2012/ch2a 2w11 aa

2012-10-22T15:14:39Z

Dmcarmon: /* Examples */

=Introduction=
Test driven development (TDD) is a process that tries to create the minimal amount of code to meet customer's expectations. The idea is to test first, code second, then improve (or refactor) last. This process forces the software developers to focus on customer specifications and validation first. Since at each step of the way the programmer proves to himself that the code meets specifications, TDD gives the programmer confidence. The rest of this chapter gives the motivation for TDD, shows the steps for TDD, outlines the principles of TDD, and provides examples using TDD.

=Motivation for TDD=
Annice
=Steps=
Annice
=Principles=
Annice
=Examples=

==Homework Grades Program==

===Setup===
As a simple example, we are creating a program that keeps track of our homework grades. We envision that we would be able to get the average of these homework grades. Step one: write a test . Let's test an average function

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
assert(myHomework.average(myHomework.grades) == 75);
</pre>

We will get multiple errors - this test won't even compile (but, that's ok for now). Let's take a look at what will generate error messages:

* class <code>Homework</code> not declared
* <code>Homework</code> constructor not declared
* field <code>grades</code> not declared
* method <code>average</code> not declared

Now, we fix the first error:

<pre>
class Homework {

}
</pre>

Second error:

<pre>
Homework(void) {

}
</pre>

Third error:

<pre>
int * grades;
</pre>

Fourth error:

<pre>
int average(int * grades) {
return 0; // default return value
}
</pre>

Finally, the test compiles! The code now looks like this:

<pre>
class Homework {

int * grades;

Homework(void) {

}

int average(int * grades) {

return 0; // default return value

}

}
</pre>

===Red===
Now, we run the test, and the familar red bar of failure greets us (remember the mantra red-green-refactor). The assert fails. The average function needs to actually average something (not just return 0). As we think about averaging the grades, we realize we need to know how many grades are in the int array <code>grades</code>. So, we add to the code:

<pre>
class Homework {

int * grades;
int numGrades; // new

Homework(void) {

}

int average(int * grades) {

int avg = 0; // new

for(int i = 0; i < numGrades; i++) { // new
avg += grades[i]; // new
} // new

return avg/numGrades; // new

}

}
</pre>

Of course, we must remember to change the test to:

<pre>
myHomework = new Homework();
myHomework.grades = [100, 50];
myHomework.numGrades = 2;
assert(myHomework.average(myHomework.grades) == 75);
</pre>

===Green===
Success! We have a green bar when we run it.

===Refactor===
The last step is refactoring. Perhaps we don't want a grade to be an <code>int</code>? Should it be an <code>unsigned int</code>? For this simple example, there isn't much refactoring to do, but in a larger example there may be multiple areas for improvement.

=Conclusion=
Danielle
=References=
*[http://catalog.lib.ncsu.edu/record/NCSU1601963 Beck, K. (2002). Test-driven development by example. Addison-Wesley.]
*[http://en.wikipedia.org/wiki/Test_driven_development (n.d.). Test-driven development. website: http://en.wikipedia.org/wiki/Test_driven_development]
*[http://c2.com/cgi/wiki?TestDrivenDevelopment (2012, January 11). Test driven development. website: http://c2.com/cgi/wiki?TestDrivenDevelopment]
*[http://www.agiledata.org/essays/tdd.html Ambler, S. W. (2002). Introduction to test driven development (tdd). Retrieved from Agile Data website: http://www.agiledata.org/essays/tdd.html]
*http://www.testdriven.com/ ?

CSC/ECE 517 Fall 2012/ch2a 2w11 aa

2012-10-22T14:08:01Z

Dmcarmon: /* References */

=Introduction=
Test driven development (TDD) is a process that tries to create the minimal amount of code to meet customer's expectations. The idea is to test first, code second, then improve (or refactor) last. This process forces the software developers to focus on customer specifications and validation first. Since at each step of the way the programmer proves to himself that the code meets specifications, TDD gives the programmer confidence. The rest of this chapter gives the motivation for TDD, shows the steps for TDD, outlines the principles of TDD, and provides examples using TDD.

=Motivation for TDD=
Annice
=Steps=
Annice
=Principles=
Annice
=Examples=
Danielle
=Conclusion=
Danielle
=References=
*[http://catalog.lib.ncsu.edu/record/NCSU1601963 Beck, K. (2002). Test-driven development by example. Addison-Wesley.]
*[http://en.wikipedia.org/wiki/Test_driven_development (n.d.). Test-driven development. website: http://en.wikipedia.org/wiki/Test_driven_development]
*[http://c2.com/cgi/wiki?TestDrivenDevelopment (2012, January 11). Test driven development. website: http://c2.com/cgi/wiki?TestDrivenDevelopment]
*[http://www.agiledata.org/essays/tdd.html Ambler, S. W. (2002). Introduction to test driven development (tdd). Retrieved from Agile Data website: http://www.agiledata.org/essays/tdd.html]
*http://www.testdriven.com/ ?

CSC/ECE 517 Fall 2012/ch2a 2w11 aa

2012-10-22T13:45:27Z

Dmcarmon: /* Introduction */

=Introduction=
Test driven development (TDD) is a process that tries to create the minimal amount of code to meet customer's expectations. The idea is to test first, code second, then improve (or refactor) last. This process forces the software developers to focus on customer specifications and validation first. Since at each step of the way the programmer proves to himself that the code meets specifications, TDD gives the programmer confidence. The rest of this chapter gives the motivation for TDD, shows the steps for TDD, outlines the principles of TDD, and provides examples using TDD.

=Motivation for TDD=
Annice
=Steps=
Annice
=Principles=
Annice
=Examples=
Danielle
=Conclusion=
Danielle
=References=

CSC/ECE 517 Fall 2012

2012-10-22T13:24:59Z

Dmcarmon:

*[[CSC/ECE 517 Fall 2012/ch1 n xx]]
*[[CSC/ECE 517 Fall 2012/ch1 1w1 rk]]
*[[CSC/ECE 517 Fall 2012/ch1 1w20 pp]]
*[[CSC/ECE 517 Fall 2012/ch1 1w5 su]]
*[[CSC/ECE 517 Fall 2012/ch1 1w6 pp]]
*[[CSC/ECE 517 Fall 2012/ch1 1w4 aj]]
*[[CSC/ECE 517 Fall 2012/ch1 1w7 am]]
*[[CSC/ECE 517 Fall 2012/ch1 1w8 aa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w9 av]]
*[[CSC/ECE 517 Fall 2012/ch1 1w10 pk]]
*[[CSC/ECE 517 Fall 2012/ch1 1w11 ap]]
*[[CSC/ECE 517 Fall 2012/ch1a 1w12 mv]]
*[[CSC/ECE 517 Fall 2012/ch1 1w14 gv]]
*[[CSC/ECE 517 Fall 2012/ch1 1w17 ir]]
*[[CSC/ECE 517 Fall 2012/ch1 1w18 as]]
*[[CSC/ECE 517 Fall 2012/ch1 1w22 an]]
*[[CSC/ECE 517 Fall 2012/ch1 1w21 aa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w21 wi]]
*[[CSC/ECE 517 Fall 2012/ch1 1w31 sa]]
*[[CSC/ECE 517 Fall 2012/ch1a 1w16 br]]
*[[CSC/ECE 517 Fall 2012/ch1a 1w23 as]]
*[[CSC/ECE 517 Fall 2012/ch1 1w24 nr]]
*[[CSC/ECE 517 Fall 2012/ch1 1w15 rt]]
*[[CSC/ECE 517 Fall 2012/ch1 1w3 pl]]
*[[CSC/ECE 517 Fall 2012/ch1 1w32 cm]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w5 dp]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w37 ss]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w67 ks]]

*[[CSC/ECE 517 Fall 2012/ch1 1w27 ms]]
*[[CSC/ECE 517 Fall 2012/ch1 1w29 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w33 op]]
*[[CSC/ECE 517 Fall 2012/ch1 1w19 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w34 vd]]
*[[CSC/ECE 517 Fall 2012/ch1 1w35 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w30 rp]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w58 am]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w47 sk]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w69 mv]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w44 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w45 is]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w53 kc]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w40 ar]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w39 sn]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w54 go]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w56 ms]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w64 nn]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w66 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w40 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w42 js]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w46 sm]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w71 gs]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w63 dv]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w55 ms]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w57 mp]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w52 an]]
*[[CSC/ECE_517_Fall_2012/ch1b 1w38 nm]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w60 ac]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w62 rb]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w29 st]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w30 an]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w17 pt]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w31 up]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w9 ms]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w19 is]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w5 dp]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w16 dp]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w8 vp]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w18 as]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w3 jm]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w23 sr]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w11_aa]]

CSC/ECE 517 Fall 2012/ch2a 2w11 aa

2012-10-22T13:24:01Z

Dmcarmon: Draft of organization

=Introduction=
Danielle
=Motivation for TDD=
Annice
=Steps=
Annice
=Principles=
Annice
=Examples=
Danielle
=Conclusion=
Danielle
=References=

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-20T00:19:12Z

Dmcarmon: /* Mixing Functional and Object-Oriented Programming */

= Introduction =
This wiki page explores the idea of mixing functional and object-oriented code. Mixing different [http://en.wikipedia.org/wiki/Multi-paradigm#Multi-paradigm_programming_language programming paradigms] is called multi-paradigm programming. There are four major paradigms:

* [http://en.wikipedia.org/wiki/Imperative_paradigm Procedural/imperative paradigms]: Assembly, C, C++, Java, C#
* Object Oriented paradigm : C++, Java, Python, Ruby, Scala, C#
* Functional Paradigm : Lisp, Haskell, Clojure, Scala, OCaml, Ruby
* [http://en.wikipedia.org/wiki/Logic_programming Logic Paradigm]: Prolog

In this wiki we explain how functional and object-oriented paradigms can be mixed. First, we explain what functional and object-oriented style programming is. Secondly, we will show how to apply functional techniques to object-oriented programming. Lastly, we discuss languages that support mixing functional and object-oriented code.

= Functional Programming =

Functional programming treats computation as the evaluation of mathematical functions. It is compute-centric rather than data-centric. Functional programming keeps no global state, does not use for or while loops, and mandates that data is [http://en.wikipedia.org/wiki/Immutable immutable]. Instead, everything is done using functions, usually functions that evaluate mathematical expressions. Each of these functions maintain no internal state and will always produce the same output given the same input.

== Example Contrasting Imperitive and Functional Styles ==

Let's look at an example. Suppose we have a list of numbers and we want to multiply each number in the list by 2. The first approach is the imperitive style:

array[] = {1,2,3,4,5}
for(i=0 ; i<array.length; i++){
array[i] = array[i] * 2;
}

In the above example, array[] is a global variable. If we fail to check the array length, then a runtime exception occurs which might result in the program being crashed. As far as functional style, there is a function called map(func,seq)(in python language) where the function 'func' is applied to each member of seq. The following code is written in a functional style.

numbers = [1,2,3,4,5]
/* define a method called compute on each number in the list */
def compute(var):
var = var * 2
return var
/* Now call the map function */
L = map(compute,numbers)
print L // L will print [1,4,6,8,10]

Notice that there is no global data nor any nested loops and the bound checking is handled internally within the map function. The programmer is relieved of of runtime errors and thus can debug the program easily.

== Advantages of Functional Programming ==

Some advantages of this approach are:
* Easier debugging: Since every thing is broken down into small simple functions, the functions are often easy to debug.
* More compact code: Functional programming typically requires fewer lines of code. Since compution is done by function code reuse is prevelent.
* Nothing depends on state: Because functional programs keep no state information, the functions will always operate the same regardless of the past history of the program.

= Object-oriented Programming =
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] (OOP) is a programming paradigm organized around interacting "objects"(usually instances of a class) rather than "actions" and data rather than logic. A basic principle of OOP is that a program consists of a list of subroutines which can perform individually.

An object-oriented programming language provides support for the following object-oriented concepts--object, class, interface and inheritance. To illustrate this idea clearly and vividly let's review the following example-- your limbs. The "Limbs" is a class. Your body has two objects of type "limbs", named arms and legs. Their main functions are controlled/ managed by a set of biological signals sent from central nervous system( through an interface). So the nervous system is an interface which your body uses to interact with your limbs. The "limbs" is a well architected class. The "legs" has a subclass which contains "left leg" and "Right leg". The "legs" is being re-used to create the left leg and right leg by slightly changing the properties of it. If the "legs" owns attributes like length, color of skin etc, then the subclass, which contains "left leg" and "right leg" in this case, automatically inherit these attributes( that is called inheritance).

We could code in object-oriented paradigm as:

class Limbs
#define a class of limbs
def initialize(limbs,length,colorofskin)
@limbs=limbs
@length=length
@colorofskin=colorofskin
end
end
limbs=Limbs.new("legs","100cm","white")
#create a new object in class "Limbs"
class Legs<Limbs
#create a subclass "Legs",which belong to class"Limbs"
def initialize(legs,length,colorofskin)
super(length,colorofskin)
@legs=legs
end
end
legs=legs.new("left leg")
#create a new object in class of "Legs"

== Features of Object-oriented Programming ==
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]. A programmer can simply create a new object that inherits many of its features from super-class. And also, they can overwrite existing operations or add new ones.This makes object-oriented programs easier to modify.
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation].This refers to hiding the internal representation of the object from the outside view. You can hide unnecessary implementation details from the object user. One of the benefits of encapsulation is data protection.
* [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism].This allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects. Consider the operator '+', for numbers it will generate the sum, but for strings it will produce a third string which concatenates the input strings.

== Advantages of Object-oriented Programming ==
* Simplicity: we use software objects to simulate real world objects, so the complexity is reduced and the program structure is very clear.
* Modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system.
* Modifiability: programmers can easily make minor changes in the data representation or operations in an OOP. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods.
* Extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones.
* Maintainability: objects can be maintained separately, making locating and fixing problems easier.
* Re-usability: objects can be reused in different programs.

= Mixing Functional and Object-Oriented Programming =

In object-oriented world, data and operations are grouped together into modular units called objects and we combine objects into structured networks to form a program. The results are depend on arguments and objects' state at method invocation time. While in functional world, the basic elements are variables in the mathematical sense and functions in the mathematical sense. Functional programming can reduce side-effects. If there is no side-effects, it means your can apply the function at anywhere freely. No matter how you apply this function, the same input arguments produce the same results.

{| class="wikitable" border="2"
|-
! Functional - Mathematical Functions
! Object-Oriented - Objects
|-
| Compact
| Modular
|-
| Easy to debug
| Easy to maintain
|-
|}

Overall, object-oriented programming requires more upfront design, but is easier to maintain long-term. Obviously if we apply functional programming techniques to object-oriented programming, everything can be done better--the code is easier to write, runs faster, and uses less memory.

== Functional Techniques useful for Object-Oriented Programming ==

According to above-mentioned information, we can perform functional programming on an object-oriented programming language because:
1). object can have constant state
2). method can depend only on its arguments and context available at method definition time

Combining both these paradigms not only provide us a robust design structure, but also enable the programmers to develop solutions to complex problems quickly and effectively. One of the cornerstone of mixing functional and object-oriented code is treating functions as objects.It means that we can pass functions as arguments, store it and return them from other functions. This is highly useful in an user interface code where it can be used as call back functions which gets called when an event occurs(event driven programming).

Some of the basic features of Functional Programming which can be combined with Object Oriented paradigm are:

* Lambda Calculus
* Currying
* Powerful pattern matching

Let us now understand how each of the above feature of Functional language fits in the Object Oriented paradigm.

=== Lambda Calculus ===
Lambda calculus is the most critical basis of functional programming. A lambda expression is an anonymous expression that contain expressions and statements.Each expression stands for a function with one parameter.

Let consider the following function:

def f(x)
return x**2
print f(4)

We can use a lambda calculus to compute this expression without assigning it to a variable:

(lambda x:x**x)(4)

We can see that these two code snippets have the same results. It is more concise and flexible to define with lambda.
The above is a pure functional approach. In order to make code more state-less and concise, lambdas can be embedded inside the object-oriented language. The below code in Python demonstrates the use of lambda in a closure:

def fun(x):
return x%3==0
str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
filter(fun,str)

The above code works to find numbers which are divisible by 3.
We can simplify the code by the use of lambda as following:

str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print filter(lambda x: x%3==0, str)

=== Currying ===
In the above information we have learned much about lambda calculus, which take care of one argument, now let me introduce you another concept called currying functions which takes in multiple arguments and returns a chain of functions with lesser number of arguments. It can be interpreted as the technique to decompose a function that takes n parameters into n functions and each of the n functions takes one parameter.

Currying is really an interesting concept. Let's take a sample code in JavaScript to understand it:

//This is a function for calculating x+y. The difference between this function and general is that this is a currying function.
function add(x, y)
{
if(x!=null && y!=null) return x + y;
else if(x!=null && y==null) return function(y)
{
return x + y; //return a closure with parameter y for subsequent calculations
}
else if(x==null && y!=null) return function(x)
{
return x + y; //return a closure with parameter x for subsequent calculations
}
}
var a = add(3, 4); //compute the value of (3+4) and return the value of 7
var b = add(2); //add(2) is equal to a function of (2+y)
var c = b(10); //pass 10 to y, and return the value of (2+10) which is 12

In the above sample, b=add(2) gives us a currying function of add(), which is function of y when x=2.

More interestingly, we can define a currying form of arbitrary functions.
function Foo(x, y, z, w)
{
var args = arguments;
if(Foo.length < args.length)
return function()
{
return args.callee.apply(Array.apply([], args).concat(Array.apply([], arguments)));
}
else
return x + y – z * w;
}

=== Pattern Matching ===
What is pattern matching? I think all of you do know what it is, you just don't know you know it. The semantics are equally straightforward.Firstly, we evaluate the value expression, then we walk down the clauses. For each one, we see if the pattern matches the value. If so, we execute the body and end. Simply put, pattern matching is a technique to search string for the occurrence of any patterns or regularity.

Pattern matching allows you to do different calculations according to different identifier values. It looks the same with nests of "if...else" statements, as well as "switch" statements in C++ and C#. But here it is much stronger and more flexible.

You may find that there are two main types of usage of pattern matching:
* To search and find a particular value.
* To find a particular value and replace it with selected text.

For example, the following code snippets writes a message if a string contains the text Perl or Python:

if line =~ /Perl|Python/
puts "Scripting language mentioned:#{line}"
end

Next, let us consider the following sample in which a part of a string matched by a regular expression can be replaced with different text using one of Ruby’s substitution methods:

line.sub(/Perl/, 'Ruby') # replace first 'Perl' with 'Ruby'
line.gsub(/Python/, 'Ruby') # replace every 'Python' with 'Ruby'

Advantages of Pattern Matching:
* It allows concise, readable deconstruction of complex data structures.
* It gives a possible separation of data structure and respective functionality.

== Examples of Mixing ==

A number of programming languages support mixing of both functional and object-oriented code. Three of these (Scala, Ruby, and Conjure), are described in more detail below.

=== Scala ===

[http://www.scala-lang.org/ Scala] is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. [http://www.scala-lang.org/ Scala] was conceived in 2001 and implemented by Martin Odersky. It supports mixing functional and object-oriented code.

==== Mixing Functional and Object-Oriented Code in Scala ====
[http://www.scala-lang.org/ Scala] is a strange specimen. It is a complete blend of object-oriented and functional programming. How can this happen? The functional world advocates immutability, but the object-oriented world focuses on the state and how to change it to fit your needs. [http://www.scala-lang.org/ Scala] allows you create both mutable and immutable objects. Consider the following example,
val str: String = "Hello World"
In the first line, an immutable version(a misnomer indeed) of <code>str</code> is being created . A rough translation into Java is below:

final String str = "Hello World"; //note the extra semi-colon
Consider the next example below,
val list: List[String] = List("Scala", "is", "the coolest", "language", "in the world!")

The same code can be written in Java as:

List<String> mutableList = new ArrayList<String>();
list.add("Scala");
list.add("is");
list.add("the coolest");
list.add("language");
list.add("in the world!");
List<String> immutableList = Collections.immutableList(mutableList);

Compared to Java, [http://www.scala-lang.org/ Scala] reduces the total number of lines you need to type and at the same time looks much simpler and less verbose. Even though the above example shows an immutable collection, scala also provides mutable collections and object types in the package <code>scala.collection.mutable.*</code>

As can be observed, even though [http://www.scala-lang.org/ Scala] advocates immutability, it does not restrict you from creating mutable objects. So it's the best of both worlds. Another part of the functional world is the concept of functions as ''''first class members'''' of the language. Some of the common languages like Ruby, Python and JavaScript all incorporate this feature. In the sense you can pass around functions to methods as a parameter. Enough talking;

Let us have a class say <code>'Person'</code> which has properties, <code>name</code> and another variable <code>age</code>.
In Java:

class Person{
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String s){
this.name = s;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}

In [http://www.scala-lang.org/ Scala]:
case class Person(name: String, age: Int)

This single line is equivalent to the above java code! Getters for <code>name</code> and <code>age</code>, <code>equals()</code>, and <code>hashCode()</code> method are automatically generated for you by the compiler. Isn't this an awesome feature?

Now assume we have a list of persons and we want to filter out all the persons who are of age 23. How would you do that in Java?

List<Person> persons; //has a bunch of person objects in it.
List<Person> twentyThree = new ArrayList<Person>();
for(Person p: persons){
if(p.getAge() == 23){
twentyThree.add(p);
}
}

In [http://www.scala-lang.org/ Scala]:

val twentyThree: List[Person] = persons.filter( _.age == 23)

That's it! In case you are wondering whats going on, filter is a method present on scala.List class and the code block <code>_.age == 23</code> is a function created on the fly and passed onto the filter method. More precisely its called a [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] - a functional concept which can be emulated in java only using anonymous inner classes. Scala's compiler transforms our one line function into some anonymous inner classes when generating java byte code, allowing developers to define functions in a simple manner.

In fact, every function is an object in [http://www.scala-lang.org/ Scala]. Scala's standard library has a number of functions which are objects themselves.

==== Implicits in Scala ====
In almost all programming languages, there is a necessity to profile the running time of the procedures and tune its performance. The old way of doing things in Java would be:

public class Main{
public static int factorial(int x){
if(x == 0 || x == 1) return 1
else return x * factorial(x-1)
}
public static void main(String [] args){
long beforeTime = System.currentTimeMillis();
int result = factorial(5);
System.out.println("Total time taken to execute factorial(5) is " + (System.currentTimeMillis() - result)+"ms");
System.out.println("factorial(5) = " + result);
}
}

However, if you want to find out the execution time of some other method, you would have to type in all the above lines again. So much for code re-use or [http://en.wikipedia.org/wiki/DRY DRY (dont't repeat yourself)]! Lets see how its done in [http://www.scala-lang.org/ Scala].

object Main{
def main(args: Array[String]){
def factorial(x: Int):Int = x match{
case 0 | 1 => 1
case _ => x * factorial(x-1)
}
import System.currentTimeMillis
def timeIt(msg: String = "Time to execute is: ")(func: => Unit){
val before = currentTimeMillis
func
println(msg + (currentTimeMillis - before) + "ms")
}
timeIt("Total time taken to execute factorial(5) is "){
val result = factorial(5)
println("factorial(5) = " + result)
}
}
//would print: factorial(5) = 120
// Total time taken to execute factorial(5) is 1ms

That's not right! The function <code>timeIt</code> looks like a feature built into the language. Try saving the above code into a separate file and run it - It will still work. Using this feature, it is possible to build powerful DSL languages which can run at full speed on JVM.

Ruby allows you to add new methods to objects. Since you are splitting open the class and adding/overriding methods (in)|(to) the class, this feature is often called [http://en.wikipedia.org/wiki/Monkey_patch Monkey Patching]. Because other libraries may depend on some methods which you changed, often this leads to unexpected behavior at runtime. However, Scala provides yet another feature called [http://en.wikipedia.org/wiki/Implicit_function implicits] which helps you do this better.

In Java, <code>String</code> class is <code>final</code> so there is no way you can add new methods to it. But with implicits you can do more! Suppose you have some text in memory and you know it represents a number. But in Java the usual way to convert string to int is to do a <code>Integer.parseInt(string)</code> which seems so unnecessary. Let us make our lives easier...

implicit def strToInt(str: String) = new {
def asInt = Integer.parseInt(str)
}
val str = "1234"
println(str.asInt * 3) //prints out 3702

The above code gives us an impression as if String class has gained new <code>asInt</code> method. Can static object oriented languages do this? No! Infact scala cheats by calling our implicits to convert it into a different object as and when needed.

The above functionalities are purely object oriented, yet they are safe. They don't pollute the global namespace, unlike Ruby or Python.

=== Ruby ===

Ruby is another language that, like Scala, supports mixing functional and object-oriented code. It is a dynamically typed Object-Oriented Language which supports multiple programming paradigms, including functional, object-oriented, imperative and reflective. In Ruby, everything is an object, every bit of information and code can have its own properties and actions. However, Ruby’s blocks can be functional. A Ruby programmer can attach a closure to any method, which generates a functional block inside an object oriented code. A closure is a piece of code that can access the lexical environment of its definition [http://www.ruby-lang.org/en/ 11].

==== Ruby Mixing Example ====

Consider the following code snippet in Ruby which uses Object Oriented concepts like Classes and functional programming concepts like lambda.

class Multiply
def initialize(n)
@block = lambda {|a| n * a}
end
def mul(a)
@block.call a
end
end
twoMultiplier = Multiply.new 2
puts twoMultiplier.mul(6)

Here,'''''@block''''' is a closure. When we call the class ''Multiply'' using '''''twoAdder = Multiply.new 2''''' ,the ''initialize'' method is called by passing the parameter 2. Here n=2 binds itself to the block. So @block will be 2*a, that is,the closure remembers the parameter with which the initialize method was called even after the initialize method exits.

This value is used when the block is called in the add method.
Thus,'''''twoMultiplier.mul(6)''''' will return 2*6 = 12

==== Functional Style Coding in Ruby Blocks ====

Blocks are basically nameless functions which can be passed to a function and then that function can invoke the passed in nameless function. This is a common style called [http://en.wikipedia.org/wiki/Higher-order_function higher order functions] among languages that handle functions as first class objects. Basically blocks can be designed for loop abstraction and lets the user to design their own way of iterating the values, thereby hiding the implementation details.
For example, if we want to iterate backwards from the end to the beginning without revealing its internal implementations, we could implement the loop logic inside the block and pass it to a method or function.

Here is a [http://www.ruby-lang.org/en/ Ruby] implementation of block:

def printlist(array,&reverse)
array.each do |element|
puts "array element: #{element}"
end
reverse.call(array) /* Here it prints the reverse implementation of list*/
end

printlist([1,2,3,4,5,6]) { |array|
array.reverse.each do |element|
puts "array element: #{element}"
end
}
The statements between { } is a block and it gets called by <code>reverse.call(array)</code>within the printlist method.

=== Clojure ===

Clojure[[http://oreilly.com/catalog/9781934356333 31]] is also a functional programming language, and it is a dialect of Lisp. It is not a pure functional language. Instead, it is a dynamically typed language. Just like Java it runs on JVM platform, but its syntax differs from Java. It is represented as :

(functions arguments...)

The function and its arguments are enclosed in paranthesis. It has features like immutable data structures, high-order functions, recursion, and easy and fast java interoperability.

In Clojure's model, value calculation is purely functional. Values never change. New values are functions of old. But, logical identity is well supported via atomic references to values. The value of a reference (state of an identity) is always observable without coordination and freely shareable between threads.
When programs are constructed this way, functional value calculation is independent of identity-value association. This makes clojure easier to understand and test.

====Example Using Functional Technique in Clojure====

Consider the following functional programming example in Clojure-
(defn make-adder [x]
(let [y x]
(fn [z] (+ y z))))
(def add2 (make-adder 2))
(add2 4)

Here,'''''defn make-adder [x]''''' defines a function called ''make-adder''.'''''let [y x]''''' gives a local name y for the value x. Since the scope of any local names is lexical, a function created in the scope of local names will close over their values.'''''fn [z] (+ y z)''''' does the addition of y and z.
''
'''def add2 (make-adder 2)''''' calls the function ''make-adder'' passing the parameter 2 and calls this as ''add2''.Now, ''add2'' has computed 2+z. When '''''add2 4''''' is called it computes 2+4=6

====Example Using Object-Oriented Technique in Clojure====

The following program implements Run-Time Polymorphism which is an object-oriented programming concept.
(defmulti encounter (fn [x y] [(:Species x) (:Species y)]))
(defmethod encounter [:Bunny :Lion] [b l] :run-away)
(defmethod encounter [:Lion :Bunny] [l b] :eat)
(defmethod encounter [:Lion :Lion] [l1 l2] :fight)
(defmethod encounter [:Bunny :Bunny] [b1 b2] :mate)
(def b1 {:Species :Bunny :other :stuff})
(def b2 {:Species :Bunny :other :stuff})
(def l1 {:Species :Lion :other :stuff})
(def l2 {:Species :Lion :other :stuff})

(encounter b1 l1)
-> :run-away
(encounter l1 l2)
-> :fight

Here,'''''defmulti''''' is used to define multiple methods which have the same method name '''''encounter'''''.Depending on the parameters passed to the encounter method, one of the four methods is called.
'''''def''''' defines each of the different species.
When, '''''(encounter b1 l1)''''' is called, the first ''encounter'' method is called with the parameters ''Bunny'' and ''Lion''. As a result, ''run-away'' is printed.

=== Summary of Languages Supporting Mixing ===

Each of the languages contains both functional and object-oriented features. The following table shows how each of the languages have both functional and object-oriented characterics. Not all characteristics of the languages are listed, but enough to demonstrate that the languages each have different ways of mixing object-oriented and functional techniques.

{| class="wikitable" border="2"
|-
!
! Functional Characteristics
! Object-Oriented Characteristics
|-
! Scala
| Immutable objects, the ability to pass functions as parameters, implicits, closures.
| Every value is a object, mutable objects.
|-
! Ruby
| Functional programming used in blocks.
| Everything is an object.
|-
! Clojure
| Immutable data structures, high-order functions, recursion.
| Objects, runtime polymorphism, [http://en.wikipedia.org/wiki/Multiple_dispatch multimethods.]
|-
|}

= Conclusion =
In summary, functional and object-oriented programming can be successfully mixed in programs. Many functional techniques are useful in object-oriented programs. Functional programming integrated with object oriented style leads to:

*Better understanding of program behavior and easier debugging as a result of immutability features
*Use of techniques such as blocks and closures to implement object oriented design and reduce repetitive code
*Lesser complexity and reduction in the number of lines of code

Languages such as Scala, Ruby, and Clojure effectively support mixing these two paradigms, allowing programmers to create cleaner, less buggy object-oriented code.

= References =

Special thanks to writers of previous wiki pages (see last three references below).

#[http://en.wikipedia.org/wiki/Functional_programming Wikipedia - Functional Programming]
#[http://www.cs.cornell.edu/riccardo/prog-smlnj/notes-011001.pdf Notes on programming Standard ML of New Jersey]
#[http://users.dickinson.edu/~braught/courses/cs132f01/classes/code/Factorial.src.html Introduction to Computing - Dickinson College]
#[http://en.wikipedia.org/wiki/Object-oriented_programming Wikipedia - Object Oriented Programming]
#[http://searchsoa.techtarget.com/sDefinition/0,,sid26_gci212681,00.html More on Object Oriented Programming]
#[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas Understanding Ruby Blocks, Procs and Lambdas - Robert Sosinski]
#[http://www.codingday.com/power-of-functional-programming-its-features-and-its-future/ Power of Functional Programming, its Features and its Future]
#[http://skillsmatter.com/podcast/open-source-dot-net/mike-wagg-mark-needham-functional-and-oo-approaches-to-c-sharp-programming Mixing Functional and Object Oriented Approaches to Programming in C#]
#[http://en.wikipedia.org/wiki/Programming_paradigm Programming Paradigm]
#[http://en.wikipedia.org/wiki/Recursion Recursion]
#[http://www.scala-lang.org/ Scala]
#[http://en.wikipedia.org/wiki/Scala_%28programming_language%29 Scala Wikipedia]
#[http://clojure.org/ Clojure]
#[http://www.ruby-lang.org/en/ Ruby]
#[http://en.wikipedia.org/wiki/Standard_ML Standard ML]
#[http://en.wikipedia.org/wiki/Haskell_%28programming_language%29 Haskell]
#[http://en.wikipedia.org/wiki/ML_%28programming_language%29 ML Family]
#[http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java]
#[http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]
#[http://en.wikipedia.org/wiki/C%2B%2B C++ Programming Language]
#[http://en.wikipedia.org/wiki/Visual_Basic_.NET Visual Basic .Net]
# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]
#O'Reilly (2009), "Programming Scala", ''O'Reilly Media Inc.''.
#Dave Thomas, Chad Fowler, Andy Hunt (2006) ''Programming Ruby'', The Pragmatic Bookshelf.
#[http://lamp.epfl.ch/~phaller/doc/haller10-Translucent_functions.pdf Philipp Halle, Lightweight language support for type-based, concurrent event processing, Lausanne, Switzerland, April 2010.]
#[http://biblion.epfl.ch/EPFL/theses/2007/3899/EPFL_TH3899.pdf Burak Emir, Object-Oriented Pattern Matching, EPFL, October 2007].
#[http://math.hws.edu/eck/cs124/downloads/OOP2_from_Univ_KwaZulu-Natal.pdf, Object-Oriented Programming,February 2007].
#[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2010/ch1_1e_az CSC/ECE 517 Fall 2010/ch1 1e az]
#[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2010/ch1_1e_AE CSC/ECE 517 Fall 2010/ch1 1e AE]
#[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2010/ch1_1e_bb CSC/ECE 517 Fall 2010/ch1 1e bb]

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-20T00:18:56Z

Dmcarmon: Added side-by-side comparison of Functional/Object-oriented advantages.

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-12T19:25:36Z

Dmcarmon: /* References */

= Introduction =
This wiki page explores the idea of mixing functional and object-oriented code. Mixing different [http://en.wikipedia.org/wiki/Multi-paradigm#Multi-paradigm_programming_language programming paradigms] is called multi-paradigm programming. There are four major paradigms:

* [http://en.wikipedia.org/wiki/Imperative_paradigm Procedural/imperative paradigms]: Assembly, C, C++, Java, C#
* Object Oriented paradigm : C++, Java, Python, Ruby, Scala, C#
* Functional Paradigm : Lisp, Haskell, Clojure, Scala, OCaml, Ruby
* [http://en.wikipedia.org/wiki/Logic_programming Logic Paradigm]: Prolog

In this wiki we explain how functional and object-oriented paradigms can be mixed. First, we explain what functional and object-oriented style programming is. Secondly, we will show how to apply functional techniques to object-oriented programming. Lastly, we discuss languages that support mixing functional and object-oriented code.

= Functional Programming =

Functional programming treats computation as the evaluation of mathematical functions. It is compute-centric rather than data-centric. Functional programming keeps no global state, does not use for or while loops, and mandates that data is [http://en.wikipedia.org/wiki/Immutable immutable]. Instead, everything is done using functions, usually functions that evaluate mathematical expressions. Each of these functions maintain no internal state and will always produce the same output given the same input.

== Example Contrasting Imperitive and Functional Styles ==

Let's look at an example. Suppose we have a list of numbers and we want to multiply each number in the list by 2. The first approach is the imperitive style:

array[] = {1,2,3,4,5}
for(i=0 ; i<array.length; i++){
array[i] = array[i] * 2;
}

In the above example, array[] is a global variable. If we fail to check the array length, then a runtime exception occurs which might result in the program being crashed. As far as functional style, there is a function called map(func,seq)(in python language) where the function 'func' is applied to each member of seq. The following code is written in a functional style.

numbers = [1,2,3,4,5]
/* define a method called compute on each number in the list */
def compute(var):
var = var * 2
return var
/* Now call the map function */
L = map(compute,numbers)
print L // L will print [1,4,6,8,10]

Notice that there is no global data nor any nested loops and the bound checking is handled internally within the map function. The programmer is relieved of of runtime errors and thus can debug the program easily.

== Advantages of Functional Programming ==

Some advantages of this approach are:
* Easier debugging: Since every thing is broken down into small simple functions, the functions are often easy to debug.
* More compact code: Functional programming typically requires fewer lines of code. Since compution is done by function code reuse is prevelent.
* Nothing depends on state: Because functional programs keep no state information, the functions will always operate the same regardless of the past history of the program.

= Object-oriented Programming =
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] (OOP) is a programming paradigm organized around interacting "objects"(usually instances of a class) rather than "actions" and data rather than logic. A basic principle of OOP is that a program consists of a list of subroutines which can perform individually.

An object-oriented programming language provides support for the following object-oriented concepts--object, class, interface and inheritance. To illustrate this idea clearly and vividly let's review the following example-- your limbs. The "Limbs" is a class. Your body has two objects of type "limbs", named arms and legs. Their main functions are controlled/ managed by a set of biological signals sent from central nervous system( through an interface). So the nervous system is an interface which your body uses to interact with your limbs. The "limbs" is a well architected class. The "legs" has a subclass which contains "left leg" and "Right leg". The "legs" is being re-used to create the left leg and right leg by slightly changing the properties of it. If the "legs" owns attributes like length, color of skin etc, then the subclass, which contains "left leg" and "right leg" in this case, automatically inherit these attributes( that is called inheritance).

We could code in object-oriented paradigm as:

class Limbs
#define a class of limbs
def initialize(limbs,length,colorofskin)
@limbs=limbs
@length=length
@colorofskin=colorofskin
end
end
limbs=Limbs.new("legs","100cm","white")
#create a new object in class "Limbs"
class Legs<Limbs
#create a subclass "Legs",which belong to class"Limbs"
def initialize(legs,length,colorofskin)
super(length,colorofskin)
@legs=legs
end
end
legs=legs.new("left leg")
#create a new object in class of "Legs"

== Features of Object-oriented Programming ==
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]. A programmer can simply create a new object that inherits many of its features from super-class. And also, they can overwrite existing operations or add new ones.This makes object-oriented programs easier to modify.
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation].This refers to hiding the internal representation of the object from the outside view. You can hide unnecessary implementation details from the object user. One of the benefits of encapsulation is data protection.
* [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism].This allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects. Consider the operator '+', for numbers it will generate the sum, but for strings it will produce a third string which concatenates the input strings.

== Advantages of Object-oriented Programming ==
* Simplicity: we use software objects to simulate real world objects, so the complexity is reduced and the program structure is very clear.
* Modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system.
* Modifiability: programmers can easily make minor changes in the data representation or operations in an OOP. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods.
* Extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones.
* Maintainability: objects can be maintained separately, making locating and fixing problems easier.
* Re-usability: objects can be reused in different programs.

= Mixing Functional and Object-Oriented Programming =

In object-oriented world, data and operations are grouped together into modular units called objects and we combine objects into structured networks to form a program. The results are depend on arguments and objects' state at method invocation time. While in functional world, the basic elements are variables in the mathematical sense and functions in the mathematical sense. Functional programming can reduce side-effects. If there is no side-effects, it means your can apply the function at anywhere freely. No matter how you apply this function, the same input arguments produce the same results.

Obviously if we apply functional programming techniques to object-oriented programming, everything can be done better--the code is easier to write, runs faster, and uses less memory.

== Functional Techniques useful for Object-Oriented Programming ==

According to above-mentioned information, we can perform functional programming on an object-oriented programming language because:
1). object can have constant state
2). method can depend only on its arguments and context available at method definition time

Combining both these paradigms not only provide us a robust design structure, but also enable the programmers to develop solutions to complex problems quickly and effectively. One of the cornerstone of mixing functional and object-oriented code is treating functions as objects.It means that we can pass functions as arguments, store it and return them from other functions. This is highly useful in an user interface code where it can be used as call back functions which gets called when an event occurs(event driven programming).

Some of the basic features of Functional Programming which can be combined with Object Oriented paradigm are:

* Lambda Calculus
* Currying
* Powerful pattern matching

Let us now understand how each of the above feature of Functional language fits in the Object Oriented paradigm.

=== Lambda Calculus ===
Lambda calculus is the most critical basis of functional programming. A lambda expression is an anonymous expression that contain expressions and statements.Each expression stands for a function with one parameter.

Let consider the following function:

def f(x)
return x**2
print f(4)

We can use a lambda calculus to compute this expression without assigning it to a variable:

(lambda x:x**x)(4)

We can see that these two code snippets have the same results. It is more concise and flexible to define with lambda.
The above is a pure functional approach. In order to make code more state-less and concise, lambdas can be embedded inside the object-oriented language. The below code in Python demonstrates the use of lambda in a closure:

def fun(x):
return x%3==0
str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
filter(fun,str)

The above code works to find numbers which are divisible by 3.
We can simplify the code by the use of lambda as following:

str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print filter(lambda x: x%3==0, str)

=== Currying ===
In the above information we have learned much about lambda calculus, which take care of one argument, now let me introduce you another concept called currying functions which takes in multiple arguments and returns a chain of functions with lesser number of arguments. It can be interpreted as the technique to decompose a function that takes n parameters into n functions and each of the n functions takes one parameter.

Currying is really an interesting concept. Let's take a sample code in JavaScript to understand it:

//This is a function for calculating x+y. The difference between this function and general is that this is a currying function.
function add(x, y)
{
if(x!=null && y!=null) return x + y;
else if(x!=null && y==null) return function(y)
{
return x + y; //return a closure with parameter y for subsequent calculations
}
else if(x==null && y!=null) return function(x)
{
return x + y; //return a closure with parameter x for subsequent calculations
}
}
var a = add(3, 4); //compute the value of (3+4) and return the value of 7
var b = add(2); //add(2) is equal to a function of (2+y)
var c = b(10); //pass 10 to y, and return the value of (2+10) which is 12

In the above sample, b=add(2) gives us a currying function of add(), which is function of y when x=2.

More interestingly, we can define a currying form of arbitrary functions.
function Foo(x, y, z, w)
{
var args = arguments;
if(Foo.length < args.length)
return function()
{
return args.callee.apply(Array.apply([], args).concat(Array.apply([], arguments)));
}
else
return x + y – z * w;
}

=== Pattern Matching ===
What is pattern matching? I think all of you do know what it is, you just don't know you know it. The semantics are equally straightforward.Firstly, we evaluate the value expression, then we walk down the clauses. For each one, we see if the pattern matches the value. If so, we execute the body and end. Simply put, pattern matching is a technique to search string for the occurrence of any patterns or regularity.

Pattern matching allows you to do different calculations according to different identifier values. It looks the same with nests of "if...else" statements, as well as "switch" statements in C++ and C#. But here it is much stronger and more flexible.

You may find that there are two main types of usage of pattern matching:
* To search and find a particular value.
* To find a particular value and replace it with selected text.

For example, the following code snippets writes a message if a string contains the text Perl or Python:

if line =~ /Perl|Python/
puts "Scripting language mentioned:#{line}"
end

Next, let us consider the following sample in which a part of a string matched by a regular expression can be replaced with different text using one of Ruby’s substitution methods:

line.sub(/Perl/, 'Ruby') # replace first 'Perl' with 'Ruby'
line.gsub(/Python/, 'Ruby') # replace every 'Python' with 'Ruby'

Advantages of Pattern Matching:
* It allows concise, readable deconstruction of complex data structures.
* It gives a possible separation of data structure and respective functionality.

== Examples of Mixing ==

A number of programming languages support mixing of both functional and object-oriented code. Three of these (Scala, Ruby, and Conjure), are described in more detail below.

=== Scala ===

[http://www.scala-lang.org/ Scala] is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. [http://www.scala-lang.org/ Scala] was conceived in 2001 and implemented by Martin Odersky. It supports mixing functional and object-oriented code.

==== Mixing Functional and Object-Oriented Code in Scala ====
[http://www.scala-lang.org/ Scala] is a strange specimen. It is a complete blend of object-oriented and functional programming. How can this happen? The functional world advocates immutability, but the object-oriented world focuses on the state and how to change it to fit your needs. [http://www.scala-lang.org/ Scala] allows you create both mutable and immutable objects. Consider the following example,
val str: String = "Hello World"
In the first line, an immutable version(a misnomer indeed) of <code>str</code> is being created . A rough translation into Java is below:

final String str = "Hello World"; //note the extra semi-colon
Consider the next example below,
val list: List[String] = List("Scala", "is", "the coolest", "language", "in the world!")

The same code can be written in Java as:

List<String> mutableList = new ArrayList<String>();
list.add("Scala");
list.add("is");
list.add("the coolest");
list.add("language");
list.add("in the world!");
List<String> immutableList = Collections.immutableList(mutableList);

Compared to Java, [http://www.scala-lang.org/ Scala] reduces the total number of lines you need to type and at the same time looks much simpler and less verbose. Even though the above example shows an immutable collection, scala also provides mutable collections and object types in the package <code>scala.collection.mutable.*</code>

As can be observed, even though [http://www.scala-lang.org/ Scala] advocates immutability, it does not restrict you from creating mutable objects. So it's the best of both worlds. Another part of the functional world is the concept of functions as ''''first class members'''' of the language. Some of the common languages like Ruby, Python and JavaScript all incorporate this feature. In the sense you can pass around functions to methods as a parameter. Enough talking;

Let us have a class say <code>'Person'</code> which has properties, <code>name</code> and another variable <code>age</code>.
In Java:

class Person{
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String s){
this.name = s;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}

In [http://www.scala-lang.org/ Scala]:
case class Person(name: String, age: Int)

This single line is equivalent to the above java code! Getters for <code>name</code> and <code>age</code>, <code>equals()</code>, and <code>hashCode()</code> method are automatically generated for you by the compiler. Isn't this an awesome feature?

Now assume we have a list of persons and we want to filter out all the persons who are of age 23. How would you do that in Java?

List<Person> persons; //has a bunch of person objects in it.
List<Person> twentyThree = new ArrayList<Person>();
for(Person p: persons){
if(p.getAge() == 23){
twentyThree.add(p);
}
}

In [http://www.scala-lang.org/ Scala]:

val twentyThree: List[Person] = persons.filter( _.age == 23)

That's it! In case you are wondering whats going on, filter is a method present on scala.List class and the code block <code>_.age == 23</code> is a function created on the fly and passed onto the filter method. More precisely its called a [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] - a functional concept which can be emulated in java only using anonymous inner classes. Scala's compiler transforms our one line function into some anonymous inner classes when generating java byte code, allowing developers to define functions in a simple manner.

In fact, every function is an object in [http://www.scala-lang.org/ Scala]. Scala's standard library has a number of functions which are objects themselves.

==== Implicits in Scala ====
In almost all programming languages, there is a necessity to profile the running time of the procedures and tune its performance. The old way of doing things in Java would be:

public class Main{
public static int factorial(int x){
if(x == 0 || x == 1) return 1
else return x * factorial(x-1)
}
public static void main(String [] args){
long beforeTime = System.currentTimeMillis();
int result = factorial(5);
System.out.println("Total time taken to execute factorial(5) is " + (System.currentTimeMillis() - result)+"ms");
System.out.println("factorial(5) = " + result);
}
}

However, if you want to find out the execution time of some other method, you would have to type in all the above lines again. So much for code re-use or [http://en.wikipedia.org/wiki/DRY DRY (dont't repeat yourself)]! Lets see how its done in [http://www.scala-lang.org/ Scala].

object Main{
def main(args: Array[String]){
def factorial(x: Int):Int = x match{
case 0 | 1 => 1
case _ => x * factorial(x-1)
}
import System.currentTimeMillis
def timeIt(msg: String = "Time to execute is: ")(func: => Unit){
val before = currentTimeMillis
func
println(msg + (currentTimeMillis - before) + "ms")
}
timeIt("Total time taken to execute factorial(5) is "){
val result = factorial(5)
println("factorial(5) = " + result)
}
}
//would print: factorial(5) = 120
// Total time taken to execute factorial(5) is 1ms

That's not right! The function <code>timeIt</code> looks like a feature built into the language. Try saving the above code into a separate file and run it - It will still work. Using this feature, it is possible to build powerful DSL languages which can run at full speed on JVM.

Ruby allows you to add new methods to objects. Since you are splitting open the class and adding/overriding methods (in)|(to) the class, this feature is often called [http://en.wikipedia.org/wiki/Monkey_patch Monkey Patching]. Because other libraries may depend on some methods which you changed, often this leads to unexpected behavior at runtime. However, Scala provides yet another feature called [http://en.wikipedia.org/wiki/Implicit_function implicits] which helps you do this better.

In Java, <code>String</code> class is <code>final</code> so there is no way you can add new methods to it. But with implicits you can do more! Suppose you have some text in memory and you know it represents a number. But in Java the usual way to convert string to int is to do a <code>Integer.parseInt(string)</code> which seems so unnecessary. Let us make our lives easier...

implicit def strToInt(str: String) = new {
def asInt = Integer.parseInt(str)
}
val str = "1234"
println(str.asInt * 3) //prints out 3702

The above code gives us an impression as if String class has gained new <code>asInt</code> method. Can static object oriented languages do this? No! Infact scala cheats by calling our implicits to convert it into a different object as and when needed.

The above functionalities are purely object oriented, yet they are safe. They don't pollute the global namespace, unlike Ruby or Python.

=== Ruby ===

Ruby is another language that, like Scala, supports mixing functional and object-oriented code. It is a dynamically typed Object-Oriented Language which supports multiple programming paradigms, including functional, object-oriented, imperative and reflective. In Ruby, everything is an object, every bit of information and code can have its own properties and actions. However, Ruby’s blocks can be functional. A Ruby programmer can attach a closure to any method, which generates a functional block inside an object oriented code. A closure is a piece of code that can access the lexical environment of its definition [http://www.ruby-lang.org/en/ 11].

==== Ruby Mixing Example ====

Consider the following code snippet in Ruby which uses Object Oriented concepts like Classes and functional programming concepts like lambda.

class Multiply
def initialize(n)
@block = lambda {|a| n * a}
end
def mul(a)
@block.call a
end
end
twoMultiplier = Multiply.new 2
puts twoMultiplier.mul(6)

Here,'''''@block''''' is a closure. When we call the class ''Multiply'' using '''''twoAdder = Multiply.new 2''''' ,the ''initialize'' method is called by passing the parameter 2. Here n=2 binds itself to the block. So @block will be 2*a, that is,the closure remembers the parameter with which the initialize method was called even after the initialize method exits.

This value is used when the block is called in the add method.
Thus,'''''twoMultiplier.mul(6)''''' will return 2*6 = 12

==== Functional Style Coding in Ruby Blocks ====

Blocks are basically nameless functions which can be passed to a function and then that function can invoke the passed in nameless function. This is a common style called [http://en.wikipedia.org/wiki/Higher-order_function higher order functions] among languages that handle functions as first class objects. Basically blocks can be designed for loop abstraction and lets the user to design their own way of iterating the values, thereby hiding the implementation details.
For example, if we want to iterate backwards from the end to the beginning without revealing its internal implementations, we could implement the loop logic inside the block and pass it to a method or function.

Here is a [http://www.ruby-lang.org/en/ Ruby] implementation of block:

def printlist(array,&reverse)
array.each do |element|
puts "array element: #{element}"
end
reverse.call(array) /* Here it prints the reverse implementation of list*/
end

printlist([1,2,3,4,5,6]) { |array|
array.reverse.each do |element|
puts "array element: #{element}"
end
}
The statements between { } is a block and it gets called by <code>reverse.call(array)</code>within the printlist method.

=== Clojure ===

Clojure[[http://oreilly.com/catalog/9781934356333 31]] is also a functional programming language, and it is a dialect of Lisp. It is not a pure functional language. Instead, it is a dynamically typed language. Just like Java it runs on JVM platform, but its syntax differs from Java. It is represented as :

(functions arguments...)

The function and its arguments are enclosed in paranthesis. It has features like immutable data structures, high-order functions, recursion, and easy and fast java interoperability.

In Clojure's model, value calculation is purely functional. Values never change. New values are functions of old. But, logical identity is well supported via atomic references to values. The value of a reference (state of an identity) is always observable without coordination and freely shareable between threads.
When programs are constructed this way, functional value calculation is independent of identity-value association. This makes clojure easier to understand and test.

====Example Using Functional Technique in Clojure====

Consider the following functional programming example in Clojure-
(defn make-adder [x]
(let [y x]
(fn [z] (+ y z))))
(def add2 (make-adder 2))
(add2 4)

Here,'''''defn make-adder [x]''''' defines a function called ''make-adder''.'''''let [y x]''''' gives a local name y for the value x. Since the scope of any local names is lexical, a function created in the scope of local names will close over their values.'''''fn [z] (+ y z)''''' does the addition of y and z.
''
'''def add2 (make-adder 2)''''' calls the function ''make-adder'' passing the parameter 2 and calls this as ''add2''.Now, ''add2'' has computed 2+z. When '''''add2 4''''' is called it computes 2+4=6

====Example Using Object-Oriented Technique in Clojure====

The following program implements Run-Time Polymorphism which is an object-oriented programming concept.
(defmulti encounter (fn [x y] [(:Species x) (:Species y)]))
(defmethod encounter [:Bunny :Lion] [b l] :run-away)
(defmethod encounter [:Lion :Bunny] [l b] :eat)
(defmethod encounter [:Lion :Lion] [l1 l2] :fight)
(defmethod encounter [:Bunny :Bunny] [b1 b2] :mate)
(def b1 {:Species :Bunny :other :stuff})
(def b2 {:Species :Bunny :other :stuff})
(def l1 {:Species :Lion :other :stuff})
(def l2 {:Species :Lion :other :stuff})

(encounter b1 l1)
-> :run-away
(encounter l1 l2)
-> :fight

Here,'''''defmulti''''' is used to define multiple methods which have the same method name '''''encounter'''''.Depending on the parameters passed to the encounter method, one of the four methods is called.
'''''def''''' defines each of the different species.
When, '''''(encounter b1 l1)''''' is called, the first ''encounter'' method is called with the parameters ''Bunny'' and ''Lion''. As a result, ''run-away'' is printed.

=== Summary of Languages Supporting Mixing ===

Each of the languages contains both functional and object-oriented features. The following table shows how each of the languages have both functional and object-oriented characterics. Not all characteristics of the languages are listed, but enough to demonstrate that the languages each have different ways of mixing object-oriented and functional techniques.

{| class="wikitable" border="2"
|-
!
! Functional Characteristics
! Object-Oriented Characteristics
|-
! Scala
| Immutable objects, the ability to pass functions as parameters, implicits, closures.
| Every value is a object, mutable objects.
|-
! Ruby
| Functional programming used in blocks.
| Everything is an object.
|-
! Clojure
| Immutable data structures, high-order functions, recursion.
| Objects, runtime polymorphism, [http://en.wikipedia.org/wiki/Multiple_dispatch multimethods.]
|-
|}

= Conclusion =
In summary, functional and object-oriented programming can be successfully mixed in programs. Many functional techniques are useful in object-oriented programs. Functional programming integrated with object oriented style leads to:

*Better understanding of program behavior and easier debugging as a result of immutability features
*Use of techniques such as blocks and closures to implement object oriented design and reduce repetitive code
*Lesser complexity and reduction in the number of lines of code

Languages such as Scala, Ruby, and Clojure effectively support mixing these two paradigms, allowing programmers to create cleaner, less buggy object-oriented code.

= References =

Special thanks to writers of previous wiki pages (see last three references below).

#[http://en.wikipedia.org/wiki/Functional_programming Wikipedia - Functional Programming]
#[http://www.cs.cornell.edu/riccardo/prog-smlnj/notes-011001.pdf Notes on programming Standard ML of New Jersey]
#[http://users.dickinson.edu/~braught/courses/cs132f01/classes/code/Factorial.src.html Introduction to Computing - Dickinson College]
#[http://en.wikipedia.org/wiki/Object-oriented_programming Wikipedia - Object Oriented Programming]
#[http://searchsoa.techtarget.com/sDefinition/0,,sid26_gci212681,00.html More on Object Oriented Programming]
#[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas Understanding Ruby Blocks, Procs and Lambdas - Robert Sosinski]
#[http://www.codingday.com/power-of-functional-programming-its-features-and-its-future/ Power of Functional Programming, its Features and its Future]
#[http://skillsmatter.com/podcast/open-source-dot-net/mike-wagg-mark-needham-functional-and-oo-approaches-to-c-sharp-programming Mixing Functional and Object Oriented Approaches to Programming in C#]
#[http://en.wikipedia.org/wiki/Programming_paradigm Programming Paradigm]
#[http://en.wikipedia.org/wiki/Recursion Recursion]
#[http://www.scala-lang.org/ Scala]
#[http://en.wikipedia.org/wiki/Scala_%28programming_language%29 Scala Wikipedia]
#[http://clojure.org/ Clojure]
#[http://www.ruby-lang.org/en/ Ruby]
#[http://en.wikipedia.org/wiki/Standard_ML Standard ML]
#[http://en.wikipedia.org/wiki/Haskell_%28programming_language%29 Haskell]
#[http://en.wikipedia.org/wiki/ML_%28programming_language%29 ML Family]
#[http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java]
#[http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]
#[http://en.wikipedia.org/wiki/C%2B%2B C++ Programming Language]
#[http://en.wikipedia.org/wiki/Visual_Basic_.NET Visual Basic .Net]
# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]
#O'Reilly (2009), "Programming Scala", ''O'Reilly Media Inc.''.
#Dave Thomas, Chad Fowler, Andy Hunt (2006) ''Programming Ruby'', The Pragmatic Bookshelf.
#[http://lamp.epfl.ch/~phaller/doc/haller10-Translucent_functions.pdf Philipp Halle, Lightweight language support for type-based, concurrent event processing, Lausanne, Switzerland, April 2010.]
#[http://biblion.epfl.ch/EPFL/theses/2007/3899/EPFL_TH3899.pdf Burak Emir, Object-Oriented Pattern Matching, EPFL, October 2007].
#[http://math.hws.edu/eck/cs124/downloads/OOP2_from_Univ_KwaZulu-Natal.pdf, Object-Oriented Programming,February 2007].
#[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2010/ch1_1e_az CSC/ECE 517 Fall 2010/ch1 1e az]
#[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2010/ch1_1e_AE CSC/ECE 517 Fall 2010/ch1 1e AE]
#[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2010/ch1_1e_bb CSC/ECE 517 Fall 2010/ch1 1e bb]

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-12T19:18:04Z

Dmcarmon: /* Conclusion */

= Introduction =
This wiki page explores the idea of mixing functional and object-oriented code. Mixing different [http://en.wikipedia.org/wiki/Multi-paradigm#Multi-paradigm_programming_language programming paradigms] is called multi-paradigm programming. There are four major paradigms:

* [http://en.wikipedia.org/wiki/Imperative_paradigm Procedural/imperative paradigms]: Assembly, C, C++, Java, C#
* Object Oriented paradigm : C++, Java, Python, Ruby, Scala, C#
* Functional Paradigm : Lisp, Haskell, Clojure, Scala, OCaml, Ruby
* [http://en.wikipedia.org/wiki/Logic_programming Logic Paradigm]: Prolog

In this wiki we explain how functional and object-oriented paradigms can be mixed. First, we explain what functional and object-oriented style programming is. Secondly, we will show how to apply functional techniques to object-oriented programming. Lastly, we discuss languages that support mixing functional and object-oriented code.

= Functional Programming =

Functional programming treats computation as the evaluation of mathematical functions. It is compute-centric rather than data-centric. Functional programming keeps no global state, does not use for or while loops, and mandates that data is [http://en.wikipedia.org/wiki/Immutable immutable]. Instead, everything is done using functions, usually functions that evaluate mathematical expressions. Each of these functions maintain no internal state and will always produce the same output given the same input.

== Example Contrasting Imperitive and Functional Styles ==

Let's look at an example. Suppose we have a list of numbers and we want to multiply each number in the list by 2. The first approach is the imperitive style:

array[] = {1,2,3,4,5}
for(i=0 ; i<array.length; i++){
array[i] = array[i] * 2;
}

In the above example, array[] is a global variable. If we fail to check the array length, then a runtime exception occurs which might result in the program being crashed. As far as functional style, there is a function called map(func,seq)(in python language) where the function 'func' is applied to each member of seq. The following code is written in a functional style.

numbers = [1,2,3,4,5]
/* define a method called compute on each number in the list */
def compute(var):
var = var * 2
return var
/* Now call the map function */
L = map(compute,numbers)
print L // L will print [1,4,6,8,10]

Notice that there is no global data nor any nested loops and the bound checking is handled internally within the map function. The programmer is relieved of of runtime errors and thus can debug the program easily.

== Advantages of Functional Programming ==

Some advantages of this approach are:
* Easier debugging: Since every thing is broken down into small simple functions, the functions are often easy to debug.
* More compact code: Functional programming typically requires fewer lines of code. Since compution is done by function code reuse is prevelent.
* Nothing depends on state: Because functional programs keep no state information, the functions will always operate the same regardless of the past history of the program.

= Object-oriented Programming =
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] (OOP) is a programming paradigm organized around interacting "objects"(usually instances of a class) rather than "actions" and data rather than logic. A basic principle of OOP is that a program consists of a list of subroutines which can perform individually.

An object-oriented programming language provides support for the following object-oriented concepts--object, class, interface and inheritance. To illustrate this idea clearly and vividly let's review the following example-- your limbs. The "Limbs" is a class. Your body has two objects of type "limbs", named arms and legs. Their main functions are controlled/ managed by a set of biological signals sent from central nervous system( through an interface). So the nervous system is an interface which your body uses to interact with your limbs. The "limbs" is a well architected class. The "legs" has a subclass which contains "left leg" and "Right leg". The "legs" is being re-used to create the left leg and right leg by slightly changing the properties of it. If the "legs" owns attributes like length, color of skin etc, then the subclass, which contains "left leg" and "right leg" in this case, automatically inherit these attributes( that is called inheritance).

We could code in object-oriented paradigm as:

class Limbs
#define a class of limbs
def initialize(limbs,length,colorofskin)
@limbs=limbs
@length=length
@colorofskin=colorofskin
end
end
limbs=Limbs.new("legs","100cm","white")
#create a new object in class "Limbs"
class Legs<Limbs
#create a subclass "Legs",which belong to class"Limbs"
def initialize(legs,length,colorofskin)
super(length,colorofskin)
@legs=legs
end
end
legs=legs.new("left leg")
#create a new object in class of "Legs"

== Features of Object-oriented Programming ==
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]. A programmer can simply create a new object that inherits many of its features from super-class. And also, they can overwrite existing operations or add new ones.This makes object-oriented programs easier to modify.
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation].This refers to hiding the internal representation of the object from the outside view. You can hide unnecessary implementation details from the object user. One of the benefits of encapsulation is data protection.
* [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism].This allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects. Consider the operator '+', for numbers it will generate the sum, but for strings it will produce a third string which concatenates the input strings.

== Advantages of Object-oriented Programming ==
* Simplicity: we use software objects to simulate real world objects, so the complexity is reduced and the program structure is very clear.
* Modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system.
* Modifiability: programmers can easily make minor changes in the data representation or operations in an OOP. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods.
* Extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones.
* Maintainability: objects can be maintained separately, making locating and fixing problems easier.
* Re-usability: objects can be reused in different programs.

= Mixing Functional and Object-Oriented Programming =

In object-oriented world, data and operations are grouped together into modular units called objects and we combine objects into structured networks to form a program. The results are depend on arguments and objects' state at method invocation time. While in functional world, the basic elements are variables in the mathematical sense and functions in the mathematical sense. Functional programming can reduce side-effects. If there is no side-effects, it means your can apply the function at anywhere freely. No matter how you apply this function, the same input arguments produce the same results.

Obviously if we apply functional programming techniques to object-oriented programming, everything can be done better--the code is easier to write, runs faster, and uses less memory.

== Functional Techniques useful for Object-Oriented Programming ==

According to above-mentioned information, we can perform functional programming on an object-oriented programming language because:
1). object can have constant state
2). method can depend only on its arguments and context available at method definition time

Combining both these paradigms not only provide us a robust design structure, but also enable the programmers to develop solutions to complex problems quickly and effectively. One of the cornerstone of mixing functional and object-oriented code is treating functions as objects.It means that we can pass functions as arguments, store it and return them from other functions. This is highly useful in an user interface code where it can be used as call back functions which gets called when an event occurs(event driven programming).

Some of the basic features of Functional Programming which can be combined with Object Oriented paradigm are:

* Lambda Calculus
* Currying
* Powerful pattern matching

Let us now understand how each of the above feature of Functional language fits in the Object Oriented paradigm.

=== Lambda Calculus ===
Lambda calculus is the most critical basis of functional programming. A lambda expression is an anonymous expression that contain expressions and statements.Each expression stands for a function with one parameter.

Let consider the following function:

def f(x)
return x**2
print f(4)

We can use a lambda calculus to compute this expression without assigning it to a variable:

(lambda x:x**x)(4)

We can see that these two code snippets have the same results. It is more concise and flexible to define with lambda.
The above is a pure functional approach. In order to make code more state-less and concise, lambdas can be embedded inside the object-oriented language. The below code in Python demonstrates the use of lambda in a closure:

def fun(x):
return x%3==0
str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
filter(fun,str)

The above code works to find numbers which are divisible by 3.
We can simplify the code by the use of lambda as following:

str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print filter(lambda x: x%3==0, str)

=== Currying ===
In the above information we have learned much about lambda calculus, which take care of one argument, now let me introduce you another concept called currying functions which takes in multiple arguments and returns a chain of functions with lesser number of arguments. It can be interpreted as the technique to decompose a function that takes n parameters into n functions and each of the n functions takes one parameter.

Currying is really an interesting concept. Let's take a sample code in JavaScript to understand it:

//This is a function for calculating x+y. The difference between this function and general is that this is a currying function.
function add(x, y)
{
if(x!=null && y!=null) return x + y;
else if(x!=null && y==null) return function(y)
{
return x + y; //return a closure with parameter y for subsequent calculations
}
else if(x==null && y!=null) return function(x)
{
return x + y; //return a closure with parameter x for subsequent calculations
}
}
var a = add(3, 4); //compute the value of (3+4) and return the value of 7
var b = add(2); //add(2) is equal to a function of (2+y)
var c = b(10); //pass 10 to y, and return the value of (2+10) which is 12

In the above sample, b=add(2) gives us a currying function of add(), which is function of y when x=2.

More interestingly, we can define a currying form of arbitrary functions.
function Foo(x, y, z, w)
{
var args = arguments;
if(Foo.length < args.length)
return function()
{
return args.callee.apply(Array.apply([], args).concat(Array.apply([], arguments)));
}
else
return x + y – z * w;
}

=== Pattern Matching ===
What is pattern matching? I think all of you do know what it is, you just don't know you know it. The semantics are equally straightforward.Firstly, we evaluate the value expression, then we walk down the clauses. For each one, we see if the pattern matches the value. If so, we execute the body and end. Simply put, pattern matching is a technique to search string for the occurrence of any patterns or regularity.

Pattern matching allows you to do different calculations according to different identifier values. It looks the same with nests of "if...else" statements, as well as "switch" statements in C++ and C#. But here it is much stronger and more flexible.

You may find that there are two main types of usage of pattern matching:
* To search and find a particular value.
* To find a particular value and replace it with selected text.

For example, the following code snippets writes a message if a string contains the text Perl or Python:

if line =~ /Perl|Python/
puts "Scripting language mentioned:#{line}"
end

Next, let us consider the following sample in which a part of a string matched by a regular expression can be replaced with different text using one of Ruby’s substitution methods:

line.sub(/Perl/, 'Ruby') # replace first 'Perl' with 'Ruby'
line.gsub(/Python/, 'Ruby') # replace every 'Python' with 'Ruby'

Advantages of Pattern Matching:
* It allows concise, readable deconstruction of complex data structures.
* It gives a possible separation of data structure and respective functionality.

== Examples of Mixing ==

A number of programming languages support mixing of both functional and object-oriented code. Three of these (Scala, Ruby, and Conjure), are described in more detail below.

=== Scala ===

[http://www.scala-lang.org/ Scala] is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. [http://www.scala-lang.org/ Scala] was conceived in 2001 and implemented by Martin Odersky. It supports mixing functional and object-oriented code.

==== Mixing Functional and Object-Oriented Code in Scala ====
[http://www.scala-lang.org/ Scala] is a strange specimen. It is a complete blend of object-oriented and functional programming. How can this happen? The functional world advocates immutability, but the object-oriented world focuses on the state and how to change it to fit your needs. [http://www.scala-lang.org/ Scala] allows you create both mutable and immutable objects. Consider the following example,
val str: String = "Hello World"
In the first line, an immutable version(a misnomer indeed) of <code>str</code> is being created . A rough translation into Java is below:

final String str = "Hello World"; //note the extra semi-colon
Consider the next example below,
val list: List[String] = List("Scala", "is", "the coolest", "language", "in the world!")

The same code can be written in Java as:

List<String> mutableList = new ArrayList<String>();
list.add("Scala");
list.add("is");
list.add("the coolest");
list.add("language");
list.add("in the world!");
List<String> immutableList = Collections.immutableList(mutableList);

Compared to Java, [http://www.scala-lang.org/ Scala] reduces the total number of lines you need to type and at the same time looks much simpler and less verbose. Even though the above example shows an immutable collection, scala also provides mutable collections and object types in the package <code>scala.collection.mutable.*</code>

As can be observed, even though [http://www.scala-lang.org/ Scala] advocates immutability, it does not restrict you from creating mutable objects. So it's the best of both worlds. Another part of the functional world is the concept of functions as ''''first class members'''' of the language. Some of the common languages like Ruby, Python and JavaScript all incorporate this feature. In the sense you can pass around functions to methods as a parameter. Enough talking;

Let us have a class say <code>'Person'</code> which has properties, <code>name</code> and another variable <code>age</code>.
In Java:

class Person{
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String s){
this.name = s;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}

In [http://www.scala-lang.org/ Scala]:
case class Person(name: String, age: Int)

This single line is equivalent to the above java code! Getters for <code>name</code> and <code>age</code>, <code>equals()</code>, and <code>hashCode()</code> method are automatically generated for you by the compiler. Isn't this an awesome feature?

Now assume we have a list of persons and we want to filter out all the persons who are of age 23. How would you do that in Java?

List<Person> persons; //has a bunch of person objects in it.
List<Person> twentyThree = new ArrayList<Person>();
for(Person p: persons){
if(p.getAge() == 23){
twentyThree.add(p);
}
}

In [http://www.scala-lang.org/ Scala]:

val twentyThree: List[Person] = persons.filter( _.age == 23)

That's it! In case you are wondering whats going on, filter is a method present on scala.List class and the code block <code>_.age == 23</code> is a function created on the fly and passed onto the filter method. More precisely its called a [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] - a functional concept which can be emulated in java only using anonymous inner classes. Scala's compiler transforms our one line function into some anonymous inner classes when generating java byte code, allowing developers to define functions in a simple manner.

In fact, every function is an object in [http://www.scala-lang.org/ Scala]. Scala's standard library has a number of functions which are objects themselves.

==== Implicits in Scala ====
In almost all programming languages, there is a necessity to profile the running time of the procedures and tune its performance. The old way of doing things in Java would be:

public class Main{
public static int factorial(int x){
if(x == 0 || x == 1) return 1
else return x * factorial(x-1)
}
public static void main(String [] args){
long beforeTime = System.currentTimeMillis();
int result = factorial(5);
System.out.println("Total time taken to execute factorial(5) is " + (System.currentTimeMillis() - result)+"ms");
System.out.println("factorial(5) = " + result);
}
}

However, if you want to find out the execution time of some other method, you would have to type in all the above lines again. So much for code re-use or [http://en.wikipedia.org/wiki/DRY DRY (dont't repeat yourself)]! Lets see how its done in [http://www.scala-lang.org/ Scala].

object Main{
def main(args: Array[String]){
def factorial(x: Int):Int = x match{
case 0 | 1 => 1
case _ => x * factorial(x-1)
}
import System.currentTimeMillis
def timeIt(msg: String = "Time to execute is: ")(func: => Unit){
val before = currentTimeMillis
func
println(msg + (currentTimeMillis - before) + "ms")
}
timeIt("Total time taken to execute factorial(5) is "){
val result = factorial(5)
println("factorial(5) = " + result)
}
}
//would print: factorial(5) = 120
// Total time taken to execute factorial(5) is 1ms

That's not right! The function <code>timeIt</code> looks like a feature built into the language. Try saving the above code into a separate file and run it - It will still work. Using this feature, it is possible to build powerful DSL languages which can run at full speed on JVM.

Ruby allows you to add new methods to objects. Since you are splitting open the class and adding/overriding methods (in)|(to) the class, this feature is often called [http://en.wikipedia.org/wiki/Monkey_patch Monkey Patching]. Because other libraries may depend on some methods which you changed, often this leads to unexpected behavior at runtime. However, Scala provides yet another feature called [http://en.wikipedia.org/wiki/Implicit_function implicits] which helps you do this better.

In Java, <code>String</code> class is <code>final</code> so there is no way you can add new methods to it. But with implicits you can do more! Suppose you have some text in memory and you know it represents a number. But in Java the usual way to convert string to int is to do a <code>Integer.parseInt(string)</code> which seems so unnecessary. Let us make our lives easier...

implicit def strToInt(str: String) = new {
def asInt = Integer.parseInt(str)
}
val str = "1234"
println(str.asInt * 3) //prints out 3702

The above code gives us an impression as if String class has gained new <code>asInt</code> method. Can static object oriented languages do this? No! Infact scala cheats by calling our implicits to convert it into a different object as and when needed.

The above functionalities are purely object oriented, yet they are safe. They don't pollute the global namespace, unlike Ruby or Python.

=== Ruby ===

Ruby is another language that, like Scala, supports mixing functional and object-oriented code. It is a dynamically typed Object-Oriented Language which supports multiple programming paradigms, including functional, object-oriented, imperative and reflective. In Ruby, everything is an object, every bit of information and code can have its own properties and actions. However, Ruby’s blocks can be functional. A Ruby programmer can attach a closure to any method, which generates a functional block inside an object oriented code. A closure is a piece of code that can access the lexical environment of its definition [http://www.ruby-lang.org/en/ 11].

==== Ruby Mixing Example ====

Consider the following code snippet in Ruby which uses Object Oriented concepts like Classes and functional programming concepts like lambda.

class Multiply
def initialize(n)
@block = lambda {|a| n * a}
end
def mul(a)
@block.call a
end
end
twoMultiplier = Multiply.new 2
puts twoMultiplier.mul(6)

Here,'''''@block''''' is a closure. When we call the class ''Multiply'' using '''''twoAdder = Multiply.new 2''''' ,the ''initialize'' method is called by passing the parameter 2. Here n=2 binds itself to the block. So @block will be 2*a, that is,the closure remembers the parameter with which the initialize method was called even after the initialize method exits.

This value is used when the block is called in the add method.
Thus,'''''twoMultiplier.mul(6)''''' will return 2*6 = 12

==== Functional Style Coding in Ruby Blocks ====

Blocks are basically nameless functions which can be passed to a function and then that function can invoke the passed in nameless function. This is a common style called [http://en.wikipedia.org/wiki/Higher-order_function higher order functions] among languages that handle functions as first class objects. Basically blocks can be designed for loop abstraction and lets the user to design their own way of iterating the values, thereby hiding the implementation details.
For example, if we want to iterate backwards from the end to the beginning without revealing its internal implementations, we could implement the loop logic inside the block and pass it to a method or function.

Here is a [http://www.ruby-lang.org/en/ Ruby] implementation of block:

def printlist(array,&reverse)
array.each do |element|
puts "array element: #{element}"
end
reverse.call(array) /* Here it prints the reverse implementation of list*/
end

printlist([1,2,3,4,5,6]) { |array|
array.reverse.each do |element|
puts "array element: #{element}"
end
}
The statements between { } is a block and it gets called by <code>reverse.call(array)</code>within the printlist method.

=== Clojure ===

Clojure[[http://oreilly.com/catalog/9781934356333 31]] is also a functional programming language, and it is a dialect of Lisp. It is not a pure functional language. Instead, it is a dynamically typed language. Just like Java it runs on JVM platform, but its syntax differs from Java. It is represented as :

(functions arguments...)

The function and its arguments are enclosed in paranthesis. It has features like immutable data structures, high-order functions, recursion, and easy and fast java interoperability.

In Clojure's model, value calculation is purely functional. Values never change. New values are functions of old. But, logical identity is well supported via atomic references to values. The value of a reference (state of an identity) is always observable without coordination and freely shareable between threads.
When programs are constructed this way, functional value calculation is independent of identity-value association. This makes clojure easier to understand and test.

====Example Using Functional Technique in Clojure====

Consider the following functional programming example in Clojure-
(defn make-adder [x]
(let [y x]
(fn [z] (+ y z))))
(def add2 (make-adder 2))
(add2 4)

Here,'''''defn make-adder [x]''''' defines a function called ''make-adder''.'''''let [y x]''''' gives a local name y for the value x. Since the scope of any local names is lexical, a function created in the scope of local names will close over their values.'''''fn [z] (+ y z)''''' does the addition of y and z.
''
'''def add2 (make-adder 2)''''' calls the function ''make-adder'' passing the parameter 2 and calls this as ''add2''.Now, ''add2'' has computed 2+z. When '''''add2 4''''' is called it computes 2+4=6

====Example Using Object-Oriented Technique in Clojure====

The following program implements Run-Time Polymorphism which is an object-oriented programming concept.
(defmulti encounter (fn [x y] [(:Species x) (:Species y)]))
(defmethod encounter [:Bunny :Lion] [b l] :run-away)
(defmethod encounter [:Lion :Bunny] [l b] :eat)
(defmethod encounter [:Lion :Lion] [l1 l2] :fight)
(defmethod encounter [:Bunny :Bunny] [b1 b2] :mate)
(def b1 {:Species :Bunny :other :stuff})
(def b2 {:Species :Bunny :other :stuff})
(def l1 {:Species :Lion :other :stuff})
(def l2 {:Species :Lion :other :stuff})

(encounter b1 l1)
-> :run-away
(encounter l1 l2)
-> :fight

Here,'''''defmulti''''' is used to define multiple methods which have the same method name '''''encounter'''''.Depending on the parameters passed to the encounter method, one of the four methods is called.
'''''def''''' defines each of the different species.
When, '''''(encounter b1 l1)''''' is called, the first ''encounter'' method is called with the parameters ''Bunny'' and ''Lion''. As a result, ''run-away'' is printed.

=== Summary of Languages Supporting Mixing ===

Each of the languages contains both functional and object-oriented features. The following table shows how each of the languages have both functional and object-oriented characterics. Not all characteristics of the languages are listed, but enough to demonstrate that the languages each have different ways of mixing object-oriented and functional techniques.

{| class="wikitable" border="2"
|-
!
! Functional Characteristics
! Object-Oriented Characteristics
|-
! Scala
| Immutable objects, the ability to pass functions as parameters, implicits, closures.
| Every value is a object, mutable objects.
|-
! Ruby
| Functional programming used in blocks.
| Everything is an object.
|-
! Clojure
| Immutable data structures, high-order functions, recursion.
| Objects, runtime polymorphism, [http://en.wikipedia.org/wiki/Multiple_dispatch multimethods.]
|-
|}

= Conclusion =
In summary, functional and object-oriented programming can be successfully mixed in programs. Many functional techniques are useful in object-oriented programs. Functional programming integrated with object oriented style leads to:

*Better understanding of program behavior and easier debugging as a result of immutability features
*Use of techniques such as blocks and closures to implement object oriented design and reduce repetitive code
*Lesser complexity and reduction in the number of lines of code

Languages such as Scala, Ruby, and Clojure effectively support mixing these two paradigms, allowing programmers to create cleaner, less buggy object-oriented code.

= References =
#[http://en.wikipedia.org/wiki/Functional_programming Wikipedia - Functional Programming]
#[http://www.cs.cornell.edu/riccardo/prog-smlnj/notes-011001.pdf Notes on programming Standard ML of New Jersey]
#[http://users.dickinson.edu/~braught/courses/cs132f01/classes/code/Factorial.src.html Introduction to Computing - Dickinson College]
#[http://en.wikipedia.org/wiki/Object-oriented_programming Wikipedia - Object Oriented Programming]
#[http://searchsoa.techtarget.com/sDefinition/0,,sid26_gci212681,00.html More on Object Oriented Programming]
#[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas Understanding Ruby Blocks, Procs and Lambdas - Robert Sosinski]
#[http://www.codingday.com/power-of-functional-programming-its-features-and-its-future/ Power of Functional Programming, its Features and its Future]
#[http://skillsmatter.com/podcast/open-source-dot-net/mike-wagg-mark-needham-functional-and-oo-approaches-to-c-sharp-programming Mixing Functional and Object Oriented Approaches to Programming in C#]
#[http://en.wikipedia.org/wiki/Programming_paradigm Programming Paradigm]
#[http://en.wikipedia.org/wiki/Recursion Recursion]
#[http://www.scala-lang.org/ Scala]
#[http://en.wikipedia.org/wiki/Scala_%28programming_language%29 Scala Wikipedia]
#[http://clojure.org/ Clojure]
#[http://www.ruby-lang.org/en/ Ruby]
#[http://en.wikipedia.org/wiki/Standard_ML Standard ML]
#[http://en.wikipedia.org/wiki/Haskell_%28programming_language%29 Haskell]
#[http://en.wikipedia.org/wiki/ML_%28programming_language%29 ML Family]
#[http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java]
#[http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]
#[http://en.wikipedia.org/wiki/C%2B%2B C++ Programming Language]
#[http://en.wikipedia.org/wiki/Visual_Basic_.NET Visual Basic .Net]
# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]
#O'Reilly (2009), "Programming Scala", ''O'Reilly Media Inc.''.
#Dave Thomas, Chad Fowler, Andy Hunt (2006) ''Programming Ruby'', The Pragmatic Bookshelf.
#[http://lamp.epfl.ch/~phaller/doc/haller10-Translucent_functions.pdf Philipp Halle, Lightweight language support for type-based, concurrent event processing, Lausanne, Switzerland, April 2010.]
#[http://biblion.epfl.ch/EPFL/theses/2007/3899/EPFL_TH3899.pdf Burak Emir, Object-Oriented Pattern Matching, EPFL, October 2007].
#[http://math.hws.edu/eck/cs124/downloads/OOP2_from_Univ_KwaZulu-Natal.pdf, Object-Oriented Programming,February 2007].

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-12T19:12:47Z

Dmcarmon: /* Conclusion */

= Introduction =
This wiki page explores the idea of mixing functional and object-oriented code. Mixing different [http://en.wikipedia.org/wiki/Multi-paradigm#Multi-paradigm_programming_language programming paradigms] is called multi-paradigm programming. There are four major paradigms:

* [http://en.wikipedia.org/wiki/Imperative_paradigm Procedural/imperative paradigms]: Assembly, C, C++, Java, C#
* Object Oriented paradigm : C++, Java, Python, Ruby, Scala, C#
* Functional Paradigm : Lisp, Haskell, Clojure, Scala, OCaml, Ruby
* [http://en.wikipedia.org/wiki/Logic_programming Logic Paradigm]: Prolog

In this wiki we explain how functional and object-oriented paradigms can be mixed. First, we explain what functional and object-oriented style programming is. Secondly, we will show how to apply functional techniques to object-oriented programming. Lastly, we discuss languages that support mixing functional and object-oriented code.

= Functional Programming =

Functional programming treats computation as the evaluation of mathematical functions. It is compute-centric rather than data-centric. Functional programming keeps no global state, does not use for or while loops, and mandates that data is [http://en.wikipedia.org/wiki/Immutable immutable]. Instead, everything is done using functions, usually functions that evaluate mathematical expressions. Each of these functions maintain no internal state and will always produce the same output given the same input.

== Example Contrasting Imperitive and Functional Styles ==

Let's look at an example. Suppose we have a list of numbers and we want to multiply each number in the list by 2. The first approach is the imperitive style:

array[] = {1,2,3,4,5}
for(i=0 ; i<array.length; i++){
array[i] = array[i] * 2;
}

In the above example, array[] is a global variable. If we fail to check the array length, then a runtime exception occurs which might result in the program being crashed. As far as functional style, there is a function called map(func,seq)(in python language) where the function 'func' is applied to each member of seq. The following code is written in a functional style.

numbers = [1,2,3,4,5]
/* define a method called compute on each number in the list */
def compute(var):
var = var * 2
return var
/* Now call the map function */
L = map(compute,numbers)
print L // L will print [1,4,6,8,10]

Notice that there is no global data nor any nested loops and the bound checking is handled internally within the map function. The programmer is relieved of of runtime errors and thus can debug the program easily.

== Advantages of Functional Programming ==

Some advantages of this approach are:
* Easier debugging: Since every thing is broken down into small simple functions, the functions are often easy to debug.
* More compact code: Functional programming typically requires fewer lines of code. Since compution is done by function code reuse is prevelent.
* Nothing depends on state: Because functional programs keep no state information, the functions will always operate the same regardless of the past history of the program.

= Object-oriented Programming =
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] (OOP) is a programming paradigm organized around interacting "objects"(usually instances of a class) rather than "actions" and data rather than logic. A basic principle of OOP is that a program consists of a list of subroutines which can perform individually.

An object-oriented programming language provides support for the following object-oriented concepts--object, class, interface and inheritance. To illustrate this idea clearly and vividly let's review the following example-- your limbs. The "Limbs" is a class. Your body has two objects of type "limbs", named arms and legs. Their main functions are controlled/ managed by a set of biological signals sent from central nervous system( through an interface). So the nervous system is an interface which your body uses to interact with your limbs. The "limbs" is a well architected class. The "legs" has a subclass which contains "left leg" and "Right leg". The "legs" is being re-used to create the left leg and right leg by slightly changing the properties of it. If the "legs" owns attributes like length, color of skin etc, then the subclass, which contains "left leg" and "right leg" in this case, automatically inherit these attributes( that is called inheritance).

We could code in object-oriented paradigm as:

class Limbs
#define a class of limbs
def initialize(limbs,length,colorofskin)
@limbs=limbs
@length=length
@colorofskin=colorofskin
end
end
limbs=Limbs.new("legs","100cm","white")
#create a new object in class "Limbs"
class Legs<Limbs
#create a subclass "Legs",which belong to class"Limbs"
def initialize(legs,length,colorofskin)
super(length,colorofskin)
@legs=legs
end
end
legs=legs.new("left leg")
#create a new object in class of "Legs"

== Features of Object-oriented Programming ==
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]. A programmer can simply create a new object that inherits many of its features from super-class. And also, they can overwrite existing operations or add new ones.This makes object-oriented programs easier to modify.
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation].This refers to hiding the internal representation of the object from the outside view. You can hide unnecessary implementation details from the object user. One of the benefits of encapsulation is data protection.
* [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism].This allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects. Consider the operator '+', for numbers it will generate the sum, but for strings it will produce a third string which concatenates the input strings.

== Advantages of Object-oriented Programming ==
* Simplicity: we use software objects to simulate real world objects, so the complexity is reduced and the program structure is very clear.
* Modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system.
* Modifiability: programmers can easily make minor changes in the data representation or operations in an OOP. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods.
* Extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones.
* Maintainability: objects can be maintained separately, making locating and fixing problems easier.
* Re-usability: objects can be reused in different programs.

= Mixing Functional and Object-Oriented Programming =

Motivation for Mixing

== Functional Techniques useful for Object-Oriented Programming ==
In object-oriented world, data and operations are grouped together into modular units called objects and we combine objects into structured networks to form a program. The results are depend on arguments and objects' state at method invocation time. While in functional world, the basic elements are variables in the mathematical sense and functions in the mathematical sense. Functional programming can reduce side-effects. If there is no side-effects, it means your can apply the function at anywhere freely. No matter how you apply this function, the same input arguments produce the same results.

According to above-mentioned information, we can perform functional programming on an object-oriented programming language because:
1). object can have constant state
2). method can depend only on its arguments and context available at method definition time

Combining both these paradigms not only provide us a robust design structure, but also enable the programmers to develop solutions to complex problems quickly and effectively. One of the cornerstone of mixing functional and object-oriented code is treating functions as objects.It means that we can pass functions as arguments, store it and return them from other functions. This is highly useful in an user interface code where it can be used as call back functions which gets called when an event occurs(event driven programming).

Some of the basic features of Functional Programming which can be combined with Object Oriented paradigm are:

* Lambda Calculus
* Currying
* Powerful pattern matching

Let us now understand how each of the above feature of Functional language fits in the Object Oriented paradigm.

=== Lambda Calculus ===
Lambda calculus is the most critical basis of functional programming. A lambda expression is an anonymous expression that contain expressions and statements.Each expression stands for a function with one parameter.

Let consider the following function:

def f(x)
return x**2
print f(4)

We can use a lambda calculus to compute this expression without assigning it to a variable:

(lambda x:x**x)(4)

We can see that these two code snippets have the same results. It is more concise and flexible to define with lambda.
The above is a pure functional approach. In order to make code more state-less and concise, lambdas can be embedded inside the object-oriented language. The below code in Python demonstrates the use of lambda in a closure:

def fun(x):
return x%3==0
str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
filter(fun,str)

The above code works to find numbers which are divisible by 3.
We can simplify the code by the use of lambda as following:

str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print filter(lambda x: x%3==0, str)

=== Currying ===
In the above information we have learned much about lambda calculus, which take care of one argument, now let me introduce you another concept called currying functions which takes in multiple arguments and returns a chain of functions with lesser number of arguments. It can be interpreted as the technique to decompose a function that takes n parameters into n functions and each of the n functions takes one parameter.

Currying is really an interesting concept. Let's take a sample code in JavaScript to understand it:

//This is a function for calculating x+y. The difference between this function and general is that this is a currying function.
function add(x, y)
{
if(x!=null && y!=null) return x + y;
else if(x!=null && y==null) return function(y)
{
return x + y; //return a closure with parameter y for subsequent calculations
}
else if(x==null && y!=null) return function(x)
{
return x + y; //return a closure with parameter x for subsequent calculations
}
}
var a = add(3, 4); //compute the value of (3+4) and return the value of 7
var b = add(2); //add(2) is equal to a function of (2+y)
var c = b(10); //pass 10 to y, and return the value of (2+10) which is 12

In the above sample, b=add(2) gives us a currying function of add(), which is function of y when x=2.

More interestingly, we can define a currying form of arbitrary functions.
function Foo(x, y, z, w)
{
var args = arguments;
if(Foo.length < args.length)
return function()
{
return args.callee.apply(Array.apply([], args).concat(Array.apply([], arguments)));
}
else
return x + y – z * w;
}

=== Pattern Matching ===
What is pattern matching? I think all of you do know what it is, you just don't know you know it. The semantics are equally straightforward.Firstly, we evaluate the value expression, then we walk down the clauses. For each one, we see if the pattern matches the value. If so, we execute the body and end. Simply put, pattern matching is a technique to search string for the occurrence of any patterns or regularity.

Pattern matching allows you to do different calculations according to different identifier values. It looks the same with nests of "if...else" statements, as well as "switch" statements in C++ and C#. But here it is much stronger and more flexible.

You may find that there are two main types of usage of pattern matching:
* To search and find a particular value.
* To find a particular value and replace it with selected text.

For example, the following code snippets writes a message if a string contains the text Perl or Python:

if line =~ /Perl|Python/
puts "Scripting language mentioned:#{line}"
end

Next, let us consider the following sample in which a part of a string matched by a regular expression can be replaced with different text using one of Ruby’s substitution methods:

line.sub(/Perl/, 'Ruby') # replace first 'Perl' with 'Ruby'
line.gsub(/Python/, 'Ruby') # replace every 'Python' with 'Ruby'

Advantages of Pattern Matching:
* It allows concise, readable deconstruction of complex data structures.
* It gives a possible separation of data structure and respective functionality.

== Examples of Mixing ==

A number of programming languages support mixing of both functional and object-oriented code. Three of these (Scala, Ruby, and Conjure), are described in more detail below.

=== Scala ===

[http://www.scala-lang.org/ Scala] is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. [http://www.scala-lang.org/ Scala] was conceived in 2001 and implemented by Martin Odersky. It supports mixing functional and object-oriented code.

==== Mixing Functional and Object-Oriented Code in Scala ====
[http://www.scala-lang.org/ Scala] is a strange specimen. It is a complete blend of object-oriented and functional programming. How can this happen? The functional world advocates immutability, but the object-oriented world focuses on the state and how to change it to fit your needs. [http://www.scala-lang.org/ Scala] allows you create both mutable and immutable objects. Consider the following example,
val str: String = "Hello World"
In the first line, an immutable version(a misnomer indeed) of <code>str</code> is being created . A rough translation into Java is below:

final String str = "Hello World"; //note the extra semi-colon
Consider the next example below,
val list: List[String] = List("Scala", "is", "the coolest", "language", "in the world!")

The same code can be written in Java as:

List<String> mutableList = new ArrayList<String>();
list.add("Scala");
list.add("is");
list.add("the coolest");
list.add("language");
list.add("in the world!");
List<String> immutableList = Collections.immutableList(mutableList);

Compared to Java, [http://www.scala-lang.org/ Scala] reduces the total number of lines you need to type and at the same time looks much simpler and less verbose. Even though the above example shows an immutable collection, scala also provides mutable collections and object types in the package <code>scala.collection.mutable.*</code>

As can be observed, even though [http://www.scala-lang.org/ Scala] advocates immutability, it does not restrict you from creating mutable objects. So it's the best of both worlds. Another part of the functional world is the concept of functions as ''''first class members'''' of the language. Some of the common languages like Ruby, Python and JavaScript all incorporate this feature. In the sense you can pass around functions to methods as a parameter. Enough talking;

Let us have a class say <code>'Person'</code> which has properties, <code>name</code> and another variable <code>age</code>.
In Java:

class Person{
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String s){
this.name = s;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}

In [http://www.scala-lang.org/ Scala]:
case class Person(name: String, age: Int)

This single line is equivalent to the above java code! Getters for <code>name</code> and <code>age</code>, <code>equals()</code>, and <code>hashCode()</code> method are automatically generated for you by the compiler. Isn't this an awesome feature?

Now assume we have a list of persons and we want to filter out all the persons who are of age 23. How would you do that in Java?

List<Person> persons; //has a bunch of person objects in it.
List<Person> twentyThree = new ArrayList<Person>();
for(Person p: persons){
if(p.getAge() == 23){
twentyThree.add(p);
}
}

In [http://www.scala-lang.org/ Scala]:

val twentyThree: List[Person] = persons.filter( _.age == 23)

That's it! In case you are wondering whats going on, filter is a method present on scala.List class and the code block <code>_.age == 23</code> is a function created on the fly and passed onto the filter method. More precisely its called a [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] - a functional concept which can be emulated in java only using anonymous inner classes. Scala's compiler transforms our one line function into some anonymous inner classes when generating java byte code, allowing developers to define functions in a simple manner.

In fact, every function is an object in [http://www.scala-lang.org/ Scala]. Scala's standard library has a number of functions which are objects themselves.

==== Implicits in Scala ====
In almost all programming languages, there is a necessity to profile the running time of the procedures and tune its performance. The old way of doing things in Java would be:

public class Main{
public static int factorial(int x){
if(x == 0 || x == 1) return 1
else return x * factorial(x-1)
}
public static void main(String [] args){
long beforeTime = System.currentTimeMillis();
int result = factorial(5);
System.out.println("Total time taken to execute factorial(5) is " + (System.currentTimeMillis() - result)+"ms");
System.out.println("factorial(5) = " + result);
}
}

However, if you want to find out the execution time of some other method, you would have to type in all the above lines again. So much for code re-use or [http://en.wikipedia.org/wiki/DRY DRY (dont't repeat yourself)]! Lets see how its done in [http://www.scala-lang.org/ Scala].

object Main{
def main(args: Array[String]){
def factorial(x: Int):Int = x match{
case 0 | 1 => 1
case _ => x * factorial(x-1)
}
import System.currentTimeMillis
def timeIt(msg: String = "Time to execute is: ")(func: => Unit){
val before = currentTimeMillis
func
println(msg + (currentTimeMillis - before) + "ms")
}
timeIt("Total time taken to execute factorial(5) is "){
val result = factorial(5)
println("factorial(5) = " + result)
}
}
//would print: factorial(5) = 120
// Total time taken to execute factorial(5) is 1ms

That's not right! The function <code>timeIt</code> looks like a feature built into the language. Try saving the above code into a separate file and run it - It will still work. Using this feature, it is possible to build powerful DSL languages which can run at full speed on JVM.

Ruby allows you to add new methods to objects. Since you are splitting open the class and adding/overriding methods (in)|(to) the class, this feature is often called [http://en.wikipedia.org/wiki/Monkey_patch Monkey Patching]. Because other libraries may depend on some methods which you changed, often this leads to unexpected behavior at runtime. However, Scala provides yet another feature called [http://en.wikipedia.org/wiki/Implicit_function implicits] which helps you do this better.

In Java, <code>String</code> class is <code>final</code> so there is no way you can add new methods to it. But with implicits you can do more! Suppose you have some text in memory and you know it represents a number. But in Java the usual way to convert string to int is to do a <code>Integer.parseInt(string)</code> which seems so unnecessary. Let us make our lives easier...

implicit def strToInt(str: String) = new {
def asInt = Integer.parseInt(str)
}
val str = "1234"
println(str.asInt * 3) //prints out 3702

The above code gives us an impression as if String class has gained new <code>asInt</code> method. Can static object oriented languages do this? No! Infact scala cheats by calling our implicits to convert it into a different object as and when needed.

The above functionalities are purely object oriented, yet they are safe. They don't pollute the global namespace, unlike Ruby or Python.

=== Ruby ===

Ruby is another language that, like Scala, supports mixing functional and object-oriented code. It is a dynamically typed Object-Oriented Language which supports multiple programming paradigms, including functional, object-oriented, imperative and reflective. In Ruby, everything is an object, every bit of information and code can have its own properties and actions. However, Ruby’s blocks can be functional. A Ruby programmer can attach a closure to any method, which generates a functional block inside an object oriented code. A closure is a piece of code that can access the lexical environment of its definition [http://www.ruby-lang.org/en/ 11].

==== Ruby Mixing Example ====

Consider the following code snippet in Ruby which uses Object Oriented concepts like Classes and functional programming concepts like lambda.

class Multiply
def initialize(n)
@block = lambda {|a| n * a}
end
def mul(a)
@block.call a
end
end
twoMultiplier = Multiply.new 2
puts twoMultiplier.mul(6)

Here,'''''@block''''' is a closure. When we call the class ''Multiply'' using '''''twoAdder = Multiply.new 2''''' ,the ''initialize'' method is called by passing the parameter 2. Here n=2 binds itself to the block. So @block will be 2*a, that is,the closure remembers the parameter with which the initialize method was called even after the initialize method exits.

This value is used when the block is called in the add method.
Thus,'''''twoMultiplier.mul(6)''''' will return 2*6 = 12

==== Functional Style Coding in Ruby Blocks ====

Blocks are basically nameless functions which can be passed to a function and then that function can invoke the passed in nameless function. This is a common style called [http://en.wikipedia.org/wiki/Higher-order_function higher order functions] among languages that handle functions as first class objects. Basically blocks can be designed for loop abstraction and lets the user to design their own way of iterating the values, thereby hiding the implementation details.
For example, if we want to iterate backwards from the end to the beginning without revealing its internal implementations, we could implement the loop logic inside the block and pass it to a method or function.

Here is a [http://www.ruby-lang.org/en/ Ruby] implementation of block:

def printlist(array,&reverse)
array.each do |element|
puts "array element: #{element}"
end
reverse.call(array) /* Here it prints the reverse implementation of list*/
end

printlist([1,2,3,4,5,6]) { |array|
array.reverse.each do |element|
puts "array element: #{element}"
end
}
The statements between { } is a block and it gets called by <code>reverse.call(array)</code>within the printlist method.

=== Clojure ===

Clojure[[http://oreilly.com/catalog/9781934356333 31]] is also a functional programming language, and it is a dialect of Lisp. It is not a pure functional language. Instead, it is a dynamically typed language. Just like Java it runs on JVM platform, but its syntax differs from Java. It is represented as :

(functions arguments...)

The function and its arguments are enclosed in paranthesis. It has features like immutable data structures, high-order functions, recursion, and easy and fast java interoperability.

In Clojure's model, value calculation is purely functional. Values never change. New values are functions of old. But, logical identity is well supported via atomic references to values. The value of a reference (state of an identity) is always observable without coordination and freely shareable between threads.
When programs are constructed this way, functional value calculation is independent of identity-value association. This makes clojure easier to understand and test.

====Example Using Functional Technique in Clojure====

Consider the following functional programming example in Clojure-
(defn make-adder [x]
(let [y x]
(fn [z] (+ y z))))
(def add2 (make-adder 2))
(add2 4)

Here,'''''defn make-adder [x]''''' defines a function called ''make-adder''.'''''let [y x]''''' gives a local name y for the value x. Since the scope of any local names is lexical, a function created in the scope of local names will close over their values.'''''fn [z] (+ y z)''''' does the addition of y and z.
''
'''def add2 (make-adder 2)''''' calls the function ''make-adder'' passing the parameter 2 and calls this as ''add2''.Now, ''add2'' has computed 2+z. When '''''add2 4''''' is called it computes 2+4=6

====Example Using Object-Oriented Technique in Clojure====

The following program implements Run-Time Polymorphism which is an object-oriented programming concept.
(defmulti encounter (fn [x y] [(:Species x) (:Species y)]))
(defmethod encounter [:Bunny :Lion] [b l] :run-away)
(defmethod encounter [:Lion :Bunny] [l b] :eat)
(defmethod encounter [:Lion :Lion] [l1 l2] :fight)
(defmethod encounter [:Bunny :Bunny] [b1 b2] :mate)
(def b1 {:Species :Bunny :other :stuff})
(def b2 {:Species :Bunny :other :stuff})
(def l1 {:Species :Lion :other :stuff})
(def l2 {:Species :Lion :other :stuff})

(encounter b1 l1)
-> :run-away
(encounter l1 l2)
-> :fight

Here,'''''defmulti''''' is used to define multiple methods which have the same method name '''''encounter'''''.Depending on the parameters passed to the encounter method, one of the four methods is called.
'''''def''''' defines each of the different species.
When, '''''(encounter b1 l1)''''' is called, the first ''encounter'' method is called with the parameters ''Bunny'' and ''Lion''. As a result, ''run-away'' is printed.

=== Summary of Languages Supporting Mixing ===

Each of the languages contains both functional and object-oriented features. The following table shows how each of the languages have both functional and object-oriented characterics. Not all characteristics of the languages are listed, but enough to demonstrate that the languages each have different ways of mixing object-oriented and functional techniques.

{| class="wikitable" border="2"
|-
!
! Functional Characteristics
! Object-Oriented Characteristics
|-
! Scala
| Immutable objects, the ability to pass functions as parameters, implicits, closures.
| Every value is a object, mutable objects.
|-
! Ruby
| Functional programming used in blocks.
| Everything is an object.
|-
! Clojure
| Immutable data structures, high-order functions, recursion.
| Objects, runtime polymorphism, [http://en.wikipedia.org/wiki/Multiple_dispatch multimethods.]
|-
|}

= Conclusion =
In summary, functional and object-oriented programming can be successfully mixed in programs. Many functional techniques are useful in object-oriented programs. Languages such as Scala, Ruby, and Clojure effectively support mixing these two paradigms, allowing programmers to create cleaner, less buggy object-oriented code.

= References =
#[http://en.wikipedia.org/wiki/Functional_programming Wikipedia - Functional Programming]
#[http://www.cs.cornell.edu/riccardo/prog-smlnj/notes-011001.pdf Notes on programming Standard ML of New Jersey]
#[http://users.dickinson.edu/~braught/courses/cs132f01/classes/code/Factorial.src.html Introduction to Computing - Dickinson College]
#[http://en.wikipedia.org/wiki/Object-oriented_programming Wikipedia - Object Oriented Programming]
#[http://searchsoa.techtarget.com/sDefinition/0,,sid26_gci212681,00.html More on Object Oriented Programming]
#[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas Understanding Ruby Blocks, Procs and Lambdas - Robert Sosinski]
#[http://www.codingday.com/power-of-functional-programming-its-features-and-its-future/ Power of Functional Programming, its Features and its Future]
#[http://skillsmatter.com/podcast/open-source-dot-net/mike-wagg-mark-needham-functional-and-oo-approaches-to-c-sharp-programming Mixing Functional and Object Oriented Approaches to Programming in C#]
#[http://en.wikipedia.org/wiki/Programming_paradigm Programming Paradigm]
#[http://en.wikipedia.org/wiki/Recursion Recursion]
#[http://www.scala-lang.org/ Scala]
#[http://en.wikipedia.org/wiki/Scala_%28programming_language%29 Scala Wikipedia]
#[http://clojure.org/ Clojure]
#[http://www.ruby-lang.org/en/ Ruby]
#[http://en.wikipedia.org/wiki/Standard_ML Standard ML]
#[http://en.wikipedia.org/wiki/Haskell_%28programming_language%29 Haskell]
#[http://en.wikipedia.org/wiki/ML_%28programming_language%29 ML Family]
#[http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java]
#[http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]
#[http://en.wikipedia.org/wiki/C%2B%2B C++ Programming Language]
#[http://en.wikipedia.org/wiki/Visual_Basic_.NET Visual Basic .Net]
# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]
#O'Reilly (2009), "Programming Scala", ''O'Reilly Media Inc.''.
#Dave Thomas, Chad Fowler, Andy Hunt (2006) ''Programming Ruby'', The Pragmatic Bookshelf.
#[http://lamp.epfl.ch/~phaller/doc/haller10-Translucent_functions.pdf Philipp Halle, Lightweight language support for type-based, concurrent event processing, Lausanne, Switzerland, April 2010.]
#[http://biblion.epfl.ch/EPFL/theses/2007/3899/EPFL_TH3899.pdf Burak Emir, Object-Oriented Pattern Matching, EPFL, October 2007].
#[http://math.hws.edu/eck/cs124/downloads/OOP2_from_Univ_KwaZulu-Natal.pdf, Object-Oriented Programming,February 2007].

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-11T02:21:22Z

Dmcarmon: /* Functional Programming */

= Introduction =

= Functional Programming =

Functional programming treats computation as the evaluation of mathematical functions. It is compute-centric rather than data-centric. Functional programming keeps no global state, does not use for or while loops, and mandates that data is [http://en.wikipedia.org/wiki/Immutable immutable]. Instead, everything is done using functions, usually functions that evaluate mathematical expressions. Each of these functions maintain no internal state and will always produce the same output given the same input.

== Example Contrasting Imperitive and Functional Styles ==

Let's look at an example. Suppose we have a list of numbers and we want to multiply each number in the list by 2. The first approach is the imperitive style:

array[] = {1,2,3,4,5}
for(i=0 ; i<array.length; i++){
array[i] = array[i] * 2;
}

In the above example, array[] is a global variable. If we fail to check the array length, then a runtime exception occurs which might result in the program being crashed. As far as functional style, there is a function called map(func,seq)(in python language) where the function 'func' is applied to each member of seq. The following code is written in a functional style.

numbers = [1,2,3,4,5]
/* define a method called compute on each number in the list */
def compute(var):
var = var * 2
return var
/* Now call the map function */
L = map(compute,numbers)
print L // L will print [1,4,6,8,10]

Notice that there is no global data nor any nested loops and the bound checking is handled internally within the map function. The programmer is relieved of of runtime errors and thus can debug the program easily.

== Advantages of Functional Programming ==

Some advantages of this approach are:
* Easier debugging: Since every thing is broken down into small simple functions, the functions are often easy to debug.
* More compact code: Functional programming typically requires fewer lines of code. Since compution is done by function code reuse is prevelent.
* Nothing depends on state: Because functional programs keep no state information, the functions will always operate the same regardless of the past history of the program.

= Object-oriented Programming =
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] (OOP) is a programming paradigm organized around interacting "objects"(usually instances of a class) rather than "actions" and data rather than logic. A basic principle of OOP is that a program consists of a list of subroutines which can perform individually.

An object-oriented programming language provides support for the following object-oriented concepts--object, class, interface and inheritance. To illustrate this idea clearly and vividly let's review the following example-- your limbs. The "Limbs" is a class. Your body has two objects of type "limbs", named arms and legs. Their main functions are controlled/ managed by a set of biological signals sent from central nervous system( through an interface). So the nervous system is an interface which your body uses to interact with your limbs. The "limbs" is a well architected class. The "legs" has a subclass which contains "left leg" and "Right leg". The "legs" is being re-used to create the left leg and right leg by slightly changing the properties of it. If the "legs" owns attributes like length, color of skin etc, then the subclass, which contains "left leg" and "right leg" in this case, automatically inherit these attributes( that is called inheritance).

We could code in object-oriented paradigm as:

class Limbs /*define a class of limbs*/
def initialize(limbs,length,colorofskin)
@limbs=limbs
@length=length
@colorofskin=colorofskin
end
end
limbs=Limbs.new("legs","100cm","white") /*create a new object in class "Limbs"*/
class Legs<Limbs /*create a subclass "Legs",which belong to class"Limbs"*/
def initialize(legs,length,colorofskin)
super(length,colorofskin)
@legs=legs
end
end
legs=legs.new("left leg") /*create a new object in class of "Legs"*/

== Features of Object-oriented Programming ==
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]. A programmer can simply create a new object that inherits many of its features from super-class. And also, they can overwrite existing operations or add new ones.This makes object-oriented programs easier to modify.
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation].This refers to hiding the internal representation of the object from the outside view. You can hide unnecessary implementation details from the object user. One of the benefits of encapsulation is data protection.
* [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism].This allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects. Consider the operator '+', for numbers it will generate the sum, but for strings it will produce a third string which concatenates the input strings.

== Advantages of Object-oriented Programming ==
* Simplicity: we use software objects to simulate real world objects, so the complexity is reduced and the program structure is very clear.
* Modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system.
* Modifiability: programmers can easily make minor changes in the data representation or operations in an OOP. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods.
* Extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones.
* Maintainability: objects can be maintained separately, making locating and fixing problems easier.
* Re-usability: objects can be reused in different programs.

= Mixing Functional and Object-Oriented Programming =

Motivation for Mixing

== Functional Techniques useful for Object-Oriented Programming ==
In object-oriented world, data and operations are grouped together into modular units called objects and we combine objects into structured networks to form a program. The results are depend on arguments and objects' state at method invocation time. While in functional world, the basic elements are variables in the mathematical sense and functions in the mathematical sense. Functional programming can reduce side-effects. If there is no side-effects, it means your can apply the function at anywhere freely. No matter how you apply this function, the same input arguments produce the same results.

According to above-mentioned information, we can perform functional programming on an object-oriented programming language because:
1). object can have constant state
2). method can depend only on its arguments and context available at method definition time

Combining both these paradigms not only provide us a robust design structure, but also enable the programmers to develop solutions to complex problems quickly and effectively. One of the cornerstone of mixing functional and object-oriented code is treating functions as objects.It means that we can pass functions as arguments, store it and return them from other functions. This is highly useful in an user interface code where it can be used as call back functions which gets called when an event occurs(event driven programming).

Some of the basic features of Functional Programming which can be combined with Object Oriented paradigm are:

* Lambda Calculus
* Currying
* Powerful pattern matching

Let us now understand how each of the above feature of Functional language fits in the Object Oriented paradigm.

=== Lambda Calculus ===
Lambda calculus is the most critical basis of functional programming. A lambda expression is an anonymous expression that contain expressions and statements.Each expression stands for a function with one parameter.

Let consider the following function:

def f(x)
return x**2
print f(4)

We can use a lambda calculus to compute this expression without assigning it to a variable:

(lambda x:x**x)(4)

We can see that these two code snippets have the same results. It is more concise and flexible to define with lambda.
The above is a pure functional approach. In order to make code more state-less and concise, lambdas can be embedded inside the object-oriented language. The below code in Python demonstrates the use of lambda in a closure:

def fun(x):
return x%3==0
str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
filter(fun,str)

The above code works to find numbers which are divisible by 3.
We can simplify the code by the use of lambda as following:

str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print filter(lambda x: x%3==0, str)

=== Currying ===

=== Pattern Matching ===

== Examples of Mixing ==

A number of programming languages support mixing of both functional and object-oriented code. Three of these (Scala, Ruby, and Conjure), are described in more detail below.

=== Scala ===

[http://www.scala-lang.org/ Scala] is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. [http://www.scala-lang.org/ Scala] was conceived in 2001 and implemented by Martin Odersky. It supports mixing functional and object-oriented code.

==== Mixing Functional and Object-Oriented Code in Scala ====
[http://www.scala-lang.org/ Scala] is a strange specimen. It is a complete blend of object-oriented and functional programming. How can this happen? The functional world advocates immutability, but the object-oriented world focuses on the state and how to change it to fit your needs. [http://www.scala-lang.org/ Scala] allows you create both mutable and immutable objects. Consider the following example,
val str: String = "Hello World"
In the first line, an immutable version(a misnomer indeed) of <code>str</code> is being created . A rough translation into Java is below:

final String str = "Hello World"; //note the extra semi-colon
Consider the next example below,
val list: List[String] = List("Scala", "is", "the coolest", "language", "in the world!")

The same code can be written in Java as:

List<String> mutableList = new ArrayList<String>();
list.add("Scala");
list.add("is");
list.add("the coolest");
list.add("language");
list.add("in the world!");
List<String> immutableList = Collections.immutableList(mutableList);

Compared to Java, [http://www.scala-lang.org/ Scala] reduces the total number of lines you need to type and at the same time looks much simpler and less verbose. Even though the above example shows an immutable collection, scala also provides mutable collections and object types in the package <code>scala.collection.mutable.*</code>

As can be observed, even though [http://www.scala-lang.org/ Scala] advocates immutability, it does not restrict you from creating mutable objects. So it's the best of both worlds. Another part of the functional world is the concept of functions as ''''first class members'''' of the language. Some of the common languages like Ruby, Python and JavaScript all incorporate this feature. In the sense you can pass around functions to methods as a parameter. Enough talking;

Let us have a class say <code>'Person'</code> which has properties, <code>name</code> and another variable <code>age</code>.
In Java:

class Person{
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String s){
this.name = s;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}

In [http://www.scala-lang.org/ Scala]:
case class Person(name: String, age: Int)

This single line is equivalent to the above java code! Getters for <code>name</code> and <code>age</code>, <code>equals()</code>, and <code>hashCode()</code> method are automatically generated for you by the compiler. Isn't this an awesome feature?

Now assume we have a list of persons and we want to filter out all the persons who are of age 23. How would you do that in Java?

List<Person> persons; //has a bunch of person objects in it.
List<Person> twentyThree = new ArrayList<Person>();
for(Person p: persons){
if(p.getAge() == 23){
twentyThree.add(p);
}
}

In [http://www.scala-lang.org/ Scala]:

val twentyThree: List[Person] = persons.filter( _.age == 23)

That's it! In case you are wondering whats going on, filter is a method present on scala.List class and the code block <code>_.age == 23</code> is a function created on the fly and passed onto the filter method. More precisely its called a [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] - a functional concept which can be emulated in java only using anonymous inner classes. Scala's compiler transforms our one line function into some anonymous inner classes when generating java byte code, allowing developers to define functions in a simple manner.

In fact, every function is an object in [http://www.scala-lang.org/ Scala]. Scala's standard library has a number of functions which are objects themselves.

==== Implicits in Scala ====
In almost all programming languages, there is a necessity to profile the running time of the procedures and tune its performance. The old way of doing things in Java would be:

public class Main{
public static int factorial(int x){
if(x == 0 || x == 1) return 1
else return x * factorial(x-1)
}
public static void main(String [] args){
long beforeTime = System.currentTimeMillis();
int result = factorial(5);
System.out.println("Total time taken to execute factorial(5) is " + (System.currentTimeMillis() - result)+"ms");
System.out.println("factorial(5) = " + result);
}
}

However, if you want to find out the execution time of some other method, you would have to type in all the above lines again. So much for code re-use or [http://en.wikipedia.org/wiki/DRY DRY (dont't repeat yourself)]! Lets see how its done in [http://www.scala-lang.org/ Scala].

object Main{
def main(args: Array[String]){
def factorial(x: Int):Int = x match{
case 0 | 1 => 1
case _ => x * factorial(x-1)
}
import System.currentTimeMillis
def timeIt(msg: String = "Time to execute is: ")(func: => Unit){
val before = currentTimeMillis
func
println(msg + (currentTimeMillis - before) + "ms")
}
timeIt("Total time taken to execute factorial(5) is "){
val result = factorial(5)
println("factorial(5) = " + result)
}
}
//would print: factorial(5) = 120
// Total time taken to execute factorial(5) is 1ms

That's not right! The function <code>timeIt</code> looks like a feature built into the language. Try saving the above code into a separate file and run it - It will still work. Using this feature, it is possible to build powerful DSL languages which can run at full speed on JVM.

Ruby allows you to add new methods to objects. Since you are splitting open the class and adding/overriding methods (in)|(to) the class, this feature is often called [http://en.wikipedia.org/wiki/Monkey_patch Monkey Patching]. Because other libraries may depend on some methods which you changed, often this leads to unexpected behavior at runtime. However, Scala provides yet another feature called [http://en.wikipedia.org/wiki/Implicit_function implicits] which helps you do this better.

In Java, <code>String</code> class is <code>final</code> so there is no way you can add new methods to it. But with implicits you can do more! Suppose you have some text in memory and you know it represents a number. But in Java the usual way to convert string to int is to do a <code>Integer.parseInt(string)</code> which seems so unnecessary. Let us make our lives easier...

implicit def strToInt(str: String) = new {
def asInt = Integer.parseInt(str)
}
val str = "1234"
println(str.asInt * 3) //prints out 3702

The above code gives us an impression as if String class has gained new <code>asInt</code> method. Can static object oriented languages do this? No! Infact scala cheats by calling our implicits to convert it into a different object as and when needed.

The above functionalities are purely object oriented, yet they are safe. They don't pollute the global namespace, unlike Ruby or Python.

=== Ruby ===

Ruby is another language that, like Scala, supports mixing functional and object-oriented code. It is a dynamically typed Object-Oriented Language which supports multiple programming paradigms, including functional, object-oriented, imperative and reflective. In Ruby, everything is an object, every bit of information and code can have its own properties and actions. However, Ruby’s blocks can be functional. A Ruby programmer can attach a closure to any method, which generates a functional block inside an object oriented code. A closure is a piece of code that can access the lexical environment of its definition [http://www.ruby-lang.org/en/ 11].

==== Ruby Mixing Example ====

Consider the following code snippet in Ruby which uses Object Oriented concepts like Classes and functional programming concepts like lambda.

class Multiply
def initialize(n)
@block = lambda {|a| n * a}
end
def mul(a)
@block.call a
end
end
twoMultiplier = Multiply.new 2
puts twoMultiplier.mul(6)

Here,'''''@block''''' is a closure. When we call the class ''Multiply'' using '''''twoAdder = Multiply.new 2''''' ,the ''initialize'' method is called by passing the parameter 2. Here n=2 binds itself to the block. So @block will be 2*a, that is,the closure remembers the parameter with which the initialize method was called even after the initialize method exits.

This value is used when the block is called in the add method.
Thus,'''''twoMultiplier.mul(6)''''' will return 2*6 = 12

==== Functional Style Coding in Ruby Blocks ====

Blocks are basically nameless functions which can be passed to a function and then that function can invoke the passed in nameless function. This is a common style called [http://en.wikipedia.org/wiki/Higher-order_function higher order functions] among languages that handle functions as first class objects. Basically blocks can be designed for loop abstraction and lets the user to design their own way of iterating the values, thereby hiding the implementation details.
For example, if we want to iterate backwards from the end to the beginning without revealing its internal implementations, we could implement the loop logic inside the block and pass it to a method or function.

Here is a [http://www.ruby-lang.org/en/ Ruby] implementation of block:

def printlist(array,&reverse)
array.each do |element|
puts "array element: #{element}"
end
reverse.call(array) /* Here it prints the reverse implementation of list*/
end

printlist([1,2,3,4,5,6]) { |array|
array.reverse.each do |element|
puts "array element: #{element}"
end
}
The statements between { } is a block and it gets called by <code>reverse.call(array)</code>within the printlist method.

=== Clojure ===

Clojure[[http://oreilly.com/catalog/9781934356333 31]] is also a functional programming language, and it is a dialect of Lisp. It is not a pure functional language. Instead, it is a dynamically typed language. Just like Java it runs on JVM platform, but its syntax differs from Java. It is represented as :

(functions arguments...)

The function and its arguments are enclosed in paranthesis. It has features like immutable data structures, high-order functions, recursion, and easy and fast java interoperability.

In Clojure's model, value calculation is purely functional. Values never change. New values are functions of old. But, logical identity is well supported via atomic references to values. The value of a reference (state of an identity) is always observable without coordination and freely shareable between threads.
When programs are constructed this way, functional value calculation is independent of identity-value association. This makes clojure easier to understand and test.

====Example Using Functional Technique in Clojure====

Consider the following functional programming example in Clojure-
(defn make-adder [x]
(let [y x]
(fn [z] (+ y z))))
(def add2 (make-adder 2))
(add2 4)

Here,'''''defn make-adder [x]''''' defines a function called ''make-adder''.'''''let [y x]''''' gives a local name y for the value x. Since the scope of any local names is lexical, a function created in the scope of local names will close over their values.'''''fn [z] (+ y z)''''' does the addition of y and z.
''
'''def add2 (make-adder 2)''''' calls the function ''make-adder'' passing the parameter 2 and calls this as ''add2''.Now, ''add2'' has computed 2+z. When '''''add2 4''''' is called it computes 2+4=6

====Example Using Object-Oriented Technique in Clojure====

The following program implements Run-Time Polymorphism which is an object-oriented programming concept.
(defmulti encounter (fn [x y] [(:Species x) (:Species y)]))
(defmethod encounter [:Bunny :Lion] [b l] :run-away)
(defmethod encounter [:Lion :Bunny] [l b] :eat)
(defmethod encounter [:Lion :Lion] [l1 l2] :fight)
(defmethod encounter [:Bunny :Bunny] [b1 b2] :mate)
(def b1 {:Species :Bunny :other :stuff})
(def b2 {:Species :Bunny :other :stuff})
(def l1 {:Species :Lion :other :stuff})
(def l2 {:Species :Lion :other :stuff})

(encounter b1 l1)
-> :run-away
(encounter l1 l2)
-> :fight

Here,'''''defmulti''''' is used to define multiple methods which have the same method name '''''encounter'''''.Depending on the parameters passed to the encounter method, one of the four methods is called.
'''''def''''' defines each of the different species.
When, '''''(encounter b1 l1)''''' is called, the first ''encounter'' method is called with the parameters ''Bunny'' and ''Lion''. As a result, ''run-away'' is printed.

=== Summary of Languages Supporting Mixing ===

Each of the languages contains both functional and object-oriented features. The following table shows how each of the languages have both functional and object-oriented characterics. Not all characteristics of the languages are listed, but enough to demonstrate that the languages each have different ways of mixing object-oriented and functional techniques.

{| class="wikitable" border="2"
|-
!
! Functional Characteristics
! Object-Oriented Characteristics
|-
! Scala
| Immutable objects, the ability to pass functions as parameters, implicits, closures.
| Every value is a object, mutable objects.
|-
! Ruby
| Functional programming used in blocks.
| Everything is an object.
|-
! Clojure
| Immutable data structures, high-order functions, recursion.
| Objects, runtime polymorphism, [http://en.wikipedia.org/wiki/Multiple_dispatch multimethods.]
|-
|}

= Conclusion =

= References =
#[http://en.wikipedia.org/wiki/Functional_programming Wikipedia - Functional Programming]
#[http://www.cs.cornell.edu/riccardo/prog-smlnj/notes-011001.pdf Notes on programming Standard ML of New Jersey]
#[http://users.dickinson.edu/~braught/courses/cs132f01/classes/code/Factorial.src.html Introduction to Computing - Dickinson College]
#[http://en.wikipedia.org/wiki/Object-oriented_programming Wikipedia - Object Oriented Programming]
#[http://searchsoa.techtarget.com/sDefinition/0,,sid26_gci212681,00.html More on Object Oriented Programming]
#[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas Understanding Ruby Blocks, Procs and Lambdas - Robert Sosinski]
#[http://www.codingday.com/power-of-functional-programming-its-features-and-its-future/ Power of Functional Programming, its Features and its Future]
#[http://skillsmatter.com/podcast/open-source-dot-net/mike-wagg-mark-needham-functional-and-oo-approaches-to-c-sharp-programming Mixing Functional and Object Oriented Approaches to Programming in C#]
#[http://en.wikipedia.org/wiki/Programming_paradigm Programming Paradigm]
#[http://en.wikipedia.org/wiki/Recursion Recursion]
#[http://www.scala-lang.org/ Scala]
#[http://en.wikipedia.org/wiki/Scala_%28programming_language%29 Scala Wikipedia]
#[http://clojure.org/ Clojure]
#[http://www.ruby-lang.org/en/ Ruby]
#[http://en.wikipedia.org/wiki/Standard_ML Standard ML]
#[http://en.wikipedia.org/wiki/Haskell_%28programming_language%29 Haskell]
#[http://en.wikipedia.org/wiki/ML_%28programming_language%29 ML Family]
#[http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java]
#[http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]
#[http://en.wikipedia.org/wiki/C%2B%2B C++ Programming Language]
#[http://en.wikipedia.org/wiki/Visual_Basic_.NET Visual Basic .Net]
# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]
#O'Reilly (2009), "Programming Scala", ''O'Reilly Media Inc.''.
#Dave Thomas, Chad Fowler, Andy Hunt (2006) ''Programming Ruby'', The Pragmatic Bookshelf.
#[http://lamp.epfl.ch/~phaller/doc/haller10-Translucent_functions.pdf Philipp Halle, Lightweight language support for type-based, concurrent event processing, Lausanne, Switzerland, April 2010.]
#[http://biblion.epfl.ch/EPFL/theses/2007/3899/EPFL_TH3899.pdf Burak Emir, Object-Oriented Pattern Matching, EPFL, October 2007].

= Mixing Functional & O-O code =

This chapter deals with the mixing of functional and object-oriented programming paradigms. We start with listing the different programming paradigms available today. We introduce functional and object-oriented approaches briefly and then discuss the advantages of one over the other. Following this, we discuss some aspects and features of mixing both the approaches. Finally, we talk about few languages that constitute such a mix.

== Programming Paradigms Today==

Several programmatic approaches to solve a particular task lead to distinct programming paradigms like, 
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
* Functional programming 
* Object Oriented programming 
* [http://en.wikipedia.org/wiki/Logic_programming Logical programming], etc. 
Lets focus on functional and object oriented programming approaches.

== Functional Programming ==

[http://en.wikipedia.org/wiki/Functional_programming Functional programming] is the task of decomposing a problem into a number of functions. Selectively executing these functions results in the solution to the problem. The functions mostly behave as mathematical. For given set of inputs the program should always return the same output. It usually concentrates on what type of problem we are dealing with rather than on the details of how to solve the problem. For example lets say there is a function which calculates area of a square. If we use it six times then we end up with area of a cube. Thus functional programming helps to build complex systems.

=== Approach ===

Expressions are the collection of variables and operations resulting in a single value this also deals with the way of solving the problem as expressions. Hence also called Expression related programming. It is structured as expression where each expression can be encapsulated in another yielding the result. Making the change in data structures as the program runs is called [http://en.wikipedia.org/wiki/Side_effect_(computer_science) side effects]. Purely functional language has no side effects. Language like Haskell is a pure functional language . Some languages need many approaches for achieving the desired result. Such languages are multi-paradigm. Examples for such languages are C++, Python,Lisp. Its like evaluating an expression and use the resulting value for something.

Structure of functional programming :

(fn2 ( fn1 ()[input list] ) []) => fn1 takes input list and the output of fn1 is used as input to fn2. Its a schematic representation of
how functional programming works.

Functional programming feature (Python) :

m = map(lambda i : i*i , numbers)
where ''numbers'' is an array of numbers and ''lambda'' is [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 closure].

Python has some functions like map, filter, reduce to support functional programming style. In the example above, the 'map' is a high-order function that takes a function and an array of numbers as input. The ''lambda'' takes i as input and returns i*i as output. Every result returned is appended to a list and produced as output. In functional programming, the programmer is given a natural framework for developing smaller, simpler, and more general modules, which are then glued together.

== Object Oriented Programming ==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] is a programming technique where everything is defined as an object. Objects are well-defined discrete bundles of data(attributes) and the associated functions(behavior). They are devised to resemble real-life objects and are uniquely identifiable by a name. The attributes could be of simple datatype(int, String, Boolean) or objects themselves. The behavior is defined by methods to use and manipulate the attributes. The values of attributes of an object at an instant is the state of the object. OO Programming allows objects to have their state retained throughout the code until manipulated otherwise. Objects are capable of housekeeping their own states, interacting and establishing relationships with other objects, inheriting, etc.

=== Fundamental concepts ===

A [http://en.wikipedia.org/wiki/Class_%28computer_science%29 class] is a user-defined datatype that provides implementation details to define the attributes and their properties. It is an abstract representation of an object(i.e.,) like a mold for objects.
An instance is an executable copy of a class. They are the actual objects created using the ‘class mold’ on run time.
Methods are a set of procedural statements or functions to define the behavior of an object, convey the current state, modify values of the attributes, etc.

Example :

An object in Java might look like this:

public class Person {
private String name;
public Person() {
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}

Here, OO Programming allows the programmer to set the ''name'' attribute of the class ''Person'' and get the name whenever needed in the code. An object of this class Person will remain in memory forever as long as there is a reference to it. As OO Programming allows objects to have their state retained, the value of the ''name'' attribute for a particular ''Person'' object remains the same across any part of the code until it is set differently.

=== Features ===

Three primary characteristics of object oriented programming are Encapsulation, Polymorphism, and Inheritance.
[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation] is the ability of objects to hide visibility of their attributes and behavior, thereby providing service independent of implementation.
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects.
[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance] is one where an existing type can be used to derive a new type. Derived types inherit the data and operations of the super-type. And also, they can overwrite existing operations or add new ones.

There are other important features of O-O programming like [http://en.wikipedia.org/wiki/Message_passing message passing], [http://en.wikipedia.org/wiki/Abstraction abstraction], delegation, etc.

Now, we have seen both the approaches and their features in brief. Lets discuss the advantages of one over the other.

== Advantages ==

=== Functional Approach over OO Approach[[http://www.jot.fm/issues/issue_2009_09/article5.pdf 8]]===
* Functional programming solves the problem with lesser number of lines of code than the OO programming style. 
* There is no side effect as they use immutable data structures also called [http://en.wikipedia.org/wiki/Persistent_data_structure Persistent Data Structure] which will have no change in the state of variables. Hence program dont have to depend on history. 
* There is no limit in the numeric types used as opposed to OO languages which mainly depend on primitive data types. 
* A programmer is given the freedom to think in terms of what to solve in the problem rather than concentrating on how to solve and the flow of the program. 
* Suitable for calculation intensive programs.

=== OO Approach over Functional Approach===
* Everything can be represented in an object and it has the attributes associated with it and hence the state of the object is known at any time. 
* A complex system can be subdivided into modules of objects where as in functional approach, many functions inter operate to form a complex system. 
* [http://en.wikipedia.org/wiki/Reusability Re-usability] (i.e.) OO approach enables programmers to create new objects that inherits many of its features from existing objects. This makes object-oriented programs easier to modify than functional. 
* [http://en.wikipedia.org/wiki/Debug Debugging] in Object Oriented environment is easy compared with functional approach where a small error in one function causes the whole system (i.e. all the functions) to fail. 
* Suitable for making application-oriented software. 

Both the approaches have their advantages and disadvantages. What if we could get the best of both the worlds? The next section deals with the aspects and features of how well both the approaches are mixed together in some languages.

== Mixing Functional & OO Code - Best of both the worlds ==

Languages that are a mix of functional and object oriented approaches(eg. Scala[[http://www.scala-lang.org/node/1305 1]], Clojure[[http://oreilly.com/catalog/9781934356333 10]], etc.) make use of best of both the worlds. They support various aspects of functional and object oriented approaches. They have a bunch of functional approach features[[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf 6]], which object oriented programming languages(like Java) lack which includes closures. Closures are first-class functions with free variables that are bound in the lexical environment. These languages also sport a very malleable syntax that makes them well suited for "domain specific languages" with the benefits of static typing. They are more expressive, extensible and allow reuse of programming abstractions.

Certain languages like Scala, Clojure, etc run on Java Virtual Machine(JVM) ensuring portability to all underlying platforms. They even support immutable objects. In Scala, new language constructs can be added in the form of libraries. They allow safe reuse[[http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf 9]] of programming abstractions and type-safe extension of software.

===Lambda===

A lambda[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] expression is an anonymous function that contain expressions and statements, and can be used to create delegates or expression types. Such kind of anonymous function can be defined and passed around as easily as other data types and can be used to contain functionality that need not be named. Some notable examples include closures[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] and currying. Lambda functions with no name can be called using the variable assigned to it.

g = lambda x: x*2
g(3)=6

We can have lambda function without assigning it to a variable which can be used as inline-function.

(lambda x: x*2)(3)

In [http://en.wikipedia.org/wiki/Clojure Clojure] as a functional language, the creation of a chunk of behavior that can be assigned to a variable (known as a lambda) is trivial. Below are two ways to create a lambda that returns the square of its argument.

(def square1 (fn [n] (* n n)))
(def square2 #(* % %))

===Currying ===

[http://en.wikipedia.org/wiki/Currying Currying] transforms a function that takes multiple parameters into a chain of functions, each taking a single parameter. It reuses a partially applied function where the function is originally defined as accepting n parameters.It can be interpreted as the technique to decompose a function that takes n parameters into n function each of them taking 1 parameter. For example to say in algebraic terms,consider the function f which takes 3 parameters x,y,z and Currying means that we can rewrite the function as a composition of 3 functions:

f(x,y,z) = 4*x+3*y+2*z
f(x)(y)(z) = 2*z+(3*y+(4*x))

In Scala, currying takes advantage of Scala’s syntactic sugar. Below is a currying example in Scala. This function creates a multiplier function which takes two arguments and partially defines it by assigning a constant to one argument and assigning it to a variable .Later the function is called by assigning the second argument.

def multiplier(i: Int)(factor: Int) = i * factor => method named multiplier which takes two parameters is defined
val byFive = multiplier(5) _ => The method is redefined with accepting one parameter and store it in a variable.
val byTen = multiplier(10) _

scala> byFive(2) => Method called by giving the second parameter.
res4: Int = 10

scala> byTen(2)
res5: Int = 20

===Less Verbosity===

In Java each variable should have its type defined beforehand. Whereas in languages like Scala, it is more concise and easier to read than the equivalent Java.

For example, a Map can be created with a simple syntax in Scala,Clojure than in Java:

<table>
<tr>
<td>
'''Java'''
Map<String, Integer> nMap = new HashMap<String, Integer>();
nMap.put("one", 1);
nMap.put("two", 2);
nMap.put("three", 3);
</td>
<td>
'''Scala'''

var nMap = Map("one" -> 1, "two" -> 2, "three" -> 3)

</td>
<td>
'''Clojure'''

(doto (new Java.util.HashMap)(.put “a” 1)(.put “b” 2))

</td>
</tr>
</table>

Here, Scala compiler knows that nMap uses Strings as keys, and Integers as values. Unlike Java, this need not be specified beforehand. Scala could figure it out itself. Moreover, Scala will give an error if a different key-value pair is tried to insert. This is called "type inference". This prevents a whole class of bugs at run time just like Java but with less verbosity.
In a similar way Clojure also involves only few lines of code compared with the object oriented Java language which takes many lines of code.A simple Clojure example and the associated Java code :
Example

(defn blank? [s] (every? #(Character/isWhitespace %) s))

The innermost function Character/isWhiteSpace checks the first argument % for any whitespace and returns true if it is. every? invoke the above inner function for all elements in the collection s.It has no variables, no branches etc.

Java code
isBlank() method checks to see whether a string is blank or contains only whitespace.

public class Stringcheck{
public static boolean isBlank(String str){
int len;
if(str==null || (strlen =str.length())==0)
return true;
for(int i=0; i<strlen;i++) {
if((Character.isWhitespace(str.charAt(i))==false)){
return false;
}
}
return true;
}
}

=== Pattern Matching ===

To say simply, a [http://en.wikipedia.org/wiki/Pattern_matching Pattern matching] is a technique to search string for the occurrence of any patterns or regularity. Pattern matching is an elegant way to decompose objects into their constituent parts for processing.Many languages support the concept of pattern matching. Perl supports pattern matching using the pattern definition mini language called regular expressions, also called regexes or REs, which is borrowed from the regular expressions used in many Unix tools, such as grep() and sed().The risk that the parts of an object might be changed outside of the control of the enclosing object is avoided. For example, if there is a Person class that contains a list of addresses, it will not be an issue to expose that list to clients if the list is immutable. The users will not be able to change the list unexpectedly.Given below is a simple example for pattern matching used in Perl:

$mystring = "Hello world!"; // Perls way of assigning string to a variable.
if($mystring =~ m/World/) { print "Yes"; } // Checks the string stored in variable mystring has the string "World".
$mystring =~ s/world/mom/; // Replaces the string "world" stored in mystring to mom.

Another sample of regular expression in java :

String mystring="Hello World" ;
Pattern str = Pattern.compile("\\w+"); => Pattern stored for matching.
Matcher fit = str.matcher(mystring); => Matcher class which perform matching of the string with the pattern defined.
if(fit.matches())

As languages like Scala and Clojure support procedural code, pattern matching is done as equal or with less difficulty compared with Java which needs to use regex. Scala can even be embedded into XML as its syntax is somewhat similar.Given below an overview of how regular expression is achieved in Clojure.
Data are manipulated in Clojure through the sequence called seq which is a logical list. Clojure can access java collections, its collections, Regular expression matches via the seq also called seq-able. Clojure's regular expression uses java.util.regex library at the lowest level. For achieving that the keyword re-seq is used.
Syntax:
(re-seq regexp string)
Example
(re-seq #"\w+" "Hello World") => ("Hello" "World") => #"\w+" represents the java.util.regex.Pattern

=== Java Interoperability ===
Considering Clojure, it gives clean, simple and direct access to java and can access Java API directly.Clojure doesnot wrap Java's string functions. We can call using Java interop forms. It provides syntax for accessing Java elements like classes, instances, constructors, methods and fields and can also wrap Java API. The “.” dot special form is used for accessing Java. Some Clojure syntax which can access Java API: 

{| class="wikitable" border="2"
|-
! Java
! Clojure
|-
| new Widget(“red”)
| (new Widget “red”)
|-
| Math.PI
| (.Math PI) or Math/PI
|-
| System.currentTimeMillis()
| (.System currentTimeMillis) or System/currentTimeMillis
|-
| rnd.nextInt()
| (.rnd nextInt) or (.nextInt rnd)
|-
|}

Clojure pass functions as arguments to other functions. But Java does not support this. So Clojure provides a member function memfn macro to wrap methods or can use anonymous function to wrap a method call.
(map (memfn toUpperCase) [“a” ,”short”,”message”])
or
(map #(.toUpperCase %)[“a”,”short”,”message”]) => #(body) represents the anonymous function in Clojure.

For example,
(def the-digits
(map #(Integer. (str %))(filter #(Character/isDigit %) (seq big-num-str))))

where (def big-num-str (str "123785334434se9088af8309304293872adbcdfd”))

The above code extracts the integers from string and discards the non-numeric characters. Lets look at the functions defined in the example. There are totally five functions defined.They are
(seq big-num-str) => get each character defined in big-num-str
(Character/isDigit %) => Checks whether the input is an integer
(filter #()) => Filter each string from str
(map #(Integer. (str %))) => Change the string to integer
(def the-digits) => Output the integers only in a string of characters.
Here,
#(Character/isDigit) represents the Java method Character.isDigit() and #(Integer.(str %)) represents the new java.lang.Integer(str(%))

Most of the Clojure library functions have defined semantics for objects of Java types. contains? and .get work on Java’s Maps, arrays, Strings, count works on Java Strings, Collections and arrays. Clojure is built around these aspects. It avails the performance of JVM and the richness of both the core APIs and the numerous third-party libraries written in the Java language and restrained from reinventing them.

=== Multiple Inheritance ===

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance][http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf 2] is the concept of using the methods and variables of more than one superclass to a sub class.Java was designed without multiple inheritance. But Java supports the solution of problems commonly solved with multiple inheritance in other ways with help of interfaces where the methods defined in it are not implemented.In Scala, classes are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance in Java.Lets see how multiple inheritance achieved in Scala:

As interfaces in Java, Scala allows traits but has some methods partially implemented. The only difference to classes is the traits may not have constructor parameters.

trait Similarity {
def isSimilar(x: Any): Boolean // not implemented
def isNotSimilar(x: Any): Boolean = !isSimilar(x) //implemented method
}

This trait defines two methods isSimilar and isNotSimilar where isSimilar does not provide a concrete method implementation (it is abstract in the terminology of Java), and the method isNotSimilar defines a concrete implementation. Consequently, classes that integrate this trait only have to provide a concrete implementation for isSimilar.

class Point(xc: Int, yc: Int) extends Similarity {
var x: Int = xc
var y: Int = yc
def isSimilar(obj: Any) = //need to implement the method here
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
}

object TraitsTest extends Application {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotSimilar(p2))
println(p1.isNotSimilar(p3)) //uses the already defined method
println(p1.isNotSimilar(2))
}

These are some of the aspects and traits of mixing functional and object-oriented approaches. As we discussed in the advantages section, both the approaches have their benefits and limitations. Mixing them aspect-wise enables the above features in such languages. Lets discuss those languages briefly in the next section.

== Languages Supporting Functional and OO code ==

OCaml and F#[[http://msdn.microsoft.com/en-us/library/dd233154.aspx 7]] are some of the languages which support both functional and object oriented programming. OCaml is as fast as C and its featured as [http://www.haskell.org/ Haskell] which is a pure functional language. F#[[http://oreilly.com/catalog/9780596153656 3]] is a dynamically typed language which can run on .NET framework and has supported immutable types i.e. tuples, records, discriminated unions and lists to work in Functional programming. It has functions that can either be in curried or in uncurried form. As in functional language it can pass functions as arguments to other functions, resulting in higher order functions. It also supports lambda functions and closures. F#,behaves like other .NET languages as both in imperative and object oriented style. 

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language and it is a dialect of Lisp. It is not a pure functional language and it is a dynamically typed language. Just like Java it runs on JVM platform. But its syntax differs from Java. It is represented as :

(functions arguments...)

The function followed by its arguments is enclosed in paranthesis. It has features like immutable data structures, high-order functions and recursion, easy and fast java interoperability. 

Python and Ruby are also the programming languages which offer the mix of functional and OO languages. But these languages doesn't support the algebraic data types and pattern matching.

==Conclusion ==
The above aspects of functional and object oriented programming techniques discuss some if their merits and demerits. Mixing them produces a new programming paradigm which leads to a new dimension in programming. A few fundamental concepts are explored in Clojure and Scala here. The ability of Clojure and Scala to run in JVM platform makes them more preferable than others in the market. Some of the merits like closure, less verbosity, high order functions, currying along with interoperation with previously written libraries in these languages make them more efficient and useful. There are also other languages which support functional and object oriented techniques. Mixing the approaches, evolve a new dimension in programming which is practical and opens doors to more exploration.

== References ==

# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-11T02:14:11Z

Dmcarmon: /* Examples of Mixing */

= Introduction =

= Functional Programming =

Functional programming treats computation as the evaluation of mathematical functions. It is compute-centric rather than data-centric. Functional programming keeps no global state, does not use for or while loops, and data is immutable****. Instead, everything is done using functions, usually functions that evaluate mathematical expressions. Each of these functions maintain no internal state and will always produce the same output given the same input.

Let's look at an example. Suppose we have a list of numbers and we want to multiply each number in the list by 2. The first approach is the imperitive style:

array[] = {1,2,3,4,5}
for(i=0 ; i<array.length; i++){
array[i] = array[i] * 2;
}

In the above example, array[] is a global variable. If we fail to check the array length, then a runtime exception occurs which might result in the program being crashed. As far as functional style, there is a function called map(func,seq)(in python language) where the function 'func' is applied to each member of seq. The following code is written in a functional style.

numbers = [1,2,3,4,5]
/* define a method called compute on each number in the list */
def compute(var):
var = var * 2
return var
/* Now call the map function */
L = map(compute,numbers)
print L // L will print [1,4,6,8,10]

Notice that there is no global data nor any nested loops and the bound checking is handled internally within the map function. The programmer is relieved of of runtime errors and thus can debug the program easily.

Some advantages of this approach are:
* Easier debugging: Since every thing is broken down into small simple functions, the functions are often easy to debug.
* More compact code: Functional programming typically requires fewer lines of code. Since compution is done by function code reuse is prevelent.
* Nothing depends on state: Because functional programs keep no state information, the functions will always operate the same regardless of the past history of the program.

= Object-oriented Programming =
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] (OOP) is a programming paradigm organized around interacting "objects"(usually instances of a class) rather than "actions" and data rather than logic. A basic principle of OOP is that a program consists of a list of subroutines which can perform individually.

An object-oriented programming language provides support for the following object-oriented concepts--object, class, interface and inheritance. To illustrate this idea clearly and vividly let's review the following example-- your limbs. The "Limbs" is a class. Your body has two objects of type "limbs", named arms and legs. Their main functions are controlled/ managed by a set of biological signals sent from central nervous system( through an interface). So the nervous system is an interface which your body uses to interact with your limbs. The "limbs" is a well architected class. The "legs" has a subclass which contains "left leg" and "Right leg". The "legs" is being re-used to create the left leg and right leg by slightly changing the properties of it. If the "legs" owns attributes like length, color of skin etc, then the subclass, which contains "left leg" and "right leg" in this case, automatically inherit these attributes( that is called inheritance).

We could code in object-oriented paradigm as:

class Limbs /*define a class of limbs*/
def initialize(limbs,length,colorofskin)
@limbs=limbs
@length=length
@colorofskin=colorofskin
end
end
limbs=Limbs.new("legs","100cm","white") /*create a new object in class "Limbs"*/
class Legs<Limbs /*create a subclass "Legs",which belong to class"Limbs"*/
def initialize(legs,length,colorofskin)
super(length,colorofskin)
@legs=legs
end
end
legs=legs.new("left leg") /*create a new object in class of "Legs"*/

== Features of Object-oriented Programming ==
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]. A programmer can simply create a new object that inherits many of its features from super-class. And also, they can overwrite existing operations or add new ones.This makes object-oriented programs easier to modify.
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation].This refers to hiding the internal representation of the object from the outside view. You can hide unnecessary implementation details from the object user. One of the benefits of encapsulation is data protection.
* [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism].This allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects. Consider the operator '+', for numbers it will generate the sum, but for strings it will produce a third string which concatenates the input strings.

== Advantages of Object-oriented Programming ==
* Simplicity: we use software objects to simulate real world objects, so the complexity is reduced and the program structure is very clear.
* Modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system.
* Modifiability: programmers can easily make minor changes in the data representation or operations in an OOP. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods.
* Extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones.
* Maintainability: objects can be maintained separately, making locating and fixing problems easier.
* Re-usability: objects can be reused in different programs.

= Mixing Functional and Object-Oriented Programming =

Motivation for Mixing

== Functional Techniques useful for Object-Oriented Programming ==
In object-oriented world, data and operations are grouped together into modular units called objects and we combine objects into structured networks to form a program. The results are depend on arguments and objects' state at method invocation time. While in functional world, the basic elements are variables in the mathematical sense and functions in the mathematical sense. Functional programming can reduce side-effects. If there is no side-effects, it means your can apply the function at anywhere freely. No matter how you apply this function, the same input arguments produce the same results.

According to above-mentioned information, we can perform functional programming on an object-oriented programming language because:
1). object can have constant state
2). method can depend only on its arguments and context available at method definition time

Combining both these paradigms not only provide us a robust design structure, but also enable the programmers to develop solutions to complex problems quickly and effectively. One of the cornerstone of mixing functional and object-oriented code is treating functions as objects.It means that we can pass functions as arguments, store it and return them from other functions. This is highly useful in an user interface code where it can be used as call back functions which gets called when an event occurs(event driven programming).

Some of the basic features of Functional Programming which can be combined with Object Oriented paradigm are:

* Lambda Calculus
* Currying
* Powerful pattern matching

Let us now understand how each of the above feature of Functional language fits in the Object Oriented paradigm.

=== Lambda Calculus ===
Lambda calculus is the most critical basis of functional programming. A lambda expression is an anonymous expression that contain expressions and statements.Each expression stands for a function with one parameter.

Let consider the following function:

def f(x)
return x**2
print f(4)

We can use a lambda calculus to compute this expression without assigning it to a variable:

(lambda x:x**x)(4)

We can see that these two code snippets have the same results. It is more concise and flexible to define with lambda.
The above is a pure functional approach. In order to make code more state-less and concise, lambdas can be embedded inside the object-oriented language. The below code in Python demonstrates the use of lambda in a closure:

def fun(x):
return x%3==0
str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
filter(fun,str)

The above code works to find numbers which are divisible by 3.
We can simplify the code by the use of lambda as following:

str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print filter(lambda x: x%3==0, str)

=== Currying ===

=== Pattern Matching ===

== Examples of Mixing ==

A number of programming languages support mixing of both functional and object-oriented code. Three of these (Scala, Ruby, and Conjure), are described in more detail below.

=== Scala ===

[http://www.scala-lang.org/ Scala] is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. [http://www.scala-lang.org/ Scala] was conceived in 2001 and implemented by Martin Odersky. It supports mixing functional and object-oriented code.

==== Mixing Functional and Object-Oriented Code in Scala ====
[http://www.scala-lang.org/ Scala] is a strange specimen. It is a complete blend of object-oriented and functional programming. How can this happen? The functional world advocates immutability, but the object-oriented world focuses on the state and how to change it to fit your needs. [http://www.scala-lang.org/ Scala] allows you create both mutable and immutable objects. Consider the following example,
val str: String = "Hello World"
In the first line, an immutable version(a misnomer indeed) of <code>str</code> is being created . A rough translation into Java is below:

final String str = "Hello World"; //note the extra semi-colon
Consider the next example below,
val list: List[String] = List("Scala", "is", "the coolest", "language", "in the world!")

The same code can be written in Java as:

List<String> mutableList = new ArrayList<String>();
list.add("Scala");
list.add("is");
list.add("the coolest");
list.add("language");
list.add("in the world!");
List<String> immutableList = Collections.immutableList(mutableList);

Compared to Java, [http://www.scala-lang.org/ Scala] reduces the total number of lines you need to type and at the same time looks much simpler and less verbose. Even though the above example shows an immutable collection, scala also provides mutable collections and object types in the package <code>scala.collection.mutable.*</code>

As can be observed, even though [http://www.scala-lang.org/ Scala] advocates immutability, it does not restrict you from creating mutable objects. So it's the best of both worlds. Another part of the functional world is the concept of functions as ''''first class members'''' of the language. Some of the common languages like Ruby, Python and JavaScript all incorporate this feature. In the sense you can pass around functions to methods as a parameter. Enough talking;

Let us have a class say <code>'Person'</code> which has properties, <code>name</code> and another variable <code>age</code>.
In Java:

class Person{
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String s){
this.name = s;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}

In [http://www.scala-lang.org/ Scala]:
case class Person(name: String, age: Int)

This single line is equivalent to the above java code! Getters for <code>name</code> and <code>age</code>, <code>equals()</code>, and <code>hashCode()</code> method are automatically generated for you by the compiler. Isn't this an awesome feature?

Now assume we have a list of persons and we want to filter out all the persons who are of age 23. How would you do that in Java?

List<Person> persons; //has a bunch of person objects in it.
List<Person> twentyThree = new ArrayList<Person>();
for(Person p: persons){
if(p.getAge() == 23){
twentyThree.add(p);
}
}

In [http://www.scala-lang.org/ Scala]:

val twentyThree: List[Person] = persons.filter( _.age == 23)

That's it! In case you are wondering whats going on, filter is a method present on scala.List class and the code block <code>_.age == 23</code> is a function created on the fly and passed onto the filter method. More precisely its called a [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] - a functional concept which can be emulated in java only using anonymous inner classes. Scala's compiler transforms our one line function into some anonymous inner classes when generating java byte code, allowing developers to define functions in a simple manner.

In fact, every function is an object in [http://www.scala-lang.org/ Scala]. Scala's standard library has a number of functions which are objects themselves.

==== Implicits in Scala ====
In almost all programming languages, there is a necessity to profile the running time of the procedures and tune its performance. The old way of doing things in Java would be:

public class Main{
public static int factorial(int x){
if(x == 0 || x == 1) return 1
else return x * factorial(x-1)
}
public static void main(String [] args){
long beforeTime = System.currentTimeMillis();
int result = factorial(5);
System.out.println("Total time taken to execute factorial(5) is " + (System.currentTimeMillis() - result)+"ms");
System.out.println("factorial(5) = " + result);
}
}

However, if you want to find out the execution time of some other method, you would have to type in all the above lines again. So much for code re-use or [http://en.wikipedia.org/wiki/DRY DRY (dont't repeat yourself)]! Lets see how its done in [http://www.scala-lang.org/ Scala].

object Main{
def main(args: Array[String]){
def factorial(x: Int):Int = x match{
case 0 | 1 => 1
case _ => x * factorial(x-1)
}
import System.currentTimeMillis
def timeIt(msg: String = "Time to execute is: ")(func: => Unit){
val before = currentTimeMillis
func
println(msg + (currentTimeMillis - before) + "ms")
}
timeIt("Total time taken to execute factorial(5) is "){
val result = factorial(5)
println("factorial(5) = " + result)
}
}
//would print: factorial(5) = 120
// Total time taken to execute factorial(5) is 1ms

That's not right! The function <code>timeIt</code> looks like a feature built into the language. Try saving the above code into a separate file and run it - It will still work. Using this feature, it is possible to build powerful DSL languages which can run at full speed on JVM.

Ruby allows you to add new methods to objects. Since you are splitting open the class and adding/overriding methods (in)|(to) the class, this feature is often called [http://en.wikipedia.org/wiki/Monkey_patch Monkey Patching]. Because other libraries may depend on some methods which you changed, often this leads to unexpected behavior at runtime. However, Scala provides yet another feature called [http://en.wikipedia.org/wiki/Implicit_function implicits] which helps you do this better.

In Java, <code>String</code> class is <code>final</code> so there is no way you can add new methods to it. But with implicits you can do more! Suppose you have some text in memory and you know it represents a number. But in Java the usual way to convert string to int is to do a <code>Integer.parseInt(string)</code> which seems so unnecessary. Let us make our lives easier...

implicit def strToInt(str: String) = new {
def asInt = Integer.parseInt(str)
}
val str = "1234"
println(str.asInt * 3) //prints out 3702

The above code gives us an impression as if String class has gained new <code>asInt</code> method. Can static object oriented languages do this? No! Infact scala cheats by calling our implicits to convert it into a different object as and when needed.

The above functionalities are purely object oriented, yet they are safe. They don't pollute the global namespace, unlike Ruby or Python.

=== Ruby ===

Ruby is another language that, like Scala, supports mixing functional and object-oriented code. It is a dynamically typed Object-Oriented Language which supports multiple programming paradigms, including functional, object-oriented, imperative and reflective. In Ruby, everything is an object, every bit of information and code can have its own properties and actions. However, Ruby’s blocks can be functional. A Ruby programmer can attach a closure to any method, which generates a functional block inside an object oriented code. A closure is a piece of code that can access the lexical environment of its definition [http://www.ruby-lang.org/en/ 11].

==== Ruby Mixing Example ====

Consider the following code snippet in Ruby which uses Object Oriented concepts like Classes and functional programming concepts like lambda.

class Multiply
def initialize(n)
@block = lambda {|a| n * a}
end
def mul(a)
@block.call a
end
end
twoMultiplier = Multiply.new 2
puts twoMultiplier.mul(6)

Here,'''''@block''''' is a closure. When we call the class ''Multiply'' using '''''twoAdder = Multiply.new 2''''' ,the ''initialize'' method is called by passing the parameter 2. Here n=2 binds itself to the block. So @block will be 2*a, that is,the closure remembers the parameter with which the initialize method was called even after the initialize method exits.

This value is used when the block is called in the add method.
Thus,'''''twoMultiplier.mul(6)''''' will return 2*6 = 12

==== Functional Style Coding in Ruby Blocks ====

Blocks are basically nameless functions which can be passed to a function and then that function can invoke the passed in nameless function. This is a common style called [http://en.wikipedia.org/wiki/Higher-order_function higher order functions] among languages that handle functions as first class objects. Basically blocks can be designed for loop abstraction and lets the user to design their own way of iterating the values, thereby hiding the implementation details.
For example, if we want to iterate backwards from the end to the beginning without revealing its internal implementations, we could implement the loop logic inside the block and pass it to a method or function.

Here is a [http://www.ruby-lang.org/en/ Ruby] implementation of block:

def printlist(array,&reverse)
array.each do |element|
puts "array element: #{element}"
end
reverse.call(array) /* Here it prints the reverse implementation of list*/
end

printlist([1,2,3,4,5,6]) { |array|
array.reverse.each do |element|
puts "array element: #{element}"
end
}
The statements between { } is a block and it gets called by <code>reverse.call(array)</code>within the printlist method.

=== Clojure ===

Clojure[[http://oreilly.com/catalog/9781934356333 31]] is also a functional programming language, and it is a dialect of Lisp. It is not a pure functional language. Instead, it is a dynamically typed language. Just like Java it runs on JVM platform, but its syntax differs from Java. It is represented as :

(functions arguments...)

The function and its arguments are enclosed in paranthesis. It has features like immutable data structures, high-order functions, recursion, and easy and fast java interoperability.

In Clojure's model, value calculation is purely functional. Values never change. New values are functions of old. But, logical identity is well supported via atomic references to values. The value of a reference (state of an identity) is always observable without coordination and freely shareable between threads.
When programs are constructed this way, functional value calculation is independent of identity-value association. This makes clojure easier to understand and test.

====Example Using Functional Technique in Clojure====

Consider the following functional programming example in Clojure-
(defn make-adder [x]
(let [y x]
(fn [z] (+ y z))))
(def add2 (make-adder 2))
(add2 4)

Here,'''''defn make-adder [x]''''' defines a function called ''make-adder''.'''''let [y x]''''' gives a local name y for the value x. Since the scope of any local names is lexical, a function created in the scope of local names will close over their values.'''''fn [z] (+ y z)''''' does the addition of y and z.
''
'''def add2 (make-adder 2)''''' calls the function ''make-adder'' passing the parameter 2 and calls this as ''add2''.Now, ''add2'' has computed 2+z. When '''''add2 4''''' is called it computes 2+4=6

====Example Using Object-Oriented Technique in Clojure====

The following program implements Run-Time Polymorphism which is an object-oriented programming concept.
(defmulti encounter (fn [x y] [(:Species x) (:Species y)]))
(defmethod encounter [:Bunny :Lion] [b l] :run-away)
(defmethod encounter [:Lion :Bunny] [l b] :eat)
(defmethod encounter [:Lion :Lion] [l1 l2] :fight)
(defmethod encounter [:Bunny :Bunny] [b1 b2] :mate)
(def b1 {:Species :Bunny :other :stuff})
(def b2 {:Species :Bunny :other :stuff})
(def l1 {:Species :Lion :other :stuff})
(def l2 {:Species :Lion :other :stuff})

(encounter b1 l1)
-> :run-away
(encounter l1 l2)
-> :fight

Here,'''''defmulti''''' is used to define multiple methods which have the same method name '''''encounter'''''.Depending on the parameters passed to the encounter method, one of the four methods is called.
'''''def''''' defines each of the different species.
When, '''''(encounter b1 l1)''''' is called, the first ''encounter'' method is called with the parameters ''Bunny'' and ''Lion''. As a result, ''run-away'' is printed.

=== Summary of Languages Supporting Mixing ===

Each of the languages contains both functional and object-oriented features. The following table shows how each of the languages have both functional and object-oriented characterics. Not all characteristics of the languages are listed, but enough to demonstrate that the languages each have different ways of mixing object-oriented and functional techniques.

{| class="wikitable" border="2"
|-
!
! Functional Characteristics
! Object-Oriented Characteristics
|-
! Scala
| Immutable objects, the ability to pass functions as parameters, implicits, closures.
| Every value is a object, mutable objects.
|-
! Ruby
| Functional programming used in blocks.
| Everything is an object.
|-
! Clojure
| Immutable data structures, high-order functions, recursion.
| Objects, runtime polymorphism, [http://en.wikipedia.org/wiki/Multiple_dispatch multimethods.]
|-
|}

= Conclusion =

= References =
#[http://en.wikipedia.org/wiki/Functional_programming Wikipedia - Functional Programming]
#[http://www.cs.cornell.edu/riccardo/prog-smlnj/notes-011001.pdf Notes on programming Standard ML of New Jersey]
#[http://users.dickinson.edu/~braught/courses/cs132f01/classes/code/Factorial.src.html Introduction to Computing - Dickinson College]
#[http://en.wikipedia.org/wiki/Object-oriented_programming Wikipedia - Object Oriented Programming]
#[http://searchsoa.techtarget.com/sDefinition/0,,sid26_gci212681,00.html More on Object Oriented Programming]
#[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas Understanding Ruby Blocks, Procs and Lambdas - Robert Sosinski]
#[http://www.codingday.com/power-of-functional-programming-its-features-and-its-future/ Power of Functional Programming, its Features and its Future]
#[http://skillsmatter.com/podcast/open-source-dot-net/mike-wagg-mark-needham-functional-and-oo-approaches-to-c-sharp-programming Mixing Functional and Object Oriented Approaches to Programming in C#]
#[http://en.wikipedia.org/wiki/Programming_paradigm Programming Paradigm]
#[http://en.wikipedia.org/wiki/Recursion Recursion]
#[http://www.scala-lang.org/ Scala]
#[http://en.wikipedia.org/wiki/Scala_%28programming_language%29 Scala Wikipedia]
#[http://clojure.org/ Clojure]
#[http://www.ruby-lang.org/en/ Ruby]
#[http://en.wikipedia.org/wiki/Standard_ML Standard ML]
#[http://en.wikipedia.org/wiki/Haskell_%28programming_language%29 Haskell]
#[http://en.wikipedia.org/wiki/ML_%28programming_language%29 ML Family]
#[http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java]
#[http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]
#[http://en.wikipedia.org/wiki/C%2B%2B C++ Programming Language]
#[http://en.wikipedia.org/wiki/Visual_Basic_.NET Visual Basic .Net]
# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]
#O'Reilly (2009), "Programming Scala", ''O'Reilly Media Inc.''.
#Dave Thomas, Chad Fowler, Andy Hunt (2006) ''Programming Ruby'', The Pragmatic Bookshelf.
#[http://lamp.epfl.ch/~phaller/doc/haller10-Translucent_functions.pdf Philipp Halle, Lightweight language support for type-based, concurrent event processing, Lausanne, Switzerland, April 2010.]
#[http://biblion.epfl.ch/EPFL/theses/2007/3899/EPFL_TH3899.pdf Burak Emir, Object-Oriented Pattern Matching, EPFL, October 2007].

= Mixing Functional & O-O code =

This chapter deals with the mixing of functional and object-oriented programming paradigms. We start with listing the different programming paradigms available today. We introduce functional and object-oriented approaches briefly and then discuss the advantages of one over the other. Following this, we discuss some aspects and features of mixing both the approaches. Finally, we talk about few languages that constitute such a mix.

== Programming Paradigms Today==

Several programmatic approaches to solve a particular task lead to distinct programming paradigms like, 
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
* Functional programming 
* Object Oriented programming 
* [http://en.wikipedia.org/wiki/Logic_programming Logical programming], etc. 
Lets focus on functional and object oriented programming approaches.

== Functional Programming ==

[http://en.wikipedia.org/wiki/Functional_programming Functional programming] is the task of decomposing a problem into a number of functions. Selectively executing these functions results in the solution to the problem. The functions mostly behave as mathematical. For given set of inputs the program should always return the same output. It usually concentrates on what type of problem we are dealing with rather than on the details of how to solve the problem. For example lets say there is a function which calculates area of a square. If we use it six times then we end up with area of a cube. Thus functional programming helps to build complex systems.

=== Approach ===

Expressions are the collection of variables and operations resulting in a single value this also deals with the way of solving the problem as expressions. Hence also called Expression related programming. It is structured as expression where each expression can be encapsulated in another yielding the result. Making the change in data structures as the program runs is called [http://en.wikipedia.org/wiki/Side_effect_(computer_science) side effects]. Purely functional language has no side effects. Language like Haskell is a pure functional language . Some languages need many approaches for achieving the desired result. Such languages are multi-paradigm. Examples for such languages are C++, Python,Lisp. Its like evaluating an expression and use the resulting value for something.

Structure of functional programming :

(fn2 ( fn1 ()[input list] ) []) => fn1 takes input list and the output of fn1 is used as input to fn2. Its a schematic representation of
how functional programming works.

Functional programming feature (Python) :

m = map(lambda i : i*i , numbers)
where ''numbers'' is an array of numbers and ''lambda'' is [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 closure].

Python has some functions like map, filter, reduce to support functional programming style. In the example above, the 'map' is a high-order function that takes a function and an array of numbers as input. The ''lambda'' takes i as input and returns i*i as output. Every result returned is appended to a list and produced as output. In functional programming, the programmer is given a natural framework for developing smaller, simpler, and more general modules, which are then glued together.

== Object Oriented Programming ==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] is a programming technique where everything is defined as an object. Objects are well-defined discrete bundles of data(attributes) and the associated functions(behavior). They are devised to resemble real-life objects and are uniquely identifiable by a name. The attributes could be of simple datatype(int, String, Boolean) or objects themselves. The behavior is defined by methods to use and manipulate the attributes. The values of attributes of an object at an instant is the state of the object. OO Programming allows objects to have their state retained throughout the code until manipulated otherwise. Objects are capable of housekeeping their own states, interacting and establishing relationships with other objects, inheriting, etc.

=== Fundamental concepts ===

A [http://en.wikipedia.org/wiki/Class_%28computer_science%29 class] is a user-defined datatype that provides implementation details to define the attributes and their properties. It is an abstract representation of an object(i.e.,) like a mold for objects.
An instance is an executable copy of a class. They are the actual objects created using the ‘class mold’ on run time.
Methods are a set of procedural statements or functions to define the behavior of an object, convey the current state, modify values of the attributes, etc.

Example :

An object in Java might look like this:

public class Person {
private String name;
public Person() {
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}

Here, OO Programming allows the programmer to set the ''name'' attribute of the class ''Person'' and get the name whenever needed in the code. An object of this class Person will remain in memory forever as long as there is a reference to it. As OO Programming allows objects to have their state retained, the value of the ''name'' attribute for a particular ''Person'' object remains the same across any part of the code until it is set differently.

=== Features ===

Three primary characteristics of object oriented programming are Encapsulation, Polymorphism, and Inheritance.
[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation] is the ability of objects to hide visibility of their attributes and behavior, thereby providing service independent of implementation.
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects.
[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance] is one where an existing type can be used to derive a new type. Derived types inherit the data and operations of the super-type. And also, they can overwrite existing operations or add new ones.

There are other important features of O-O programming like [http://en.wikipedia.org/wiki/Message_passing message passing], [http://en.wikipedia.org/wiki/Abstraction abstraction], delegation, etc.

Now, we have seen both the approaches and their features in brief. Lets discuss the advantages of one over the other.

== Advantages ==

=== Functional Approach over OO Approach[[http://www.jot.fm/issues/issue_2009_09/article5.pdf 8]]===
* Functional programming solves the problem with lesser number of lines of code than the OO programming style. 
* There is no side effect as they use immutable data structures also called [http://en.wikipedia.org/wiki/Persistent_data_structure Persistent Data Structure] which will have no change in the state of variables. Hence program dont have to depend on history. 
* There is no limit in the numeric types used as opposed to OO languages which mainly depend on primitive data types. 
* A programmer is given the freedom to think in terms of what to solve in the problem rather than concentrating on how to solve and the flow of the program. 
* Suitable for calculation intensive programs.

=== OO Approach over Functional Approach===
* Everything can be represented in an object and it has the attributes associated with it and hence the state of the object is known at any time. 
* A complex system can be subdivided into modules of objects where as in functional approach, many functions inter operate to form a complex system. 
* [http://en.wikipedia.org/wiki/Reusability Re-usability] (i.e.) OO approach enables programmers to create new objects that inherits many of its features from existing objects. This makes object-oriented programs easier to modify than functional. 
* [http://en.wikipedia.org/wiki/Debug Debugging] in Object Oriented environment is easy compared with functional approach where a small error in one function causes the whole system (i.e. all the functions) to fail. 
* Suitable for making application-oriented software. 

Both the approaches have their advantages and disadvantages. What if we could get the best of both the worlds? The next section deals with the aspects and features of how well both the approaches are mixed together in some languages.

== Mixing Functional & OO Code - Best of both the worlds ==

Languages that are a mix of functional and object oriented approaches(eg. Scala[[http://www.scala-lang.org/node/1305 1]], Clojure[[http://oreilly.com/catalog/9781934356333 10]], etc.) make use of best of both the worlds. They support various aspects of functional and object oriented approaches. They have a bunch of functional approach features[[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf 6]], which object oriented programming languages(like Java) lack which includes closures. Closures are first-class functions with free variables that are bound in the lexical environment. These languages also sport a very malleable syntax that makes them well suited for "domain specific languages" with the benefits of static typing. They are more expressive, extensible and allow reuse of programming abstractions.

Certain languages like Scala, Clojure, etc run on Java Virtual Machine(JVM) ensuring portability to all underlying platforms. They even support immutable objects. In Scala, new language constructs can be added in the form of libraries. They allow safe reuse[[http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf 9]] of programming abstractions and type-safe extension of software.

===Lambda===

A lambda[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] expression is an anonymous function that contain expressions and statements, and can be used to create delegates or expression types. Such kind of anonymous function can be defined and passed around as easily as other data types and can be used to contain functionality that need not be named. Some notable examples include closures[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] and currying. Lambda functions with no name can be called using the variable assigned to it.

g = lambda x: x*2
g(3)=6

We can have lambda function without assigning it to a variable which can be used as inline-function.

(lambda x: x*2)(3)

In [http://en.wikipedia.org/wiki/Clojure Clojure] as a functional language, the creation of a chunk of behavior that can be assigned to a variable (known as a lambda) is trivial. Below are two ways to create a lambda that returns the square of its argument.

(def square1 (fn [n] (* n n)))
(def square2 #(* % %))

===Currying ===

[http://en.wikipedia.org/wiki/Currying Currying] transforms a function that takes multiple parameters into a chain of functions, each taking a single parameter. It reuses a partially applied function where the function is originally defined as accepting n parameters.It can be interpreted as the technique to decompose a function that takes n parameters into n function each of them taking 1 parameter. For example to say in algebraic terms,consider the function f which takes 3 parameters x,y,z and Currying means that we can rewrite the function as a composition of 3 functions:

f(x,y,z) = 4*x+3*y+2*z
f(x)(y)(z) = 2*z+(3*y+(4*x))

In Scala, currying takes advantage of Scala’s syntactic sugar. Below is a currying example in Scala. This function creates a multiplier function which takes two arguments and partially defines it by assigning a constant to one argument and assigning it to a variable .Later the function is called by assigning the second argument.

def multiplier(i: Int)(factor: Int) = i * factor => method named multiplier which takes two parameters is defined
val byFive = multiplier(5) _ => The method is redefined with accepting one parameter and store it in a variable.
val byTen = multiplier(10) _

scala> byFive(2) => Method called by giving the second parameter.
res4: Int = 10

scala> byTen(2)
res5: Int = 20

===Less Verbosity===

In Java each variable should have its type defined beforehand. Whereas in languages like Scala, it is more concise and easier to read than the equivalent Java.

For example, a Map can be created with a simple syntax in Scala,Clojure than in Java:

<table>
<tr>
<td>
'''Java'''
Map<String, Integer> nMap = new HashMap<String, Integer>();
nMap.put("one", 1);
nMap.put("two", 2);
nMap.put("three", 3);
</td>
<td>
'''Scala'''

var nMap = Map("one" -> 1, "two" -> 2, "three" -> 3)

</td>
<td>
'''Clojure'''

(doto (new Java.util.HashMap)(.put “a” 1)(.put “b” 2))

</td>
</tr>
</table>

Here, Scala compiler knows that nMap uses Strings as keys, and Integers as values. Unlike Java, this need not be specified beforehand. Scala could figure it out itself. Moreover, Scala will give an error if a different key-value pair is tried to insert. This is called "type inference". This prevents a whole class of bugs at run time just like Java but with less verbosity.
In a similar way Clojure also involves only few lines of code compared with the object oriented Java language which takes many lines of code.A simple Clojure example and the associated Java code :
Example

(defn blank? [s] (every? #(Character/isWhitespace %) s))

The innermost function Character/isWhiteSpace checks the first argument % for any whitespace and returns true if it is. every? invoke the above inner function for all elements in the collection s.It has no variables, no branches etc.

Java code
isBlank() method checks to see whether a string is blank or contains only whitespace.

public class Stringcheck{
public static boolean isBlank(String str){
int len;
if(str==null || (strlen =str.length())==0)
return true;
for(int i=0; i<strlen;i++) {
if((Character.isWhitespace(str.charAt(i))==false)){
return false;
}
}
return true;
}
}

=== Pattern Matching ===

To say simply, a [http://en.wikipedia.org/wiki/Pattern_matching Pattern matching] is a technique to search string for the occurrence of any patterns or regularity. Pattern matching is an elegant way to decompose objects into their constituent parts for processing.Many languages support the concept of pattern matching. Perl supports pattern matching using the pattern definition mini language called regular expressions, also called regexes or REs, which is borrowed from the regular expressions used in many Unix tools, such as grep() and sed().The risk that the parts of an object might be changed outside of the control of the enclosing object is avoided. For example, if there is a Person class that contains a list of addresses, it will not be an issue to expose that list to clients if the list is immutable. The users will not be able to change the list unexpectedly.Given below is a simple example for pattern matching used in Perl:

$mystring = "Hello world!"; // Perls way of assigning string to a variable.
if($mystring =~ m/World/) { print "Yes"; } // Checks the string stored in variable mystring has the string "World".
$mystring =~ s/world/mom/; // Replaces the string "world" stored in mystring to mom.

Another sample of regular expression in java :

String mystring="Hello World" ;
Pattern str = Pattern.compile("\\w+"); => Pattern stored for matching.
Matcher fit = str.matcher(mystring); => Matcher class which perform matching of the string with the pattern defined.
if(fit.matches())

As languages like Scala and Clojure support procedural code, pattern matching is done as equal or with less difficulty compared with Java which needs to use regex. Scala can even be embedded into XML as its syntax is somewhat similar.Given below an overview of how regular expression is achieved in Clojure.
Data are manipulated in Clojure through the sequence called seq which is a logical list. Clojure can access java collections, its collections, Regular expression matches via the seq also called seq-able. Clojure's regular expression uses java.util.regex library at the lowest level. For achieving that the keyword re-seq is used.
Syntax:
(re-seq regexp string)
Example
(re-seq #"\w+" "Hello World") => ("Hello" "World") => #"\w+" represents the java.util.regex.Pattern

=== Java Interoperability ===
Considering Clojure, it gives clean, simple and direct access to java and can access Java API directly.Clojure doesnot wrap Java's string functions. We can call using Java interop forms. It provides syntax for accessing Java elements like classes, instances, constructors, methods and fields and can also wrap Java API. The “.” dot special form is used for accessing Java. Some Clojure syntax which can access Java API: 

{| class="wikitable" border="2"
|-
! Java
! Clojure
|-
| new Widget(“red”)
| (new Widget “red”)
|-
| Math.PI
| (.Math PI) or Math/PI
|-
| System.currentTimeMillis()
| (.System currentTimeMillis) or System/currentTimeMillis
|-
| rnd.nextInt()
| (.rnd nextInt) or (.nextInt rnd)
|-
|}

Clojure pass functions as arguments to other functions. But Java does not support this. So Clojure provides a member function memfn macro to wrap methods or can use anonymous function to wrap a method call.
(map (memfn toUpperCase) [“a” ,”short”,”message”])
or
(map #(.toUpperCase %)[“a”,”short”,”message”]) => #(body) represents the anonymous function in Clojure.

For example,
(def the-digits
(map #(Integer. (str %))(filter #(Character/isDigit %) (seq big-num-str))))

where (def big-num-str (str "123785334434se9088af8309304293872adbcdfd”))

The above code extracts the integers from string and discards the non-numeric characters. Lets look at the functions defined in the example. There are totally five functions defined.They are
(seq big-num-str) => get each character defined in big-num-str
(Character/isDigit %) => Checks whether the input is an integer
(filter #()) => Filter each string from str
(map #(Integer. (str %))) => Change the string to integer
(def the-digits) => Output the integers only in a string of characters.
Here,
#(Character/isDigit) represents the Java method Character.isDigit() and #(Integer.(str %)) represents the new java.lang.Integer(str(%))

Most of the Clojure library functions have defined semantics for objects of Java types. contains? and .get work on Java’s Maps, arrays, Strings, count works on Java Strings, Collections and arrays. Clojure is built around these aspects. It avails the performance of JVM and the richness of both the core APIs and the numerous third-party libraries written in the Java language and restrained from reinventing them.

=== Multiple Inheritance ===

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance][http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf 2] is the concept of using the methods and variables of more than one superclass to a sub class.Java was designed without multiple inheritance. But Java supports the solution of problems commonly solved with multiple inheritance in other ways with help of interfaces where the methods defined in it are not implemented.In Scala, classes are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance in Java.Lets see how multiple inheritance achieved in Scala:

As interfaces in Java, Scala allows traits but has some methods partially implemented. The only difference to classes is the traits may not have constructor parameters.

trait Similarity {
def isSimilar(x: Any): Boolean // not implemented
def isNotSimilar(x: Any): Boolean = !isSimilar(x) //implemented method
}

This trait defines two methods isSimilar and isNotSimilar where isSimilar does not provide a concrete method implementation (it is abstract in the terminology of Java), and the method isNotSimilar defines a concrete implementation. Consequently, classes that integrate this trait only have to provide a concrete implementation for isSimilar.

class Point(xc: Int, yc: Int) extends Similarity {
var x: Int = xc
var y: Int = yc
def isSimilar(obj: Any) = //need to implement the method here
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
}

object TraitsTest extends Application {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotSimilar(p2))
println(p1.isNotSimilar(p3)) //uses the already defined method
println(p1.isNotSimilar(2))
}

These are some of the aspects and traits of mixing functional and object-oriented approaches. As we discussed in the advantages section, both the approaches have their benefits and limitations. Mixing them aspect-wise enables the above features in such languages. Lets discuss those languages briefly in the next section.

== Languages Supporting Functional and OO code ==

OCaml and F#[[http://msdn.microsoft.com/en-us/library/dd233154.aspx 7]] are some of the languages which support both functional and object oriented programming. OCaml is as fast as C and its featured as [http://www.haskell.org/ Haskell] which is a pure functional language. F#[[http://oreilly.com/catalog/9780596153656 3]] is a dynamically typed language which can run on .NET framework and has supported immutable types i.e. tuples, records, discriminated unions and lists to work in Functional programming. It has functions that can either be in curried or in uncurried form. As in functional language it can pass functions as arguments to other functions, resulting in higher order functions. It also supports lambda functions and closures. F#,behaves like other .NET languages as both in imperative and object oriented style. 

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language and it is a dialect of Lisp. It is not a pure functional language and it is a dynamically typed language. Just like Java it runs on JVM platform. But its syntax differs from Java. It is represented as :

(functions arguments...)

The function followed by its arguments is enclosed in paranthesis. It has features like immutable data structures, high-order functions and recursion, easy and fast java interoperability. 

Python and Ruby are also the programming languages which offer the mix of functional and OO languages. But these languages doesn't support the algebraic data types and pattern matching.

==Conclusion ==
The above aspects of functional and object oriented programming techniques discuss some if their merits and demerits. Mixing them produces a new programming paradigm which leads to a new dimension in programming. A few fundamental concepts are explored in Clojure and Scala here. The ability of Clojure and Scala to run in JVM platform makes them more preferable than others in the market. Some of the merits like closure, less verbosity, high order functions, currying along with interoperation with previously written libraries in these languages make them more efficient and useful. There are also other languages which support functional and object oriented techniques. Mixing the approaches, evolve a new dimension in programming which is practical and opens doors to more exploration.

== References ==

# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-11T01:48:23Z

Dmcarmon: /* References */

= Introduction =

= Functional Programming =

Functional programming treats computation as the evaluation of mathematical functions. It is compute-centric rather than data-centric. Functional programming keeps no global state, does not use for or while loops, and data is immutable****. Instead, everything is done using functions, usually functions that evaluate mathematical expressions. Each of these functions maintain no internal state and will always produce the same output given the same input.

Let's look at an example. Suppose we have a list of numbers and we want to multiply each number in the list by 2. The first approach is the imperitive style:

array[] = {1,2,3,4,5}
for(i=0 ; i<array.length; i++){
array[i] = array[i] * 2;
}

In the above example, array[] is a global variable. If we fail to check the array length, then a runtime exception occurs which might result in the program being crashed. As far as functional style, there is a function called map(func,seq)(in python language) where the function 'func' is applied to each member of seq. The following code is written in a functional style.

numbers = [1,2,3,4,5]
/* define a method called compute on each number in the list */
def compute(var):
var = var * 2
return var
/* Now call the map function */
L = map(compute,numbers)
print L // L will print [1,4,6,8,10]

Notice that there is no global data nor any nested loops and the bound checking is handled internally within the map function. The programmer is relieved of of runtime errors and thus can debug the program easily.

Some advantages of this approach are:
* Easier debugging: Since every thing is broken down into small simple functions, the functions are often easy to debug.
* More compact code: Functional programming typically requires fewer lines of code. Since compution is done by function code reuse is prevelent.
* Nothing depends on state: Because functional programs keep no state information, the functions will always operate the same regardless of the past history of the program.

= Object-oriented Programming =
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] (OOP) is a programming paradigm organized around interacting "objects"(usually instances of a class) rather than "actions" and data rather than logic. A basic principle of OOP is that a program consists of a list of subroutines which can perform individually.

An object-oriented programming language provides support for the following object-oriented concepts--object, class, interface and inheritance. To illustrate this idea clearly and vividly let's review the following example-- your limbs. The "Limbs" is a class. Your body has two objects of type "limbs", named arms and legs. Their main functions are controlled/ managed by a set of biological signals sent from central nervous system( through an interface). So the nervous system is an interface which your body uses to interact with your limbs. The "limbs" is a well architected class. The "legs" has a subclass which contains "left leg" and "Right leg". The "legs" is being re-used to create the left leg and right leg by slightly changing the properties of it. If the "legs" owns attributes like length, color of skin etc, then the subclass, which contains "left leg" and "right leg" in this case, automatically inherit these attributes( that is called inheritance).

We could code in object-oriented paradigm as:

class Limbs /*define a class of limbs*/
def initialize(limbs,length,colorofskin)
@limbs=limbs
@length=length
@colorofskin=colorofskin
end
end
limbs=Limbs.new("legs","100cm","white") /*create a new object in class "Limbs"*/
class Legs<Limbs /*create a subclass "Legs",which belong to class"Limbs"*/
def initialize(legs,length,colorofskin)
super(length,colorofskin)
@legs=legs
end
end
legs=legs.new("left leg") /*create a new object in class of "Legs"*/

== Features of Object-oriented Programming ==
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]. A programmer can simply create a new object that inherits many of its features from super-class. And also, they can overwrite existing operations or add new ones.This makes object-oriented programs easier to modify.
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation].This refers to hiding the internal representation of the object from the outside view. You can hide unnecessary implementation details from the object user. One of the benefits of encapsulation is data protection.
* [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism].This allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects. Consider the operator '+', for numbers it will generate the sum, but for strings it will produce a third string which concatenates the input strings.

== Advantages of Object-oriented Programming ==
* Simplicity: we use software objects to simulate real world objects, so the complexity is reduced and the program structure is very clear.
* Modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system.
* Modifiability: programmers can easily make minor changes in the data representation or operations in an OOP. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods.
* Extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones.
* Maintainability: objects can be maintained separately, making locating and fixing problems easier.
* Re-usability: objects can be reused in different programs.

= Mixing Functional and Object-Oriented Programming =

Motivation for Mixing

== Functional Techniques useful for Object-Oriented Programming ==
In object-oriented world, data and operations are grouped together into modular units called objects and we combine objects into structured networks to form a program. The results are depend on arguments and objects' state at method invocation time. While in functional world, the basic elements are variables in the mathematical sense and functions in the mathematical sense. Functional programming can reduce side-effects. If there is no side-effects, it means your can apply the function at anywhere freely. No matter how you apply this function, the same input arguments produce the same results.

According to above-mentioned information, we can perform functional programming on an object-oriented programming language because:
1). object can have constant state
2). method can depend only on its arguments and context available at method definition time

Combining both these paradigms not only provide us a robust design structure, but also enable the programmers to develop solutions to complex problems quickly and effectively. One of the cornerstone of mixing functional and object-oriented code is treating functions as objects.It means that we can pass functions as arguments, store it and return them from other functions. This is highly useful in an user interface code where it can be used as call back functions which gets called when an event occurs(event driven programming).

Some of the basic features of Functional Programming which can be combined with Object Oriented paradigm are:

* Lambda Calculus
* Currying
* Powerful pattern matching

Let us now understand how each of the above feature of Functional language fits in the Object Oriented paradigm.

=== Lambda Calculus ===
Lambda calculus is the most critical basis of functional programming. A lambda expression is an anonymous expression that contain expressions and statements.Each expression stands for a function with one parameter.

Let consider the following function:

def f(x)
return x**2
print f(4)

We can use a lambda calculus to compute this expression without assigning it to a variable:

(lambda x:x**x)(4)

We can see that these two code snippets have the same results. It is more concise and flexible to define with lambda.
The above is a pure functional approach. In order to make code more state-less and concise, lambdas can be embedded inside the object-oriented language. The below code in Python demonstrates the use of lambda in a closure:

def fun(x):
return x%3==0
str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
filter(fun,str)

The above code works to find numbers which are divisible by 3.
We can simplify the code by the use of lambda as following:

str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print filter(lambda x: x%3==0, str)

=== Currying ===

=== Pattern Matching ===

== Examples of Mixing ==

A number of programming languages support mixing of both functional and object-oriented code. Three of these (Scala, Ruby, and Conjure), are described in more detail below.

=== Scala ===

[http://www.scala-lang.org/ Scala] is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. [http://www.scala-lang.org/ Scala] was conceived in 2001 and implemented by Martin Odersky. It supports mixing functional and object-oriented code.

==== Mixing Functional and Object-Oriented Code in Scala ====
[http://www.scala-lang.org/ Scala] is a strange specimen. It is a complete blend of object-oriented and functional programming. How can this happen? The functional world advocates immutability, but the object-oriented world focuses on the state and how to change it to fit your needs. [http://www.scala-lang.org/ Scala] allows you create both mutable and immutable objects. Consider the following example,
val str: String = "Hello World"
In the first line, an immutable version(a misnomer indeed) of <code>str</code> is being created . A rough translation into Java is below:

final String str = "Hello World"; //note the extra semi-colon
Consider the next example below,
val list: List[String] = List("Scala", "is", "the coolest", "language", "in the world!")

The same code can be written in Java as:

List<String> mutableList = new ArrayList<String>();
list.add("Scala");
list.add("is");
list.add("the coolest");
list.add("language");
list.add("in the world!");
List<String> immutableList = Collections.immutableList(mutableList);

Compared to Java, [http://www.scala-lang.org/ Scala] reduces the total number of lines you need to type and at the same time looks much simpler and less verbose. Even though the above example shows an immutable collection, scala also provides mutable collections and object types in the package <code>scala.collection.mutable.*</code>

As can be observed, even though [http://www.scala-lang.org/ Scala] advocates immutability, it does not restrict you from creating mutable objects. So it's the best of both worlds. Another part of the functional world is the concept of functions as ''''first class members'''' of the language. Some of the common languages like Ruby, Python and JavaScript all incorporate this feature. In the sense you can pass around functions to methods as a parameter. Enough talking;

Let us have a class say <code>'Person'</code> which has properties, <code>name</code> and another variable <code>age</code>.
In Java:

class Person{
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String s){
this.name = s;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}

In [http://www.scala-lang.org/ Scala]:
case class Person(name: String, age: Int)

This single line is equivalent to the above java code! Getters for <code>name</code> and <code>age</code>, <code>equals()</code>, and <code>hashCode()</code> method are automatically generated for you by the compiler. Isn't this an awesome feature?

Now assume we have a list of persons and we want to filter out all the persons who are of age 23. How would you do that in Java?

List<Person> persons; //has a bunch of person objects in it.
List<Person> twentyThree = new ArrayList<Person>();
for(Person p: persons){
if(p.getAge() == 23){
twentyThree.add(p);
}
}

In [http://www.scala-lang.org/ Scala]:

val twentyThree: List[Person] = persons.filter( _.age == 23)

That's it! In case you are wondering whats going on, filter is a method present on scala.List class and the code block <code>_.age == 23</code> is a function created on the fly and passed onto the filter method. More precisely its called a [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] - a functional concept which can be emulated in java only using anonymous inner classes. Scala's compiler transforms our one line function into some anonymous inner classes when generating java byte code, allowing developers to define functions in a simple manner.

In fact, every function is an object in [http://www.scala-lang.org/ Scala]. Scala's standard library has a number of functions which are objects themselves.

==== Implicits in Scala ====
In almost all programming languages, there is a necessity to profile the running time of the procedures and tune its performance. The old way of doing things in Java would be:

public class Main{
public static int factorial(int x){
if(x == 0 || x == 1) return 1
else return x * factorial(x-1)
}
public static void main(String [] args){
long beforeTime = System.currentTimeMillis();
int result = factorial(5);
System.out.println("Total time taken to execute factorial(5) is " + (System.currentTimeMillis() - result)+"ms");
System.out.println("factorial(5) = " + result);
}
}

However, if you want to find out the execution time of some other method, you would have to type in all the above lines again. So much for code re-use or [http://en.wikipedia.org/wiki/DRY DRY (dont't repeat yourself)]! Lets see how its done in [http://www.scala-lang.org/ Scala].

object Main{
def main(args: Array[String]){
def factorial(x: Int):Int = x match{
case 0 | 1 => 1
case _ => x * factorial(x-1)
}
import System.currentTimeMillis
def timeIt(msg: String = "Time to execute is: ")(func: => Unit){
val before = currentTimeMillis
func
println(msg + (currentTimeMillis - before) + "ms")
}
timeIt("Total time taken to execute factorial(5) is "){
val result = factorial(5)
println("factorial(5) = " + result)
}
}
//would print: factorial(5) = 120
// Total time taken to execute factorial(5) is 1ms

That's not right! The function <code>timeIt</code> looks like a feature built into the language. Try saving the above code into a separate file and run it - It will still work. Using this feature, it is possible to build powerful DSL languages which can run at full speed on JVM.

Ruby allows you to add new methods to objects. This feature is often called as [http://en.wikipedia.org/wiki/Monkey_patch Monkey Patching] because you are splitting open the class and adding/overriding methods (in)|(to) the class. Because other libraries may depend on some methods which you changed, often this leads to unexpected behavior at runtime. However, Scala provides yet another feature called [http://en.wikipedia.org/wiki/Implicit_function implicits] which helps you do this better.

In Java, <code>String</code> class is <code>final</code> so there is no way you can add new methods to it. But with implicits you can do more! Suppose you have some text in memory and you know it represents a number. But in Java the usual way to convert string to int is to do a <code>Integer.parseInt(string)</code> which seems so unnecessary. Let us make our lives easier...

implicit def strToInt(str: String) = new {
def asInt = Integer.parseInt(str)
}
val str = "1234"
println(str.asInt * 3) //prints out 3702

The above code gives us an impression as if String class has gained new <code>asInt</code> method. Can static object oriented languages do this? No! Infact scala cheats by calling our implicits to convert it into a different object as and when needed.

The above functionalities are purely object oriented, yet they are safe. They don't pollute the global namespace, unlike Ruby or Python.

=== Ruby ===

Ruby is another language that, like Scala, supports mixing functional and object-oriented code. It is a dynamically typed Object-Oriented Language which supports multiple programming paradigms, including functional, object-oriented, imperative and reflective. In Ruby, everything is an object, every bit of information and code can have its own properties and actions. However, Ruby’s blocks can be functional. A Ruby programmer can attach a closure to any method, which generates a functional block inside an object oriented code. A closure is a piece of code that can access the lexical environment of its definition [http://www.ruby-lang.org/en/ 11].

==== Ruby Mixing Example ====

Consider the following code snippet in Ruby which uses Object Oriented concepts like Classes and functional programming concepts like lambda.

class Multiply
def initialize(n)
@block = lambda {|a| n * a}
end
def mul(a)
@block.call a
end
end
twoMultiplier = Multiply.new 2
puts twoMultiplier.mul(6)

Here,'''''@block''''' is a closure. When we call the class ''Multiply'' using '''''twoAdder = Multiply.new 2''''' ,the ''initialize'' method is called by passing the parameter 2. Here n=2 binds itself to the block. So @block will be 2*a, that is,the closure remembers the parameter with which the initialize method was called even after the initialize method exits.

This value is used when the block is called in the add method.
Thus,'''''twoMultiplier.mul(6)''''' will return 2*6 = 12

==== Functional Style Coding in Ruby Blocks ====

Blocks are basically nameless functions which can be passed to a function and then that function can invoke the passed in nameless function. This is a common style called [http://en.wikipedia.org/wiki/Higher-order_function higher order functions] among languages that handle functions as first class objects. Basically blocks can be designed for loop abstraction and lets the user to design their own way of iterating the values, thereby hiding the implementation details.
For example, if we want to iterate backwards from the end to the beginning without revealing its internal implementations, we could implement the loop logic inside the block and pass it to a method or function.

Here is a [http://www.ruby-lang.org/en/ Ruby] implementation of block:

def printlist(array,&reverse)
array.each do |element|
puts "array element: #{element}"
end
reverse.call(array) /* Here it prints the reverse implementation of list*/
end

printlist([1,2,3,4,5,6]) { |array|
array.reverse.each do |element|
puts "array element: #{element}"
end
}
The statements between { } is a block and it gets called by <code>reverse.call(array)</code>within the printlist method.

=== Clojure ===

Clojure[[http://oreilly.com/catalog/9781934356333 31]] is also a functional programming language, and it is a dialect of Lisp. It is not a pure functional language. Instead, it is a dynamically typed language. Just like Java it runs on JVM platform, but its syntax differs from Java. It is represented as :

(functions arguments...)

The function and its arguments are enclosed in paranthesis. It has features like immutable data structures, high-order functions, recursion, and easy and fast java interoperability.

In Clojure's model, value calculation is purely functional. Values never change. New values are functions of old. But, logical identity is well supported via atomic references to values. The value of a reference (state of an identity) is always observable without coordination and freely shareable between threads.
When programs are constructed this way, functional value calculation is independent of identity-value association. This makes clojure easier to understand and test.

====Example Using Functional Technique in Clojure====

Consider the following functional programming example in Clojure-
(defn make-adder [x]
(let [y x]
(fn [z] (+ y z))))
(def add2 (make-adder 2))
(add2 4)

Here,'''''defn make-adder [x]''''' defines a function called ''make-adder''.'''''let [y x]''''' gives a local name y for the value x. Since the scope of any local names is lexical, a function created in the scope of local names will close over their values.'''''fn [z] (+ y z)''''' does the addition of y and z.
''
'''def add2 (make-adder 2)''''' calls the function ''make-adder'' passing the parameter 2 and calls this as ''add2''.Now, ''add2'' has computed 2+z. When '''''add2 4''''' is called it computes 2+4=6

====Example Using Object-Oriented Technique in Clojure====

The following program implements Run-Time Polymorphism which is an object-oriented programming concept.
(defmulti encounter (fn [x y] [(:Species x) (:Species y)]))
(defmethod encounter [:Bunny :Lion] [b l] :run-away)
(defmethod encounter [:Lion :Bunny] [l b] :eat)
(defmethod encounter [:Lion :Lion] [l1 l2] :fight)
(defmethod encounter [:Bunny :Bunny] [b1 b2] :mate)
(def b1 {:Species :Bunny :other :stuff})
(def b2 {:Species :Bunny :other :stuff})
(def l1 {:Species :Lion :other :stuff})
(def l2 {:Species :Lion :other :stuff})

(encounter b1 l1)
-> :run-away
(encounter l1 l2)
-> :fight

Here,'''''defmulti''''' is used to define multiple methods which have the same method name '''''encounter'''''.Depending on the parameters passed to the encounter method, one of the four methods is called.
'''''def''''' defines each of the different species.
When, '''''(encounter b1 l1)''''' is called, the first ''encounter'' method is called with the parameters ''Bunny'' and ''Lion''. As a result, ''run-away'' is printed.

= Conclusion =

= References =
#[http://en.wikipedia.org/wiki/Functional_programming Wikipedia - Functional Programming]
#[http://www.cs.cornell.edu/riccardo/prog-smlnj/notes-011001.pdf Notes on programming Standard ML of New Jersey]
#[http://users.dickinson.edu/~braught/courses/cs132f01/classes/code/Factorial.src.html Introduction to Computing - Dickinson College]
#[http://en.wikipedia.org/wiki/Object-oriented_programming Wikipedia - Object Oriented Programming]
#[http://searchsoa.techtarget.com/sDefinition/0,,sid26_gci212681,00.html More on Object Oriented Programming]
#[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas Understanding Ruby Blocks, Procs and Lambdas - Robert Sosinski]
#[http://www.codingday.com/power-of-functional-programming-its-features-and-its-future/ Power of Functional Programming, its Features and its Future]
#[http://skillsmatter.com/podcast/open-source-dot-net/mike-wagg-mark-needham-functional-and-oo-approaches-to-c-sharp-programming Mixing Functional and Object Oriented Approaches to Programming in C#]
#[http://en.wikipedia.org/wiki/Programming_paradigm Programming Paradigm]
#[http://en.wikipedia.org/wiki/Recursion Recursion]
#[http://www.scala-lang.org/ Scala]
#[http://en.wikipedia.org/wiki/Scala_%28programming_language%29 Scala Wikipedia]
#[http://clojure.org/ Clojure]
#[http://www.ruby-lang.org/en/ Ruby]
#[http://en.wikipedia.org/wiki/Standard_ML Standard ML]
#[http://en.wikipedia.org/wiki/Haskell_%28programming_language%29 Haskell]
#[http://en.wikipedia.org/wiki/ML_%28programming_language%29 ML Family]
#[http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java]
#[http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]
#[http://en.wikipedia.org/wiki/C%2B%2B C++ Programming Language]
#[http://en.wikipedia.org/wiki/Visual_Basic_.NET Visual Basic .Net]
# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]
#O'Reilly (2009), "Programming Scala", ''O'Reilly Media Inc.''.
#Dave Thomas, Chad Fowler, Andy Hunt (2006) ''Programming Ruby'', The Pragmatic Bookshelf.
#[http://lamp.epfl.ch/~phaller/doc/haller10-Translucent_functions.pdf Philipp Halle, Lightweight language support for type-based, concurrent event processing, Lausanne, Switzerland, April 2010.]
#[http://biblion.epfl.ch/EPFL/theses/2007/3899/EPFL_TH3899.pdf Burak Emir, Object-Oriented Pattern Matching, EPFL, October 2007].

= Mixing Functional & O-O code =

This chapter deals with the mixing of functional and object-oriented programming paradigms. We start with listing the different programming paradigms available today. We introduce functional and object-oriented approaches briefly and then discuss the advantages of one over the other. Following this, we discuss some aspects and features of mixing both the approaches. Finally, we talk about few languages that constitute such a mix.

== Programming Paradigms Today==

Several programmatic approaches to solve a particular task lead to distinct programming paradigms like, 
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
* Functional programming 
* Object Oriented programming 
* [http://en.wikipedia.org/wiki/Logic_programming Logical programming], etc. 
Lets focus on functional and object oriented programming approaches.

== Functional Programming ==

[http://en.wikipedia.org/wiki/Functional_programming Functional programming] is the task of decomposing a problem into a number of functions. Selectively executing these functions results in the solution to the problem. The functions mostly behave as mathematical. For given set of inputs the program should always return the same output. It usually concentrates on what type of problem we are dealing with rather than on the details of how to solve the problem. For example lets say there is a function which calculates area of a square. If we use it six times then we end up with area of a cube. Thus functional programming helps to build complex systems.

=== Approach ===

Expressions are the collection of variables and operations resulting in a single value this also deals with the way of solving the problem as expressions. Hence also called Expression related programming. It is structured as expression where each expression can be encapsulated in another yielding the result. Making the change in data structures as the program runs is called [http://en.wikipedia.org/wiki/Side_effect_(computer_science) side effects]. Purely functional language has no side effects. Language like Haskell is a pure functional language . Some languages need many approaches for achieving the desired result. Such languages are multi-paradigm. Examples for such languages are C++, Python,Lisp. Its like evaluating an expression and use the resulting value for something.

Structure of functional programming :

(fn2 ( fn1 ()[input list] ) []) => fn1 takes input list and the output of fn1 is used as input to fn2. Its a schematic representation of
how functional programming works.

Functional programming feature (Python) :

m = map(lambda i : i*i , numbers)
where ''numbers'' is an array of numbers and ''lambda'' is [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 closure].

Python has some functions like map, filter, reduce to support functional programming style. In the example above, the 'map' is a high-order function that takes a function and an array of numbers as input. The ''lambda'' takes i as input and returns i*i as output. Every result returned is appended to a list and produced as output. In functional programming, the programmer is given a natural framework for developing smaller, simpler, and more general modules, which are then glued together.

== Object Oriented Programming ==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] is a programming technique where everything is defined as an object. Objects are well-defined discrete bundles of data(attributes) and the associated functions(behavior). They are devised to resemble real-life objects and are uniquely identifiable by a name. The attributes could be of simple datatype(int, String, Boolean) or objects themselves. The behavior is defined by methods to use and manipulate the attributes. The values of attributes of an object at an instant is the state of the object. OO Programming allows objects to have their state retained throughout the code until manipulated otherwise. Objects are capable of housekeeping their own states, interacting and establishing relationships with other objects, inheriting, etc.

=== Fundamental concepts ===

A [http://en.wikipedia.org/wiki/Class_%28computer_science%29 class] is a user-defined datatype that provides implementation details to define the attributes and their properties. It is an abstract representation of an object(i.e.,) like a mold for objects.
An instance is an executable copy of a class. They are the actual objects created using the ‘class mold’ on run time.
Methods are a set of procedural statements or functions to define the behavior of an object, convey the current state, modify values of the attributes, etc.

Example :

An object in Java might look like this:

public class Person {
private String name;
public Person() {
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}

Here, OO Programming allows the programmer to set the ''name'' attribute of the class ''Person'' and get the name whenever needed in the code. An object of this class Person will remain in memory forever as long as there is a reference to it. As OO Programming allows objects to have their state retained, the value of the ''name'' attribute for a particular ''Person'' object remains the same across any part of the code until it is set differently.

=== Features ===

Three primary characteristics of object oriented programming are Encapsulation, Polymorphism, and Inheritance.
[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation] is the ability of objects to hide visibility of their attributes and behavior, thereby providing service independent of implementation.
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects.
[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance] is one where an existing type can be used to derive a new type. Derived types inherit the data and operations of the super-type. And also, they can overwrite existing operations or add new ones.

There are other important features of O-O programming like [http://en.wikipedia.org/wiki/Message_passing message passing], [http://en.wikipedia.org/wiki/Abstraction abstraction], delegation, etc.

Now, we have seen both the approaches and their features in brief. Lets discuss the advantages of one over the other.

== Advantages ==

=== Functional Approach over OO Approach[[http://www.jot.fm/issues/issue_2009_09/article5.pdf 8]]===
* Functional programming solves the problem with lesser number of lines of code than the OO programming style. 
* There is no side effect as they use immutable data structures also called [http://en.wikipedia.org/wiki/Persistent_data_structure Persistent Data Structure] which will have no change in the state of variables. Hence program dont have to depend on history. 
* There is no limit in the numeric types used as opposed to OO languages which mainly depend on primitive data types. 
* A programmer is given the freedom to think in terms of what to solve in the problem rather than concentrating on how to solve and the flow of the program. 
* Suitable for calculation intensive programs.

=== OO Approach over Functional Approach===
* Everything can be represented in an object and it has the attributes associated with it and hence the state of the object is known at any time. 
* A complex system can be subdivided into modules of objects where as in functional approach, many functions inter operate to form a complex system. 
* [http://en.wikipedia.org/wiki/Reusability Re-usability] (i.e.) OO approach enables programmers to create new objects that inherits many of its features from existing objects. This makes object-oriented programs easier to modify than functional. 
* [http://en.wikipedia.org/wiki/Debug Debugging] in Object Oriented environment is easy compared with functional approach where a small error in one function causes the whole system (i.e. all the functions) to fail. 
* Suitable for making application-oriented software. 

Both the approaches have their advantages and disadvantages. What if we could get the best of both the worlds? The next section deals with the aspects and features of how well both the approaches are mixed together in some languages.

== Mixing Functional & OO Code - Best of both the worlds ==

Languages that are a mix of functional and object oriented approaches(eg. Scala[[http://www.scala-lang.org/node/1305 1]], Clojure[[http://oreilly.com/catalog/9781934356333 10]], etc.) make use of best of both the worlds. They support various aspects of functional and object oriented approaches. They have a bunch of functional approach features[[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf 6]], which object oriented programming languages(like Java) lack which includes closures. Closures are first-class functions with free variables that are bound in the lexical environment. These languages also sport a very malleable syntax that makes them well suited for "domain specific languages" with the benefits of static typing. They are more expressive, extensible and allow reuse of programming abstractions.

Certain languages like Scala, Clojure, etc run on Java Virtual Machine(JVM) ensuring portability to all underlying platforms. They even support immutable objects. In Scala, new language constructs can be added in the form of libraries. They allow safe reuse[[http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf 9]] of programming abstractions and type-safe extension of software.

===Lambda===

A lambda[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] expression is an anonymous function that contain expressions and statements, and can be used to create delegates or expression types. Such kind of anonymous function can be defined and passed around as easily as other data types and can be used to contain functionality that need not be named. Some notable examples include closures[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] and currying. Lambda functions with no name can be called using the variable assigned to it.

g = lambda x: x*2
g(3)=6

We can have lambda function without assigning it to a variable which can be used as inline-function.

(lambda x: x*2)(3)

In [http://en.wikipedia.org/wiki/Clojure Clojure] as a functional language, the creation of a chunk of behavior that can be assigned to a variable (known as a lambda) is trivial. Below are two ways to create a lambda that returns the square of its argument.

(def square1 (fn [n] (* n n)))
(def square2 #(* % %))

===Currying ===

[http://en.wikipedia.org/wiki/Currying Currying] transforms a function that takes multiple parameters into a chain of functions, each taking a single parameter. It reuses a partially applied function where the function is originally defined as accepting n parameters.It can be interpreted as the technique to decompose a function that takes n parameters into n function each of them taking 1 parameter. For example to say in algebraic terms,consider the function f which takes 3 parameters x,y,z and Currying means that we can rewrite the function as a composition of 3 functions:

f(x,y,z) = 4*x+3*y+2*z
f(x)(y)(z) = 2*z+(3*y+(4*x))

In Scala, currying takes advantage of Scala’s syntactic sugar. Below is a currying example in Scala. This function creates a multiplier function which takes two arguments and partially defines it by assigning a constant to one argument and assigning it to a variable .Later the function is called by assigning the second argument.

def multiplier(i: Int)(factor: Int) = i * factor => method named multiplier which takes two parameters is defined
val byFive = multiplier(5) _ => The method is redefined with accepting one parameter and store it in a variable.
val byTen = multiplier(10) _

scala> byFive(2) => Method called by giving the second parameter.
res4: Int = 10

scala> byTen(2)
res5: Int = 20

===Less Verbosity===

In Java each variable should have its type defined beforehand. Whereas in languages like Scala, it is more concise and easier to read than the equivalent Java.

For example, a Map can be created with a simple syntax in Scala,Clojure than in Java:

<table>
<tr>
<td>
'''Java'''
Map<String, Integer> nMap = new HashMap<String, Integer>();
nMap.put("one", 1);
nMap.put("two", 2);
nMap.put("three", 3);
</td>
<td>
'''Scala'''

var nMap = Map("one" -> 1, "two" -> 2, "three" -> 3)

</td>
<td>
'''Clojure'''

(doto (new Java.util.HashMap)(.put “a” 1)(.put “b” 2))

</td>
</tr>
</table>

Here, Scala compiler knows that nMap uses Strings as keys, and Integers as values. Unlike Java, this need not be specified beforehand. Scala could figure it out itself. Moreover, Scala will give an error if a different key-value pair is tried to insert. This is called "type inference". This prevents a whole class of bugs at run time just like Java but with less verbosity.
In a similar way Clojure also involves only few lines of code compared with the object oriented Java language which takes many lines of code.A simple Clojure example and the associated Java code :
Example

(defn blank? [s] (every? #(Character/isWhitespace %) s))

The innermost function Character/isWhiteSpace checks the first argument % for any whitespace and returns true if it is. every? invoke the above inner function for all elements in the collection s.It has no variables, no branches etc.

Java code
isBlank() method checks to see whether a string is blank or contains only whitespace.

public class Stringcheck{
public static boolean isBlank(String str){
int len;
if(str==null || (strlen =str.length())==0)
return true;
for(int i=0; i<strlen;i++) {
if((Character.isWhitespace(str.charAt(i))==false)){
return false;
}
}
return true;
}
}

=== Pattern Matching ===

To say simply, a [http://en.wikipedia.org/wiki/Pattern_matching Pattern matching] is a technique to search string for the occurrence of any patterns or regularity. Pattern matching is an elegant way to decompose objects into their constituent parts for processing.Many languages support the concept of pattern matching. Perl supports pattern matching using the pattern definition mini language called regular expressions, also called regexes or REs, which is borrowed from the regular expressions used in many Unix tools, such as grep() and sed().The risk that the parts of an object might be changed outside of the control of the enclosing object is avoided. For example, if there is a Person class that contains a list of addresses, it will not be an issue to expose that list to clients if the list is immutable. The users will not be able to change the list unexpectedly.Given below is a simple example for pattern matching used in Perl:

$mystring = "Hello world!"; // Perls way of assigning string to a variable.
if($mystring =~ m/World/) { print "Yes"; } // Checks the string stored in variable mystring has the string "World".
$mystring =~ s/world/mom/; // Replaces the string "world" stored in mystring to mom.

Another sample of regular expression in java :

String mystring="Hello World" ;
Pattern str = Pattern.compile("\\w+"); => Pattern stored for matching.
Matcher fit = str.matcher(mystring); => Matcher class which perform matching of the string with the pattern defined.
if(fit.matches())

As languages like Scala and Clojure support procedural code, pattern matching is done as equal or with less difficulty compared with Java which needs to use regex. Scala can even be embedded into XML as its syntax is somewhat similar.Given below an overview of how regular expression is achieved in Clojure.
Data are manipulated in Clojure through the sequence called seq which is a logical list. Clojure can access java collections, its collections, Regular expression matches via the seq also called seq-able. Clojure's regular expression uses java.util.regex library at the lowest level. For achieving that the keyword re-seq is used.
Syntax:
(re-seq regexp string)
Example
(re-seq #"\w+" "Hello World") => ("Hello" "World") => #"\w+" represents the java.util.regex.Pattern

=== Java Interoperability ===
Considering Clojure, it gives clean, simple and direct access to java and can access Java API directly.Clojure doesnot wrap Java's string functions. We can call using Java interop forms. It provides syntax for accessing Java elements like classes, instances, constructors, methods and fields and can also wrap Java API. The “.” dot special form is used for accessing Java. Some Clojure syntax which can access Java API: 

{| class="wikitable" border="2"
|-
! Java
! Clojure
|-
| new Widget(“red”)
| (new Widget “red”)
|-
| Math.PI
| (.Math PI) or Math/PI
|-
| System.currentTimeMillis()
| (.System currentTimeMillis) or System/currentTimeMillis
|-
| rnd.nextInt()
| (.rnd nextInt) or (.nextInt rnd)
|-
|}

Clojure pass functions as arguments to other functions. But Java does not support this. So Clojure provides a member function memfn macro to wrap methods or can use anonymous function to wrap a method call.
(map (memfn toUpperCase) [“a” ,”short”,”message”])
or
(map #(.toUpperCase %)[“a”,”short”,”message”]) => #(body) represents the anonymous function in Clojure.

For example,
(def the-digits
(map #(Integer. (str %))(filter #(Character/isDigit %) (seq big-num-str))))

where (def big-num-str (str "123785334434se9088af8309304293872adbcdfd”))

The above code extracts the integers from string and discards the non-numeric characters. Lets look at the functions defined in the example. There are totally five functions defined.They are
(seq big-num-str) => get each character defined in big-num-str
(Character/isDigit %) => Checks whether the input is an integer
(filter #()) => Filter each string from str
(map #(Integer. (str %))) => Change the string to integer
(def the-digits) => Output the integers only in a string of characters.
Here,
#(Character/isDigit) represents the Java method Character.isDigit() and #(Integer.(str %)) represents the new java.lang.Integer(str(%))

Most of the Clojure library functions have defined semantics for objects of Java types. contains? and .get work on Java’s Maps, arrays, Strings, count works on Java Strings, Collections and arrays. Clojure is built around these aspects. It avails the performance of JVM and the richness of both the core APIs and the numerous third-party libraries written in the Java language and restrained from reinventing them.

=== Multiple Inheritance ===

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance][http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf 2] is the concept of using the methods and variables of more than one superclass to a sub class.Java was designed without multiple inheritance. But Java supports the solution of problems commonly solved with multiple inheritance in other ways with help of interfaces where the methods defined in it are not implemented.In Scala, classes are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance in Java.Lets see how multiple inheritance achieved in Scala:

As interfaces in Java, Scala allows traits but has some methods partially implemented. The only difference to classes is the traits may not have constructor parameters.

trait Similarity {
def isSimilar(x: Any): Boolean // not implemented
def isNotSimilar(x: Any): Boolean = !isSimilar(x) //implemented method
}

This trait defines two methods isSimilar and isNotSimilar where isSimilar does not provide a concrete method implementation (it is abstract in the terminology of Java), and the method isNotSimilar defines a concrete implementation. Consequently, classes that integrate this trait only have to provide a concrete implementation for isSimilar.

class Point(xc: Int, yc: Int) extends Similarity {
var x: Int = xc
var y: Int = yc
def isSimilar(obj: Any) = //need to implement the method here
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
}

object TraitsTest extends Application {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotSimilar(p2))
println(p1.isNotSimilar(p3)) //uses the already defined method
println(p1.isNotSimilar(2))
}

These are some of the aspects and traits of mixing functional and object-oriented approaches. As we discussed in the advantages section, both the approaches have their benefits and limitations. Mixing them aspect-wise enables the above features in such languages. Lets discuss those languages briefly in the next section.

== Languages Supporting Functional and OO code ==

OCaml and F#[[http://msdn.microsoft.com/en-us/library/dd233154.aspx 7]] are some of the languages which support both functional and object oriented programming. OCaml is as fast as C and its featured as [http://www.haskell.org/ Haskell] which is a pure functional language. F#[[http://oreilly.com/catalog/9780596153656 3]] is a dynamically typed language which can run on .NET framework and has supported immutable types i.e. tuples, records, discriminated unions and lists to work in Functional programming. It has functions that can either be in curried or in uncurried form. As in functional language it can pass functions as arguments to other functions, resulting in higher order functions. It also supports lambda functions and closures. F#,behaves like other .NET languages as both in imperative and object oriented style. 

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language and it is a dialect of Lisp. It is not a pure functional language and it is a dynamically typed language. Just like Java it runs on JVM platform. But its syntax differs from Java. It is represented as :

(functions arguments...)

The function followed by its arguments is enclosed in paranthesis. It has features like immutable data structures, high-order functions and recursion, easy and fast java interoperability. 

Python and Ruby are also the programming languages which offer the mix of functional and OO languages. But these languages doesn't support the algebraic data types and pattern matching.

==Conclusion ==
The above aspects of functional and object oriented programming techniques discuss some if their merits and demerits. Mixing them produces a new programming paradigm which leads to a new dimension in programming. A few fundamental concepts are explored in Clojure and Scala here. The ability of Clojure and Scala to run in JVM platform makes them more preferable than others in the market. Some of the merits like closure, less verbosity, high order functions, currying along with interoperation with previously written libraries in these languages make them more efficient and useful. There are also other languages which support functional and object oriented techniques. Mixing the approaches, evolve a new dimension in programming which is practical and opens doors to more exploration.

== References ==

# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-11T01:45:50Z

Dmcarmon:

= Introduction =

= Functional Programming =

Functional programming treats computation as the evaluation of mathematical functions. It is compute-centric rather than data-centric. Functional programming keeps no global state, does not use for or while loops, and data is immutable****. Instead, everything is done using functions, usually functions that evaluate mathematical expressions. Each of these functions maintain no internal state and will always produce the same output given the same input.

Let's look at an example. Suppose we have a list of numbers and we want to multiply each number in the list by 2. The first approach is the imperitive style:

array[] = {1,2,3,4,5}
for(i=0 ; i<array.length; i++){
array[i] = array[i] * 2;
}

In the above example, array[] is a global variable. If we fail to check the array length, then a runtime exception occurs which might result in the program being crashed. As far as functional style, there is a function called map(func,seq)(in python language) where the function 'func' is applied to each member of seq. The following code is written in a functional style.

numbers = [1,2,3,4,5]
/* define a method called compute on each number in the list */
def compute(var):
var = var * 2
return var
/* Now call the map function */
L = map(compute,numbers)
print L // L will print [1,4,6,8,10]

Notice that there is no global data nor any nested loops and the bound checking is handled internally within the map function. The programmer is relieved of of runtime errors and thus can debug the program easily.

Some advantages of this approach are:
* Easier debugging: Since every thing is broken down into small simple functions, the functions are often easy to debug.
* More compact code: Functional programming typically requires fewer lines of code. Since compution is done by function code reuse is prevelent.
* Nothing depends on state: Because functional programs keep no state information, the functions will always operate the same regardless of the past history of the program.

= Object-oriented Programming =
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] (OOP) is a programming paradigm organized around interacting "objects"(usually instances of a class) rather than "actions" and data rather than logic. A basic principle of OOP is that a program consists of a list of subroutines which can perform individually.

An object-oriented programming language provides support for the following object-oriented concepts--object, class, interface and inheritance. To illustrate this idea clearly and vividly let's review the following example-- your limbs. The "Limbs" is a class. Your body has two objects of type "limbs", named arms and legs. Their main functions are controlled/ managed by a set of biological signals sent from central nervous system( through an interface). So the nervous system is an interface which your body uses to interact with your limbs. The "limbs" is a well architected class. The "legs" has a subclass which contains "left leg" and "Right leg". The "legs" is being re-used to create the left leg and right leg by slightly changing the properties of it. If the "legs" owns attributes like length, color of skin etc, then the subclass, which contains "left leg" and "right leg" in this case, automatically inherit these attributes( that is called inheritance).

We could code in object-oriented paradigm as:

class Limbs /*define a class of limbs*/
def initialize(limbs,length,colorofskin)
@limbs=limbs
@length=length
@colorofskin=colorofskin
end
end
limbs=Limbs.new("legs","100cm","white") /*create a new object in class "Limbs"*/
class Legs<Limbs /*create a subclass "Legs",which belong to class"Limbs"*/
def initialize(legs,length,colorofskin)
super(length,colorofskin)
@legs=legs
end
end
legs=legs.new("left leg") /*create a new object in class of "Legs"*/

== Features of Object-oriented Programming ==
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]. A programmer can simply create a new object that inherits many of its features from super-class. And also, they can overwrite existing operations or add new ones.This makes object-oriented programs easier to modify.
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation].This refers to hiding the internal representation of the object from the outside view. You can hide unnecessary implementation details from the object user. One of the benefits of encapsulation is data protection.
* [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism].This allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects. Consider the operator '+', for numbers it will generate the sum, but for strings it will produce a third string which concatenates the input strings.

== Advantages of Object-oriented Programming ==
* Simplicity: we use software objects to simulate real world objects, so the complexity is reduced and the program structure is very clear.
* Modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system.
* Modifiability: programmers can easily make minor changes in the data representation or operations in an OOP. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods.
* Extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones.
* Maintainability: objects can be maintained separately, making locating and fixing problems easier.
* Re-usability: objects can be reused in different programs.

= Mixing Functional and Object-Oriented Programming =

Motivation for Mixing

== Functional Techniques useful for Object-Oriented Programming ==
In object-oriented world, data and operations are grouped together into modular units called objects and we combine objects into structured networks to form a program. The results are depend on arguments and objects' state at method invocation time. While in functional world, the basic elements are variables in the mathematical sense and functions in the mathematical sense. Functional programming can reduce side-effects. If there is no side-effects, it means your can apply the function at anywhere freely. No matter how you apply this function, the same input arguments produce the same results.

According to above-mentioned information, we can perform functional programming on an object-oriented programming language because:
1). object can have constant state
2). method can depend only on its arguments and context available at method definition time

Combining both these paradigms not only provide us a robust design structure, but also enable the programmers to develop solutions to complex problems quickly and effectively. One of the cornerstone of mixing functional and object-oriented code is treating functions as objects.It means that we can pass functions as arguments, store it and return them from other functions. This is highly useful in an user interface code where it can be used as call back functions which gets called when an event occurs(event driven programming).

Some of the basic features of Functional Programming which can be combined with Object Oriented paradigm are:

* Lambda Calculus
* Currying
* Powerful pattern matching

Let us now understand how each of the above feature of Functional language fits in the Object Oriented paradigm.

=== Lambda Calculus ===
Lambda calculus is the most critical basis of functional programming. A lambda expression is an anonymous expression that contain expressions and statements.Each expression stands for a function with one parameter.

Let consider the following function:

def f(x)
return x**2
print f(4)

We can use a lambda calculus to compute this expression without assigning it to a variable:

(lambda x:x**x)(4)

We can see that these two code snippets have the same results. It is more concise and flexible to define with lambda.
The above is a pure functional approach. In order to make code more state-less and concise, lambdas can be embedded inside the object-oriented language. The below code in Python demonstrates the use of lambda in a closure:

def fun(x):
return x%3==0
str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
filter(fun,str)

The above code works to find numbers which are divisible by 3.
We can simplify the code by the use of lambda as following:

str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print filter(lambda x: x%3==0, str)

=== Currying ===

=== Pattern Matching ===

== Examples of Mixing ==

A number of programming languages support mixing of both functional and object-oriented code. Three of these (Scala, Ruby, and Conjure), are described in more detail below.

=== Scala ===

[http://www.scala-lang.org/ Scala] is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. [http://www.scala-lang.org/ Scala] was conceived in 2001 and implemented by Martin Odersky. It supports mixing functional and object-oriented code.

==== Mixing Functional and Object-Oriented Code in Scala ====
[http://www.scala-lang.org/ Scala] is a strange specimen. It is a complete blend of object-oriented and functional programming. How can this happen? The functional world advocates immutability, but the object-oriented world focuses on the state and how to change it to fit your needs. [http://www.scala-lang.org/ Scala] allows you create both mutable and immutable objects. Consider the following example,
val str: String = "Hello World"
In the first line, an immutable version(a misnomer indeed) of <code>str</code> is being created . A rough translation into Java is below:

final String str = "Hello World"; //note the extra semi-colon
Consider the next example below,
val list: List[String] = List("Scala", "is", "the coolest", "language", "in the world!")

The same code can be written in Java as:

List<String> mutableList = new ArrayList<String>();
list.add("Scala");
list.add("is");
list.add("the coolest");
list.add("language");
list.add("in the world!");
List<String> immutableList = Collections.immutableList(mutableList);

Compared to Java, [http://www.scala-lang.org/ Scala] reduces the total number of lines you need to type and at the same time looks much simpler and less verbose. Even though the above example shows an immutable collection, scala also provides mutable collections and object types in the package <code>scala.collection.mutable.*</code>

As can be observed, even though [http://www.scala-lang.org/ Scala] advocates immutability, it does not restrict you from creating mutable objects. So it's the best of both worlds. Another part of the functional world is the concept of functions as ''''first class members'''' of the language. Some of the common languages like Ruby, Python and JavaScript all incorporate this feature. In the sense you can pass around functions to methods as a parameter. Enough talking;

Let us have a class say <code>'Person'</code> which has properties, <code>name</code> and another variable <code>age</code>.
In Java:

class Person{
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String s){
this.name = s;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}

In [http://www.scala-lang.org/ Scala]:
case class Person(name: String, age: Int)

This single line is equivalent to the above java code! Getters for <code>name</code> and <code>age</code>, <code>equals()</code>, and <code>hashCode()</code> method are automatically generated for you by the compiler. Isn't this an awesome feature?

Now assume we have a list of persons and we want to filter out all the persons who are of age 23. How would you do that in Java?

List<Person> persons; //has a bunch of person objects in it.
List<Person> twentyThree = new ArrayList<Person>();
for(Person p: persons){
if(p.getAge() == 23){
twentyThree.add(p);
}
}

In [http://www.scala-lang.org/ Scala]:

val twentyThree: List[Person] = persons.filter( _.age == 23)

That's it! In case you are wondering whats going on, filter is a method present on scala.List class and the code block <code>_.age == 23</code> is a function created on the fly and passed onto the filter method. More precisely its called a [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] - a functional concept which can be emulated in java only using anonymous inner classes. Scala's compiler transforms our one line function into some anonymous inner classes when generating java byte code, allowing developers to define functions in a simple manner.

In fact, every function is an object in [http://www.scala-lang.org/ Scala]. Scala's standard library has a number of functions which are objects themselves.

==== Implicits in Scala ====
In almost all programming languages, there is a necessity to profile the running time of the procedures and tune its performance. The old way of doing things in Java would be:

public class Main{
public static int factorial(int x){
if(x == 0 || x == 1) return 1
else return x * factorial(x-1)
}
public static void main(String [] args){
long beforeTime = System.currentTimeMillis();
int result = factorial(5);
System.out.println("Total time taken to execute factorial(5) is " + (System.currentTimeMillis() - result)+"ms");
System.out.println("factorial(5) = " + result);
}
}

However, if you want to find out the execution time of some other method, you would have to type in all the above lines again. So much for code re-use or [http://en.wikipedia.org/wiki/DRY DRY (dont't repeat yourself)]! Lets see how its done in [http://www.scala-lang.org/ Scala].

object Main{
def main(args: Array[String]){
def factorial(x: Int):Int = x match{
case 0 | 1 => 1
case _ => x * factorial(x-1)
}
import System.currentTimeMillis
def timeIt(msg: String = "Time to execute is: ")(func: => Unit){
val before = currentTimeMillis
func
println(msg + (currentTimeMillis - before) + "ms")
}
timeIt("Total time taken to execute factorial(5) is "){
val result = factorial(5)
println("factorial(5) = " + result)
}
}
//would print: factorial(5) = 120
// Total time taken to execute factorial(5) is 1ms

That's not right! The function <code>timeIt</code> looks like a feature built into the language. Try saving the above code into a separate file and run it - It will still work. Using this feature, it is possible to build powerful DSL languages which can run at full speed on JVM.

Ruby allows you to add new methods to objects. This feature is often called as [http://en.wikipedia.org/wiki/Monkey_patch Monkey Patching] because you are splitting open the class and adding/overriding methods (in)|(to) the class. Because other libraries may depend on some methods which you changed, often this leads to unexpected behavior at runtime. However, Scala provides yet another feature called [http://en.wikipedia.org/wiki/Implicit_function implicits] which helps you do this better.

In Java, <code>String</code> class is <code>final</code> so there is no way you can add new methods to it. But with implicits you can do more! Suppose you have some text in memory and you know it represents a number. But in Java the usual way to convert string to int is to do a <code>Integer.parseInt(string)</code> which seems so unnecessary. Let us make our lives easier...

implicit def strToInt(str: String) = new {
def asInt = Integer.parseInt(str)
}
val str = "1234"
println(str.asInt * 3) //prints out 3702

The above code gives us an impression as if String class has gained new <code>asInt</code> method. Can static object oriented languages do this? No! Infact scala cheats by calling our implicits to convert it into a different object as and when needed.

The above functionalities are purely object oriented, yet they are safe. They don't pollute the global namespace, unlike Ruby or Python.

=== Ruby ===

Ruby is another language that, like Scala, supports mixing functional and object-oriented code. It is a dynamically typed Object-Oriented Language which supports multiple programming paradigms, including functional, object-oriented, imperative and reflective. In Ruby, everything is an object, every bit of information and code can have its own properties and actions. However, Ruby’s blocks can be functional. A Ruby programmer can attach a closure to any method, which generates a functional block inside an object oriented code. A closure is a piece of code that can access the lexical environment of its definition [http://www.ruby-lang.org/en/ 11].

==== Ruby Mixing Example ====

Consider the following code snippet in Ruby which uses Object Oriented concepts like Classes and functional programming concepts like lambda.

class Multiply
def initialize(n)
@block = lambda {|a| n * a}
end
def mul(a)
@block.call a
end
end
twoMultiplier = Multiply.new 2
puts twoMultiplier.mul(6)

Here,'''''@block''''' is a closure. When we call the class ''Multiply'' using '''''twoAdder = Multiply.new 2''''' ,the ''initialize'' method is called by passing the parameter 2. Here n=2 binds itself to the block. So @block will be 2*a, that is,the closure remembers the parameter with which the initialize method was called even after the initialize method exits.

This value is used when the block is called in the add method.
Thus,'''''twoMultiplier.mul(6)''''' will return 2*6 = 12

==== Functional Style Coding in Ruby Blocks ====

Blocks are basically nameless functions which can be passed to a function and then that function can invoke the passed in nameless function. This is a common style called [http://en.wikipedia.org/wiki/Higher-order_function higher order functions] among languages that handle functions as first class objects. Basically blocks can be designed for loop abstraction and lets the user to design their own way of iterating the values, thereby hiding the implementation details.
For example, if we want to iterate backwards from the end to the beginning without revealing its internal implementations, we could implement the loop logic inside the block and pass it to a method or function.

Here is a [http://www.ruby-lang.org/en/ Ruby] implementation of block:

def printlist(array,&reverse)
array.each do |element|
puts "array element: #{element}"
end
reverse.call(array) /* Here it prints the reverse implementation of list*/
end

printlist([1,2,3,4,5,6]) { |array|
array.reverse.each do |element|
puts "array element: #{element}"
end
}
The statements between { } is a block and it gets called by <code>reverse.call(array)</code>within the printlist method.

=== Clojure ===

Clojure[[http://oreilly.com/catalog/9781934356333 31]] is also a functional programming language, and it is a dialect of Lisp. It is not a pure functional language. Instead, it is a dynamically typed language. Just like Java it runs on JVM platform, but its syntax differs from Java. It is represented as :

(functions arguments...)

The function and its arguments are enclosed in paranthesis. It has features like immutable data structures, high-order functions, recursion, and easy and fast java interoperability.

In Clojure's model, value calculation is purely functional. Values never change. New values are functions of old. But, logical identity is well supported via atomic references to values. The value of a reference (state of an identity) is always observable without coordination and freely shareable between threads.
When programs are constructed this way, functional value calculation is independent of identity-value association. This makes clojure easier to understand and test.

====Example Using Functional Technique in Clojure====

Consider the following functional programming example in Clojure-
(defn make-adder [x]
(let [y x]
(fn [z] (+ y z))))
(def add2 (make-adder 2))
(add2 4)

Here,'''''defn make-adder [x]''''' defines a function called ''make-adder''.'''''let [y x]''''' gives a local name y for the value x. Since the scope of any local names is lexical, a function created in the scope of local names will close over their values.'''''fn [z] (+ y z)''''' does the addition of y and z.
''
'''def add2 (make-adder 2)''''' calls the function ''make-adder'' passing the parameter 2 and calls this as ''add2''.Now, ''add2'' has computed 2+z. When '''''add2 4''''' is called it computes 2+4=6

====Example Using Object-Oriented Technique in Clojure====

The following program implements Run-Time Polymorphism which is an object-oriented programming concept.
(defmulti encounter (fn [x y] [(:Species x) (:Species y)]))
(defmethod encounter [:Bunny :Lion] [b l] :run-away)
(defmethod encounter [:Lion :Bunny] [l b] :eat)
(defmethod encounter [:Lion :Lion] [l1 l2] :fight)
(defmethod encounter [:Bunny :Bunny] [b1 b2] :mate)
(def b1 {:Species :Bunny :other :stuff})
(def b2 {:Species :Bunny :other :stuff})
(def l1 {:Species :Lion :other :stuff})
(def l2 {:Species :Lion :other :stuff})

(encounter b1 l1)
-> :run-away
(encounter l1 l2)
-> :fight

Here,'''''defmulti''''' is used to define multiple methods which have the same method name '''''encounter'''''.Depending on the parameters passed to the encounter method, one of the four methods is called.
'''''def''''' defines each of the different species.
When, '''''(encounter b1 l1)''''' is called, the first ''encounter'' method is called with the parameters ''Bunny'' and ''Lion''. As a result, ''run-away'' is printed.

= Conclusion =

= References =
#[http://en.wikipedia.org/wiki/Functional_programming Wikipedia - Functional Programming]
#[http://www.cs.cornell.edu/riccardo/prog-smlnj/notes-011001.pdf Notes on programming Standard ML of New Jersey]
#[http://users.dickinson.edu/~braught/courses/cs132f01/classes/code/Factorial.src.html Introduction to Computing - Dickinson College]
#[http://en.wikipedia.org/wiki/Object-oriented_programming Wikipedia - Object Oriented Programming]
#[http://searchsoa.techtarget.com/sDefinition/0,,sid26_gci212681,00.html More on Object Oriented Programming]
#[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas Understanding Ruby Blocks, Procs and Lambdas - Robert Sosinski]
#[http://www.codingday.com/power-of-functional-programming-its-features-and-its-future/ Power of Functional Programming, its Features and its Future]
#[http://skillsmatter.com/podcast/open-source-dot-net/mike-wagg-mark-needham-functional-and-oo-approaches-to-c-sharp-programming Mixing Functional and Object Oriented Approaches to Programming in C#]
#[http://en.wikipedia.org/wiki/Programming_paradigm Programming Paradigm]
#[http://en.wikipedia.org/wiki/Recursion Recursion]
#[http://www.scala-lang.org/ Scala]
#[http://en.wikipedia.org/wiki/Scala_%28programming_language%29 Scala Wikipedia]
#[http://clojure.org/ Clojure]
#[http://www.ruby-lang.org/en/ Ruby]
#[http://en.wikipedia.org/wiki/Standard_ML Standard ML]
#[http://en.wikipedia.org/wiki/Haskell_%28programming_language%29 Haskell]
#[http://en.wikipedia.org/wiki/ML_%28programming_language%29 ML Family]
#[http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java]
#[http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]
#[http://en.wikipedia.org/wiki/C%2B%2B C++ Programming Language]
#[http://en.wikipedia.org/wiki/Visual_Basic_.NET Visual Basic .Net]
# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]

= Mixing Functional & O-O code =

This chapter deals with the mixing of functional and object-oriented programming paradigms. We start with listing the different programming paradigms available today. We introduce functional and object-oriented approaches briefly and then discuss the advantages of one over the other. Following this, we discuss some aspects and features of mixing both the approaches. Finally, we talk about few languages that constitute such a mix.

== Programming Paradigms Today==

Several programmatic approaches to solve a particular task lead to distinct programming paradigms like, 
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
* Functional programming 
* Object Oriented programming 
* [http://en.wikipedia.org/wiki/Logic_programming Logical programming], etc. 
Lets focus on functional and object oriented programming approaches.

== Functional Programming ==

[http://en.wikipedia.org/wiki/Functional_programming Functional programming] is the task of decomposing a problem into a number of functions. Selectively executing these functions results in the solution to the problem. The functions mostly behave as mathematical. For given set of inputs the program should always return the same output. It usually concentrates on what type of problem we are dealing with rather than on the details of how to solve the problem. For example lets say there is a function which calculates area of a square. If we use it six times then we end up with area of a cube. Thus functional programming helps to build complex systems.

=== Approach ===

Expressions are the collection of variables and operations resulting in a single value this also deals with the way of solving the problem as expressions. Hence also called Expression related programming. It is structured as expression where each expression can be encapsulated in another yielding the result. Making the change in data structures as the program runs is called [http://en.wikipedia.org/wiki/Side_effect_(computer_science) side effects]. Purely functional language has no side effects. Language like Haskell is a pure functional language . Some languages need many approaches for achieving the desired result. Such languages are multi-paradigm. Examples for such languages are C++, Python,Lisp. Its like evaluating an expression and use the resulting value for something.

Structure of functional programming :

(fn2 ( fn1 ()[input list] ) []) => fn1 takes input list and the output of fn1 is used as input to fn2. Its a schematic representation of
how functional programming works.

Functional programming feature (Python) :

m = map(lambda i : i*i , numbers)
where ''numbers'' is an array of numbers and ''lambda'' is [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 closure].

Python has some functions like map, filter, reduce to support functional programming style. In the example above, the 'map' is a high-order function that takes a function and an array of numbers as input. The ''lambda'' takes i as input and returns i*i as output. Every result returned is appended to a list and produced as output. In functional programming, the programmer is given a natural framework for developing smaller, simpler, and more general modules, which are then glued together.

== Object Oriented Programming ==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] is a programming technique where everything is defined as an object. Objects are well-defined discrete bundles of data(attributes) and the associated functions(behavior). They are devised to resemble real-life objects and are uniquely identifiable by a name. The attributes could be of simple datatype(int, String, Boolean) or objects themselves. The behavior is defined by methods to use and manipulate the attributes. The values of attributes of an object at an instant is the state of the object. OO Programming allows objects to have their state retained throughout the code until manipulated otherwise. Objects are capable of housekeeping their own states, interacting and establishing relationships with other objects, inheriting, etc.

=== Fundamental concepts ===

A [http://en.wikipedia.org/wiki/Class_%28computer_science%29 class] is a user-defined datatype that provides implementation details to define the attributes and their properties. It is an abstract representation of an object(i.e.,) like a mold for objects.
An instance is an executable copy of a class. They are the actual objects created using the ‘class mold’ on run time.
Methods are a set of procedural statements or functions to define the behavior of an object, convey the current state, modify values of the attributes, etc.

Example :

An object in Java might look like this:

public class Person {
private String name;
public Person() {
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}

Here, OO Programming allows the programmer to set the ''name'' attribute of the class ''Person'' and get the name whenever needed in the code. An object of this class Person will remain in memory forever as long as there is a reference to it. As OO Programming allows objects to have their state retained, the value of the ''name'' attribute for a particular ''Person'' object remains the same across any part of the code until it is set differently.

=== Features ===

Three primary characteristics of object oriented programming are Encapsulation, Polymorphism, and Inheritance.
[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation] is the ability of objects to hide visibility of their attributes and behavior, thereby providing service independent of implementation.
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects.
[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance] is one where an existing type can be used to derive a new type. Derived types inherit the data and operations of the super-type. And also, they can overwrite existing operations or add new ones.

There are other important features of O-O programming like [http://en.wikipedia.org/wiki/Message_passing message passing], [http://en.wikipedia.org/wiki/Abstraction abstraction], delegation, etc.

Now, we have seen both the approaches and their features in brief. Lets discuss the advantages of one over the other.

== Advantages ==

=== Functional Approach over OO Approach[[http://www.jot.fm/issues/issue_2009_09/article5.pdf 8]]===
* Functional programming solves the problem with lesser number of lines of code than the OO programming style. 
* There is no side effect as they use immutable data structures also called [http://en.wikipedia.org/wiki/Persistent_data_structure Persistent Data Structure] which will have no change in the state of variables. Hence program dont have to depend on history. 
* There is no limit in the numeric types used as opposed to OO languages which mainly depend on primitive data types. 
* A programmer is given the freedom to think in terms of what to solve in the problem rather than concentrating on how to solve and the flow of the program. 
* Suitable for calculation intensive programs.

=== OO Approach over Functional Approach===
* Everything can be represented in an object and it has the attributes associated with it and hence the state of the object is known at any time. 
* A complex system can be subdivided into modules of objects where as in functional approach, many functions inter operate to form a complex system. 
* [http://en.wikipedia.org/wiki/Reusability Re-usability] (i.e.) OO approach enables programmers to create new objects that inherits many of its features from existing objects. This makes object-oriented programs easier to modify than functional. 
* [http://en.wikipedia.org/wiki/Debug Debugging] in Object Oriented environment is easy compared with functional approach where a small error in one function causes the whole system (i.e. all the functions) to fail. 
* Suitable for making application-oriented software. 

Both the approaches have their advantages and disadvantages. What if we could get the best of both the worlds? The next section deals with the aspects and features of how well both the approaches are mixed together in some languages.

== Mixing Functional & OO Code - Best of both the worlds ==

Languages that are a mix of functional and object oriented approaches(eg. Scala[[http://www.scala-lang.org/node/1305 1]], Clojure[[http://oreilly.com/catalog/9781934356333 10]], etc.) make use of best of both the worlds. They support various aspects of functional and object oriented approaches. They have a bunch of functional approach features[[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf 6]], which object oriented programming languages(like Java) lack which includes closures. Closures are first-class functions with free variables that are bound in the lexical environment. These languages also sport a very malleable syntax that makes them well suited for "domain specific languages" with the benefits of static typing. They are more expressive, extensible and allow reuse of programming abstractions.

Certain languages like Scala, Clojure, etc run on Java Virtual Machine(JVM) ensuring portability to all underlying platforms. They even support immutable objects. In Scala, new language constructs can be added in the form of libraries. They allow safe reuse[[http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf 9]] of programming abstractions and type-safe extension of software.

===Lambda===

A lambda[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] expression is an anonymous function that contain expressions and statements, and can be used to create delegates or expression types. Such kind of anonymous function can be defined and passed around as easily as other data types and can be used to contain functionality that need not be named. Some notable examples include closures[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] and currying. Lambda functions with no name can be called using the variable assigned to it.

g = lambda x: x*2
g(3)=6

We can have lambda function without assigning it to a variable which can be used as inline-function.

(lambda x: x*2)(3)

In [http://en.wikipedia.org/wiki/Clojure Clojure] as a functional language, the creation of a chunk of behavior that can be assigned to a variable (known as a lambda) is trivial. Below are two ways to create a lambda that returns the square of its argument.

(def square1 (fn [n] (* n n)))
(def square2 #(* % %))

===Currying ===

[http://en.wikipedia.org/wiki/Currying Currying] transforms a function that takes multiple parameters into a chain of functions, each taking a single parameter. It reuses a partially applied function where the function is originally defined as accepting n parameters.It can be interpreted as the technique to decompose a function that takes n parameters into n function each of them taking 1 parameter. For example to say in algebraic terms,consider the function f which takes 3 parameters x,y,z and Currying means that we can rewrite the function as a composition of 3 functions:

f(x,y,z) = 4*x+3*y+2*z
f(x)(y)(z) = 2*z+(3*y+(4*x))

In Scala, currying takes advantage of Scala’s syntactic sugar. Below is a currying example in Scala. This function creates a multiplier function which takes two arguments and partially defines it by assigning a constant to one argument and assigning it to a variable .Later the function is called by assigning the second argument.

def multiplier(i: Int)(factor: Int) = i * factor => method named multiplier which takes two parameters is defined
val byFive = multiplier(5) _ => The method is redefined with accepting one parameter and store it in a variable.
val byTen = multiplier(10) _

scala> byFive(2) => Method called by giving the second parameter.
res4: Int = 10

scala> byTen(2)
res5: Int = 20

===Less Verbosity===

In Java each variable should have its type defined beforehand. Whereas in languages like Scala, it is more concise and easier to read than the equivalent Java.

For example, a Map can be created with a simple syntax in Scala,Clojure than in Java:

<table>
<tr>
<td>
'''Java'''
Map<String, Integer> nMap = new HashMap<String, Integer>();
nMap.put("one", 1);
nMap.put("two", 2);
nMap.put("three", 3);
</td>
<td>
'''Scala'''

var nMap = Map("one" -> 1, "two" -> 2, "three" -> 3)

</td>
<td>
'''Clojure'''

(doto (new Java.util.HashMap)(.put “a” 1)(.put “b” 2))

</td>
</tr>
</table>

Here, Scala compiler knows that nMap uses Strings as keys, and Integers as values. Unlike Java, this need not be specified beforehand. Scala could figure it out itself. Moreover, Scala will give an error if a different key-value pair is tried to insert. This is called "type inference". This prevents a whole class of bugs at run time just like Java but with less verbosity.
In a similar way Clojure also involves only few lines of code compared with the object oriented Java language which takes many lines of code.A simple Clojure example and the associated Java code :
Example

(defn blank? [s] (every? #(Character/isWhitespace %) s))

The innermost function Character/isWhiteSpace checks the first argument % for any whitespace and returns true if it is. every? invoke the above inner function for all elements in the collection s.It has no variables, no branches etc.

Java code
isBlank() method checks to see whether a string is blank or contains only whitespace.

public class Stringcheck{
public static boolean isBlank(String str){
int len;
if(str==null || (strlen =str.length())==0)
return true;
for(int i=0; i<strlen;i++) {
if((Character.isWhitespace(str.charAt(i))==false)){
return false;
}
}
return true;
}
}

=== Pattern Matching ===

To say simply, a [http://en.wikipedia.org/wiki/Pattern_matching Pattern matching] is a technique to search string for the occurrence of any patterns or regularity. Pattern matching is an elegant way to decompose objects into their constituent parts for processing.Many languages support the concept of pattern matching. Perl supports pattern matching using the pattern definition mini language called regular expressions, also called regexes or REs, which is borrowed from the regular expressions used in many Unix tools, such as grep() and sed().The risk that the parts of an object might be changed outside of the control of the enclosing object is avoided. For example, if there is a Person class that contains a list of addresses, it will not be an issue to expose that list to clients if the list is immutable. The users will not be able to change the list unexpectedly.Given below is a simple example for pattern matching used in Perl:

$mystring = "Hello world!"; // Perls way of assigning string to a variable.
if($mystring =~ m/World/) { print "Yes"; } // Checks the string stored in variable mystring has the string "World".
$mystring =~ s/world/mom/; // Replaces the string "world" stored in mystring to mom.

Another sample of regular expression in java :

String mystring="Hello World" ;
Pattern str = Pattern.compile("\\w+"); => Pattern stored for matching.
Matcher fit = str.matcher(mystring); => Matcher class which perform matching of the string with the pattern defined.
if(fit.matches())

As languages like Scala and Clojure support procedural code, pattern matching is done as equal or with less difficulty compared with Java which needs to use regex. Scala can even be embedded into XML as its syntax is somewhat similar.Given below an overview of how regular expression is achieved in Clojure.
Data are manipulated in Clojure through the sequence called seq which is a logical list. Clojure can access java collections, its collections, Regular expression matches via the seq also called seq-able. Clojure's regular expression uses java.util.regex library at the lowest level. For achieving that the keyword re-seq is used.
Syntax:
(re-seq regexp string)
Example
(re-seq #"\w+" "Hello World") => ("Hello" "World") => #"\w+" represents the java.util.regex.Pattern

=== Java Interoperability ===
Considering Clojure, it gives clean, simple and direct access to java and can access Java API directly.Clojure doesnot wrap Java's string functions. We can call using Java interop forms. It provides syntax for accessing Java elements like classes, instances, constructors, methods and fields and can also wrap Java API. The “.” dot special form is used for accessing Java. Some Clojure syntax which can access Java API: 

{| class="wikitable" border="2"
|-
! Java
! Clojure
|-
| new Widget(“red”)
| (new Widget “red”)
|-
| Math.PI
| (.Math PI) or Math/PI
|-
| System.currentTimeMillis()
| (.System currentTimeMillis) or System/currentTimeMillis
|-
| rnd.nextInt()
| (.rnd nextInt) or (.nextInt rnd)
|-
|}

Clojure pass functions as arguments to other functions. But Java does not support this. So Clojure provides a member function memfn macro to wrap methods or can use anonymous function to wrap a method call.
(map (memfn toUpperCase) [“a” ,”short”,”message”])
or
(map #(.toUpperCase %)[“a”,”short”,”message”]) => #(body) represents the anonymous function in Clojure.

For example,
(def the-digits
(map #(Integer. (str %))(filter #(Character/isDigit %) (seq big-num-str))))

where (def big-num-str (str "123785334434se9088af8309304293872adbcdfd”))

The above code extracts the integers from string and discards the non-numeric characters. Lets look at the functions defined in the example. There are totally five functions defined.They are
(seq big-num-str) => get each character defined in big-num-str
(Character/isDigit %) => Checks whether the input is an integer
(filter #()) => Filter each string from str
(map #(Integer. (str %))) => Change the string to integer
(def the-digits) => Output the integers only in a string of characters.
Here,
#(Character/isDigit) represents the Java method Character.isDigit() and #(Integer.(str %)) represents the new java.lang.Integer(str(%))

Most of the Clojure library functions have defined semantics for objects of Java types. contains? and .get work on Java’s Maps, arrays, Strings, count works on Java Strings, Collections and arrays. Clojure is built around these aspects. It avails the performance of JVM and the richness of both the core APIs and the numerous third-party libraries written in the Java language and restrained from reinventing them.

=== Multiple Inheritance ===

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance][http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf 2] is the concept of using the methods and variables of more than one superclass to a sub class.Java was designed without multiple inheritance. But Java supports the solution of problems commonly solved with multiple inheritance in other ways with help of interfaces where the methods defined in it are not implemented.In Scala, classes are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance in Java.Lets see how multiple inheritance achieved in Scala:

As interfaces in Java, Scala allows traits but has some methods partially implemented. The only difference to classes is the traits may not have constructor parameters.

trait Similarity {
def isSimilar(x: Any): Boolean // not implemented
def isNotSimilar(x: Any): Boolean = !isSimilar(x) //implemented method
}

This trait defines two methods isSimilar and isNotSimilar where isSimilar does not provide a concrete method implementation (it is abstract in the terminology of Java), and the method isNotSimilar defines a concrete implementation. Consequently, classes that integrate this trait only have to provide a concrete implementation for isSimilar.

class Point(xc: Int, yc: Int) extends Similarity {
var x: Int = xc
var y: Int = yc
def isSimilar(obj: Any) = //need to implement the method here
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
}

object TraitsTest extends Application {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotSimilar(p2))
println(p1.isNotSimilar(p3)) //uses the already defined method
println(p1.isNotSimilar(2))
}

These are some of the aspects and traits of mixing functional and object-oriented approaches. As we discussed in the advantages section, both the approaches have their benefits and limitations. Mixing them aspect-wise enables the above features in such languages. Lets discuss those languages briefly in the next section.

== Languages Supporting Functional and OO code ==

OCaml and F#[[http://msdn.microsoft.com/en-us/library/dd233154.aspx 7]] are some of the languages which support both functional and object oriented programming. OCaml is as fast as C and its featured as [http://www.haskell.org/ Haskell] which is a pure functional language. F#[[http://oreilly.com/catalog/9780596153656 3]] is a dynamically typed language which can run on .NET framework and has supported immutable types i.e. tuples, records, discriminated unions and lists to work in Functional programming. It has functions that can either be in curried or in uncurried form. As in functional language it can pass functions as arguments to other functions, resulting in higher order functions. It also supports lambda functions and closures. F#,behaves like other .NET languages as both in imperative and object oriented style. 

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language and it is a dialect of Lisp. It is not a pure functional language and it is a dynamically typed language. Just like Java it runs on JVM platform. But its syntax differs from Java. It is represented as :

(functions arguments...)

The function followed by its arguments is enclosed in paranthesis. It has features like immutable data structures, high-order functions and recursion, easy and fast java interoperability. 

Python and Ruby are also the programming languages which offer the mix of functional and OO languages. But these languages doesn't support the algebraic data types and pattern matching.

==Conclusion ==
The above aspects of functional and object oriented programming techniques discuss some if their merits and demerits. Mixing them produces a new programming paradigm which leads to a new dimension in programming. A few fundamental concepts are explored in Clojure and Scala here. The ability of Clojure and Scala to run in JVM platform makes them more preferable than others in the market. Some of the merits like closure, less verbosity, high order functions, currying along with interoperation with previously written libraries in these languages make them more efficient and useful. There are also other languages which support functional and object oriented techniques. Mixing the approaches, evolve a new dimension in programming which is practical and opens doors to more exploration.

== References ==

# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-11T01:39:02Z

Dmcarmon: /* References */

= Introduction =

= Functional Programming =

Functional programming treats computation as the evaluation of mathematical functions. It is compute-centric rather than data-centric. Functional programming keeps no global state, does not use for or while loops, and data is immutable****. Instead, everything is done using functions, usually functions that evaluate mathematical expressions. Each of these functions maintain no internal state and will always produce the same output given the same input.

Let's look at an example. Suppose we have a list of numbers and we want to multiply each number in the list by 2. The first approach is the imperitive style:

array[] = {1,2,3,4,5}
for(i=0 ; i<array.length; i++){
array[i] = array[i] * 2;
}

In the above example, array[] is a global variable. If we fail to check the array length, then a runtime exception occurs which might result in the program being crashed. As far as functional style, there is a function called map(func,seq)(in python language) where the function 'func' is applied to each member of seq. The following code is written in a functional style.

numbers = [1,2,3,4,5]
/* define a method called compute on each number in the list */
def compute(var):
var = var * 2
return var
/* Now call the map function */
L = map(compute,numbers)
print L // L will print [1,4,6,8,10]

Notice that there is no global data nor any nested loops and the bound checking is handled internally within the map function. The programmer is relieved of of runtime errors and thus can debug the program easily.

Some advantages of this approach are:
* Easier debugging: Since every thing is broken down into small simple functions, the functions are often easy to debug.
* More compact code: Functional programming typically requires fewer lines of code. Since compution is done by function code reuse is prevelent.
* Nothing depends on state: Because functional programs keep no state information, the functions will always operate the same regardless of the past history of the program.

= Object-oriented Programming =
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] (OOP) is a programming paradigm organized around interacting "objects"(usually instances of a class) rather than "actions" and data rather than logic. A basic principle of OOP is that a program consists of a list of subroutines which can perform individually.

An object-oriented programming language provides support for the following object-oriented concepts--object, class, interface and inheritance. To illustrate this idea clearly and vividly let's review the following example-- your limbs. The "Limbs" is a class. Your body has two objects of type "limbs", named arms and legs. Their main functions are controlled/ managed by a set of biological signals sent from central nervous system( through an interface). So the nervous system is an interface which your body uses to interact with your limbs. The "limbs" is a well architected class. The "legs" has a subclass which contains "left leg" and "Right leg". The "legs" is being re-used to create the left leg and right leg by slightly changing the properties of it. If the "legs" owns attributes like length, color of skin etc, then the subclass, which contains "left leg" and "right leg" in this case, automatically inherit these attributes( that is called inheritance).

We could code in object-oriented paradigm as:

class Limbs /*define a class of limbs*/
def initialize(limbs,length,colorofskin)
@limbs=limbs
@length=length
@colorofskin=colorofskin
end
end
limbs=Limbs.new("legs","100cm","white") /*create a new object in class "Limbs"*/
class Legs<Limbs /*create a subclass "Legs",which belong to class"Limbs"*/
def initialize(legs,length,colorofskin)
super(length,colorofskin)
@legs=legs
end
end
legs=legs.new("left leg") /*create a new object in class of "Legs"*/

== Features of Object-oriented Programming ==
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]. A programmer can simply create a new object that inherits many of its features from super-class. And also, they can overwrite existing operations or add new ones.This makes object-oriented programs easier to modify.
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation].This refers to hiding the internal representation of the object from the outside view. You can hide unnecessary implementation details from the object user. One of the benefits of encapsulation is data protection.
* [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism].This allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects. Consider the operator '+', for numbers it will generate the sum, but for strings it will produce a third string which concatenates the input strings.

== Advantages of Object-oriented Programming ==
* Simplicity: we use software objects to simulate real world objects, so the complexity is reduced and the program structure is very clear.
* Modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system.
* Modifiability: programmers can easily make minor changes in the data representation or operations in an OOP. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods.
* Extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones.
* Maintainability: objects can be maintained separately, making locating and fixing problems easier.
* Re-usability: objects can be reused in different programs.

= Mixing Functional and Object-Oriented Programming =

Motivation for Mixing

== Functional Techniques useful for Object-Oriented Programming ==
In object-oriented world, data and operations are grouped together into modular units called objects and we combine objects into structured networks to form a program. The results are depend on arguments and objects' state at method invocation time. While in functional world, the basic elements are variables in the mathematical sense and functions in the mathematical sense. Functional programming can reduce side-effects. If there is no side-effects, it means your can apply the function at anywhere freely. No matter how you apply this function, the same input arguments produce the same results.

According to above-mentioned information, we can perform functional programming on an object-oriented programming language because:
1). object can have constant state
2). method can depend only on its arguments and context available at method definition time

Combining both these paradigms not only provide us a robust design structure, but also enable the programmers to develop solutions to complex problems quickly and effectively. One of the cornerstone of mixing functional and object-oriented code is treating functions as objects.It means that we can pass functions as arguments, store it and return them from other functions. This is highly useful in an user interface code where it can be used as call back functions which gets called when an event occurs(event driven programming).

Some of the basic features of Functional Programming which can be combined with Object Oriented paradigm are:

* Lambda Calculus
* Currying
* Powerful pattern matching

Let us now understand how each of the above feature of Functional language fits in the Object Oriented paradigm.

=== Lambda Calculus ===
Lambda calculus is the most critical basis of functional programming. A lambda expression is an anonymous expression that contain expressions and statements.Each expression stands for a function with one parameter.

Let consider the following function:

def f(x)
return x**2
print f(4)

We can use a lambda calculus to compute this expression without assigning it to a variable:

(lambda x:x**x)(4)

We can see that these two code snippets have the same results. It is more concise and flexible to define with lambda.
The above is a pure functional approach. In order to make code more state-less and concise, lambdas can be embedded inside the object-oriented language. The below code in Python demonstrates the use of lambda in a closure:

def fun(x):
return x%3==0
str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
filter(fun,str)

The above code works to find numbers which are divisible by 3.
We can simplify the code by the use of lambda as following:

str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print filter(lambda x: x%3==0, str)

=== Currying ===

=== Pattern Matching ===

== Examples of Mixing ==

A number of programming languages support mixing of both functional and object-oriented code. Three of these (Scala, Ruby, and Conjure), are described in more detail below.

=== Scala ===

[http://www.scala-lang.org/ Scala] is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. [http://www.scala-lang.org/ Scala] was conceived in 2001 and implemented by Martin Odersky. It supports mixing functional and object-oriented code.

==== Mixing Functional and Object-Oriented Code in Scala ====
[http://www.scala-lang.org/ Scala] is a strange specimen. It is a complete blend of object-oriented and functional programming. How can this happen? The functional world advocates immutability, but the object-oriented world focuses on the state and how to change it to fit your needs. [http://www.scala-lang.org/ Scala] allows you create both mutable and immutable objects. Consider the following example,
val str: String = "Hello World"
In the first line, an immutable version(a misnomer indeed) of <code>str</code> is being created . A rough translation into Java is below:

final String str = "Hello World"; //note the extra semi-colon
Consider the next example below,
val list: List[String] = List("Scala", "is", "the coolest", "language", "in the world!")

The same code can be written in Java as:

List<String> mutableList = new ArrayList<String>();
list.add("Scala");
list.add("is");
list.add("the coolest");
list.add("language");
list.add("in the world!");
List<String> immutableList = Collections.immutableList(mutableList);

Compared to Java, [http://www.scala-lang.org/ Scala] reduces the total number of lines you need to type and at the same time looks much simpler and less verbose. Even though the above example shows an immutable collection, scala also provides mutable collections and object types in the package <code>scala.collection.mutable.*</code>

As can be observed, even though [http://www.scala-lang.org/ Scala] advocates immutability, it does not restrict you from creating mutable objects. So it's the best of both worlds. Another part of the functional world is the concept of functions as ''''first class members'''' of the language. Some of the common languages like Ruby, Python and JavaScript all incorporate this feature. In the sense you can pass around functions to methods as a parameter. Enough talking;

Let us have a class say <code>'Person'</code> which has properties, <code>name</code> and another variable <code>age</code>.
In Java:

class Person{
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String s){
this.name = s;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}

In [http://www.scala-lang.org/ Scala]:
case class Person(name: String, age: Int)

This single line is equivalent to the above java code! Getters for <code>name</code> and <code>age</code>, <code>equals()</code>, and <code>hashCode()</code> method are automatically generated for you by the compiler. Isn't this an awesome feature?

Now assume we have a list of persons and we want to filter out all the persons who are of age 23. How would you do that in Java?

List<Person> persons; //has a bunch of person objects in it.
List<Person> twentyThree = new ArrayList<Person>();
for(Person p: persons){
if(p.getAge() == 23){
twentyThree.add(p);
}
}

In [http://www.scala-lang.org/ Scala]:

val twentyThree: List[Person] = persons.filter( _.age == 23)

That's it! In case you are wondering whats going on, filter is a method present on scala.List class and the code block <code>_.age == 23</code> is a function created on the fly and passed onto the filter method. More precisely its called a [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] - a functional concept which can be emulated in java only using anonymous inner classes. Scala's compiler transforms our one line function into some anonymous inner classes when generating java byte code, allowing developers to define functions in a simple manner.

In fact, every function is an object in [http://www.scala-lang.org/ Scala]. Scala's standard library has a number of functions which are objects themselves.

==== Implicits in Scala ====
In almost all programming languages, there is a necessity to profile the running time of the procedures and tune its performance. The old way of doing things in Java would be:

public class Main{
public static int factorial(int x){
if(x == 0 || x == 1) return 1
else return x * factorial(x-1)
}
public static void main(String [] args){
long beforeTime = System.currentTimeMillis();
int result = factorial(5);
System.out.println("Total time taken to execute factorial(5) is " + (System.currentTimeMillis() - result)+"ms");
System.out.println("factorial(5) = " + result);
}
}

However, if you want to find out the execution time of some other method, you would have to type in all the above lines again. So much for code re-use or [http://en.wikipedia.org/wiki/DRY DRY (dont't repeat yourself)]! Lets see how its done in [http://www.scala-lang.org/ Scala].

object Main{
def main(args: Array[String]){
def factorial(x: Int):Int = x match{
case 0 | 1 => 1
case _ => x * factorial(x-1)
}
import System.currentTimeMillis
def timeIt(msg: String = "Time to execute is: ")(func: => Unit){
val before = currentTimeMillis
func
println(msg + (currentTimeMillis - before) + "ms")
}
timeIt("Total time taken to execute factorial(5) is "){
val result = factorial(5)
println("factorial(5) = " + result)
}
}
//would print: factorial(5) = 120
// Total time taken to execute factorial(5) is 1ms

That's not right! The function <code>timeIt</code> looks like a feature built into the language. Try saving the above code into a separate file and run it - It will still work. Using this feature, it is possible to build powerful DSL languages which can run at full speed on JVM.

Ruby allows you to add new methods to objects. This feature is often called as [http://en.wikipedia.org/wiki/Monkey_patch Monkey Patching] because you are splitting open the class and adding/overriding methods (in)|(to) the class. Because other libraries may depend on some methods which you changed, often this leads to unexpected behavior at runtime. However, Scala provides yet another feature called [http://en.wikipedia.org/wiki/Implicit_function implicits] which helps you do this better.

In Java, <code>String</code> class is <code>final</code> so there is no way you can add new methods to it. But with implicits you can do more! Suppose you have some text in memory and you know it represents a number. But in Java the usual way to convert string to int is to do a <code>Integer.parseInt(string)</code> which seems so unnecessary. Let us make our lives easier...

implicit def strToInt(str: String) = new {
def asInt = Integer.parseInt(str)
}
val str = "1234"
println(str.asInt * 3) //prints out 3702

The above code gives us an impression as if String class has gained new <code>asInt</code> method. Can static object oriented languages do this? No! Infact scala cheats by calling our implicits to convert it into a different object as and when needed.

The above functionalities are purely object oriented, yet they are safe. They don't pollute the global namespace, unlike Ruby or Python.

=== Ruby ===

Ruby is another language that, like Scala, supports mixing functional and object-oriented code. It is a dynamically typed Object-Oriented Language which supports multiple programming paradigms, including functional, object-oriented, imperative and reflective. In Ruby, everything is an object, every bit of information and code can have its own properties and actions. However, Ruby’s blocks can be functional. A Ruby programmer can attach a closure to any method, which generates a functional block inside an object oriented code. A closure is a piece of code that can access the lexical environment of its definition [http://www.ruby-lang.org/en/ 11].

==== Ruby Mixing Example ====

Consider the following code snippet in Ruby which uses Object Oriented concepts like Classes and functional programming concepts like lambda.

class Multiply
def initialize(n)
@block = lambda {|a| n * a}
end
def mul(a)
@block.call a
end
end
twoMultiplier = Multiply.new 2
puts twoMultiplier.mul(6)

Here,'''''@block''''' is a closure. When we call the class ''Multiply'' using '''''twoAdder = Multiply.new 2''''' ,the ''initialize'' method is called by passing the parameter 2. Here n=2 binds itself to the block. So @block will be 2*a, that is,the closure remembers the parameter with which the initialize method was called even after the initialize method exits.

This value is used when the block is called in the add method.
Thus,'''''twoMultiplier.mul(6)''''' will return 2*6 = 12

==== Functional Style Coding in Ruby Blocks ====

Blocks are basically nameless functions which can be passed to a function and then that function can invoke the passed in nameless function. This is a common style called [http://en.wikipedia.org/wiki/Higher-order_function higher order functions] among languages that handle functions as first class objects. Basically blocks can be designed for loop abstraction and lets the user to design their own way of iterating the values, thereby hiding the implementation details.
For example, if we want to iterate backwards from the end to the beginning without revealing its internal implementations, we could implement the loop logic inside the block and pass it to a method or function.

Here is a [http://www.ruby-lang.org/en/ Ruby] implementation of block:

def printlist(array,&reverse)
array.each do |element|
puts "array element: #{element}"
end
reverse.call(array) /* Here it prints the reverse implementation of list*/
end

printlist([1,2,3,4,5,6]) { |array|
array.reverse.each do |element|
puts "array element: #{element}"
end
}
The statements between { } is a block and it gets called by <code>reverse.call(array)</code>within the printlist method.

=== Clojure ===

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language, and it is a dialect of Lisp. It is not a pure functional language. Instead, it is a dynamically typed language. Just like Java it runs on JVM platform, but its syntax differs from Java. It is represented as :

(functions arguments...)

The function and its arguments are enclosed in paranthesis. It has features like immutable data structures, high-order functions, recursion, and easy and fast java interoperability.

In Clojure's model, value calculation is purely functional. Values never change. New values are functions of old. But, logical identity is well supported via atomic references to values. The value of a reference (state of an identity) is always observable without coordination and freely shareable between threads.
When programs are constructed this way, functional value calculation is independent of identity-value association. This makes clojure easier to understand and test.

====Example Using Functional Technique in Clojure====

Consider the following functional programming example in Clojure-
(defn make-adder [x]
(let [y x]
(fn [z] (+ y z))))
(def add2 (make-adder 2))
(add2 4)

Here,'''''defn make-adder [x]''''' defines a function called ''make-adder''.'''''let [y x]''''' gives a local name y for the value x. Since the scope of any local names is lexical, a function created in the scope of local names will close over their values.'''''fn [z] (+ y z)''''' does the addition of y and z.
''
'''def add2 (make-adder 2)''''' calls the function ''make-adder'' passing the parameter 2 and calls this as ''add2''.Now, ''add2'' has computed 2+z. When '''''add2 4''''' is called it computes 2+4=6

====Example Using Object-Oriented Technique in Clojure====

The following program implements Run-Time Polymorphism which is an object-oriented programming concept.
(defmulti encounter (fn [x y] [(:Species x) (:Species y)]))
(defmethod encounter [:Bunny :Lion] [b l] :run-away)
(defmethod encounter [:Lion :Bunny] [l b] :eat)
(defmethod encounter [:Lion :Lion] [l1 l2] :fight)
(defmethod encounter [:Bunny :Bunny] [b1 b2] :mate)
(def b1 {:Species :Bunny :other :stuff})
(def b2 {:Species :Bunny :other :stuff})
(def l1 {:Species :Lion :other :stuff})
(def l2 {:Species :Lion :other :stuff})

(encounter b1 l1)
-> :run-away
(encounter l1 l2)
-> :fight

Here,'''''defmulti''''' is used to define multiple methods which have the same method name '''''encounter'''''.Depending on the parameters passed to the encounter method, one of the four methods is called.
'''''def''''' defines each of the different species.
When, '''''(encounter b1 l1)''''' is called, the first ''encounter'' method is called with the parameters ''Bunny'' and ''Lion''. As a result, ''run-away'' is printed.

= Conclusion =

= References =
#[http://en.wikipedia.org/wiki/Functional_programming Wikipedia - Functional Programming]
#[http://www.cs.cornell.edu/riccardo/prog-smlnj/notes-011001.pdf Notes on programming Standard ML of New Jersey]
#[http://users.dickinson.edu/~braught/courses/cs132f01/classes/code/Factorial.src.html Introduction to Computing - Dickinson College]
#[http://en.wikipedia.org/wiki/Object-oriented_programming Wikipedia - Object Oriented Programming]
#[http://searchsoa.techtarget.com/sDefinition/0,,sid26_gci212681,00.html More on Object Oriented Programming]
#[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas Understanding Ruby Blocks, Procs and Lambdas - Robert Sosinski]
#[http://www.codingday.com/power-of-functional-programming-its-features-and-its-future/ Power of Functional Programming, its Features and its Future]
#[http://skillsmatter.com/podcast/open-source-dot-net/mike-wagg-mark-needham-functional-and-oo-approaches-to-c-sharp-programming Mixing Functional and Object Oriented Approaches to Programming in C#]
#[http://en.wikipedia.org/wiki/Programming_paradigm Programming Paradigm]
#[http://en.wikipedia.org/wiki/Recursion Recursion]
#[http://www.scala-lang.org/ Scala]
#[http://en.wikipedia.org/wiki/Scala_%28programming_language%29 Scala Wikipedia]
#[http://clojure.org/ Clojure]
#[http://www.ruby-lang.org/en/ Ruby]
#[http://en.wikipedia.org/wiki/Standard_ML Standard ML]
#[http://en.wikipedia.org/wiki/Haskell_%28programming_language%29 Haskell]
#[http://en.wikipedia.org/wiki/ML_%28programming_language%29 ML Family]
#[http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java]
#[http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]
#[http://en.wikipedia.org/wiki/C%2B%2B C++ Programming Language]
#[http://en.wikipedia.org/wiki/Visual_Basic_.NET Visual Basic .Net]
# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]

= Mixing Functional & O-O code =

This chapter deals with the mixing of functional and object-oriented programming paradigms. We start with listing the different programming paradigms available today. We introduce functional and object-oriented approaches briefly and then discuss the advantages of one over the other. Following this, we discuss some aspects and features of mixing both the approaches. Finally, we talk about few languages that constitute such a mix.

== Programming Paradigms Today==

Several programmatic approaches to solve a particular task lead to distinct programming paradigms like, 
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
* Functional programming 
* Object Oriented programming 
* [http://en.wikipedia.org/wiki/Logic_programming Logical programming], etc. 
Lets focus on functional and object oriented programming approaches.

== Functional Programming ==

[http://en.wikipedia.org/wiki/Functional_programming Functional programming] is the task of decomposing a problem into a number of functions. Selectively executing these functions results in the solution to the problem. The functions mostly behave as mathematical. For given set of inputs the program should always return the same output. It usually concentrates on what type of problem we are dealing with rather than on the details of how to solve the problem. For example lets say there is a function which calculates area of a square. If we use it six times then we end up with area of a cube. Thus functional programming helps to build complex systems.

=== Approach ===

Expressions are the collection of variables and operations resulting in a single value this also deals with the way of solving the problem as expressions. Hence also called Expression related programming. It is structured as expression where each expression can be encapsulated in another yielding the result. Making the change in data structures as the program runs is called [http://en.wikipedia.org/wiki/Side_effect_(computer_science) side effects]. Purely functional language has no side effects. Language like Haskell is a pure functional language . Some languages need many approaches for achieving the desired result. Such languages are multi-paradigm. Examples for such languages are C++, Python,Lisp. Its like evaluating an expression and use the resulting value for something.

Structure of functional programming :

(fn2 ( fn1 ()[input list] ) []) => fn1 takes input list and the output of fn1 is used as input to fn2. Its a schematic representation of
how functional programming works.

Functional programming feature (Python) :

m = map(lambda i : i*i , numbers)
where ''numbers'' is an array of numbers and ''lambda'' is [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 closure].

Python has some functions like map, filter, reduce to support functional programming style. In the example above, the 'map' is a high-order function that takes a function and an array of numbers as input. The ''lambda'' takes i as input and returns i*i as output. Every result returned is appended to a list and produced as output. In functional programming, the programmer is given a natural framework for developing smaller, simpler, and more general modules, which are then glued together.

== Object Oriented Programming ==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] is a programming technique where everything is defined as an object. Objects are well-defined discrete bundles of data(attributes) and the associated functions(behavior). They are devised to resemble real-life objects and are uniquely identifiable by a name. The attributes could be of simple datatype(int, String, Boolean) or objects themselves. The behavior is defined by methods to use and manipulate the attributes. The values of attributes of an object at an instant is the state of the object. OO Programming allows objects to have their state retained throughout the code until manipulated otherwise. Objects are capable of housekeeping their own states, interacting and establishing relationships with other objects, inheriting, etc.

=== Fundamental concepts ===

A [http://en.wikipedia.org/wiki/Class_%28computer_science%29 class] is a user-defined datatype that provides implementation details to define the attributes and their properties. It is an abstract representation of an object(i.e.,) like a mold for objects.
An instance is an executable copy of a class. They are the actual objects created using the ‘class mold’ on run time.
Methods are a set of procedural statements or functions to define the behavior of an object, convey the current state, modify values of the attributes, etc.

Example :

An object in Java might look like this:

public class Person {
private String name;
public Person() {
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}

Here, OO Programming allows the programmer to set the ''name'' attribute of the class ''Person'' and get the name whenever needed in the code. An object of this class Person will remain in memory forever as long as there is a reference to it. As OO Programming allows objects to have their state retained, the value of the ''name'' attribute for a particular ''Person'' object remains the same across any part of the code until it is set differently.

=== Features ===

Three primary characteristics of object oriented programming are Encapsulation, Polymorphism, and Inheritance.
[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation] is the ability of objects to hide visibility of their attributes and behavior, thereby providing service independent of implementation.
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects.
[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance] is one where an existing type can be used to derive a new type. Derived types inherit the data and operations of the super-type. And also, they can overwrite existing operations or add new ones.

There are other important features of O-O programming like [http://en.wikipedia.org/wiki/Message_passing message passing], [http://en.wikipedia.org/wiki/Abstraction abstraction], delegation, etc.

Now, we have seen both the approaches and their features in brief. Lets discuss the advantages of one over the other.

== Advantages ==

=== Functional Approach over OO Approach[[http://www.jot.fm/issues/issue_2009_09/article5.pdf 8]]===
* Functional programming solves the problem with lesser number of lines of code than the OO programming style. 
* There is no side effect as they use immutable data structures also called [http://en.wikipedia.org/wiki/Persistent_data_structure Persistent Data Structure] which will have no change in the state of variables. Hence program dont have to depend on history. 
* There is no limit in the numeric types used as opposed to OO languages which mainly depend on primitive data types. 
* A programmer is given the freedom to think in terms of what to solve in the problem rather than concentrating on how to solve and the flow of the program. 
* Suitable for calculation intensive programs.

=== OO Approach over Functional Approach===
* Everything can be represented in an object and it has the attributes associated with it and hence the state of the object is known at any time. 
* A complex system can be subdivided into modules of objects where as in functional approach, many functions inter operate to form a complex system. 
* [http://en.wikipedia.org/wiki/Reusability Re-usability] (i.e.) OO approach enables programmers to create new objects that inherits many of its features from existing objects. This makes object-oriented programs easier to modify than functional. 
* [http://en.wikipedia.org/wiki/Debug Debugging] in Object Oriented environment is easy compared with functional approach where a small error in one function causes the whole system (i.e. all the functions) to fail. 
* Suitable for making application-oriented software. 

Both the approaches have their advantages and disadvantages. What if we could get the best of both the worlds? The next section deals with the aspects and features of how well both the approaches are mixed together in some languages.

== Mixing Functional & OO Code - Best of both the worlds ==

Languages that are a mix of functional and object oriented approaches(eg. Scala[[http://www.scala-lang.org/node/1305 1]], Clojure[[http://oreilly.com/catalog/9781934356333 10]], etc.) make use of best of both the worlds. They support various aspects of functional and object oriented approaches. They have a bunch of functional approach features[[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf 6]], which object oriented programming languages(like Java) lack which includes closures. Closures are first-class functions with free variables that are bound in the lexical environment. These languages also sport a very malleable syntax that makes them well suited for "domain specific languages" with the benefits of static typing. They are more expressive, extensible and allow reuse of programming abstractions.

Certain languages like Scala, Clojure, etc run on Java Virtual Machine(JVM) ensuring portability to all underlying platforms. They even support immutable objects. In Scala, new language constructs can be added in the form of libraries. They allow safe reuse[[http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf 9]] of programming abstractions and type-safe extension of software.

===Lambda===

A lambda[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] expression is an anonymous function that contain expressions and statements, and can be used to create delegates or expression types. Such kind of anonymous function can be defined and passed around as easily as other data types and can be used to contain functionality that need not be named. Some notable examples include closures[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] and currying. Lambda functions with no name can be called using the variable assigned to it.

g = lambda x: x*2
g(3)=6

We can have lambda function without assigning it to a variable which can be used as inline-function.

(lambda x: x*2)(3)

In [http://en.wikipedia.org/wiki/Clojure Clojure] as a functional language, the creation of a chunk of behavior that can be assigned to a variable (known as a lambda) is trivial. Below are two ways to create a lambda that returns the square of its argument.

(def square1 (fn [n] (* n n)))
(def square2 #(* % %))

===Currying ===

[http://en.wikipedia.org/wiki/Currying Currying] transforms a function that takes multiple parameters into a chain of functions, each taking a single parameter. It reuses a partially applied function where the function is originally defined as accepting n parameters.It can be interpreted as the technique to decompose a function that takes n parameters into n function each of them taking 1 parameter. For example to say in algebraic terms,consider the function f which takes 3 parameters x,y,z and Currying means that we can rewrite the function as a composition of 3 functions:

f(x,y,z) = 4*x+3*y+2*z
f(x)(y)(z) = 2*z+(3*y+(4*x))

In Scala, currying takes advantage of Scala’s syntactic sugar. Below is a currying example in Scala. This function creates a multiplier function which takes two arguments and partially defines it by assigning a constant to one argument and assigning it to a variable .Later the function is called by assigning the second argument.

def multiplier(i: Int)(factor: Int) = i * factor => method named multiplier which takes two parameters is defined
val byFive = multiplier(5) _ => The method is redefined with accepting one parameter and store it in a variable.
val byTen = multiplier(10) _

scala> byFive(2) => Method called by giving the second parameter.
res4: Int = 10

scala> byTen(2)
res5: Int = 20

===Less Verbosity===

In Java each variable should have its type defined beforehand. Whereas in languages like Scala, it is more concise and easier to read than the equivalent Java.

For example, a Map can be created with a simple syntax in Scala,Clojure than in Java:

<table>
<tr>
<td>
'''Java'''
Map<String, Integer> nMap = new HashMap<String, Integer>();
nMap.put("one", 1);
nMap.put("two", 2);
nMap.put("three", 3);
</td>
<td>
'''Scala'''

var nMap = Map("one" -> 1, "two" -> 2, "three" -> 3)

</td>
<td>
'''Clojure'''

(doto (new Java.util.HashMap)(.put “a” 1)(.put “b” 2))

</td>
</tr>
</table>

Here, Scala compiler knows that nMap uses Strings as keys, and Integers as values. Unlike Java, this need not be specified beforehand. Scala could figure it out itself. Moreover, Scala will give an error if a different key-value pair is tried to insert. This is called "type inference". This prevents a whole class of bugs at run time just like Java but with less verbosity.
In a similar way Clojure also involves only few lines of code compared with the object oriented Java language which takes many lines of code.A simple Clojure example and the associated Java code :
Example

(defn blank? [s] (every? #(Character/isWhitespace %) s))

The innermost function Character/isWhiteSpace checks the first argument % for any whitespace and returns true if it is. every? invoke the above inner function for all elements in the collection s.It has no variables, no branches etc.

Java code
isBlank() method checks to see whether a string is blank or contains only whitespace.

public class Stringcheck{
public static boolean isBlank(String str){
int len;
if(str==null || (strlen =str.length())==0)
return true;
for(int i=0; i<strlen;i++) {
if((Character.isWhitespace(str.charAt(i))==false)){
return false;
}
}
return true;
}
}

=== Pattern Matching ===

To say simply, a [http://en.wikipedia.org/wiki/Pattern_matching Pattern matching] is a technique to search string for the occurrence of any patterns or regularity. Pattern matching is an elegant way to decompose objects into their constituent parts for processing.Many languages support the concept of pattern matching. Perl supports pattern matching using the pattern definition mini language called regular expressions, also called regexes or REs, which is borrowed from the regular expressions used in many Unix tools, such as grep() and sed().The risk that the parts of an object might be changed outside of the control of the enclosing object is avoided. For example, if there is a Person class that contains a list of addresses, it will not be an issue to expose that list to clients if the list is immutable. The users will not be able to change the list unexpectedly.Given below is a simple example for pattern matching used in Perl:

$mystring = "Hello world!"; // Perls way of assigning string to a variable.
if($mystring =~ m/World/) { print "Yes"; } // Checks the string stored in variable mystring has the string "World".
$mystring =~ s/world/mom/; // Replaces the string "world" stored in mystring to mom.

Another sample of regular expression in java :

String mystring="Hello World" ;
Pattern str = Pattern.compile("\\w+"); => Pattern stored for matching.
Matcher fit = str.matcher(mystring); => Matcher class which perform matching of the string with the pattern defined.
if(fit.matches())

As languages like Scala and Clojure support procedural code, pattern matching is done as equal or with less difficulty compared with Java which needs to use regex. Scala can even be embedded into XML as its syntax is somewhat similar.Given below an overview of how regular expression is achieved in Clojure.
Data are manipulated in Clojure through the sequence called seq which is a logical list. Clojure can access java collections, its collections, Regular expression matches via the seq also called seq-able. Clojure's regular expression uses java.util.regex library at the lowest level. For achieving that the keyword re-seq is used.
Syntax:
(re-seq regexp string)
Example
(re-seq #"\w+" "Hello World") => ("Hello" "World") => #"\w+" represents the java.util.regex.Pattern

=== Java Interoperability ===
Considering Clojure, it gives clean, simple and direct access to java and can access Java API directly.Clojure doesnot wrap Java's string functions. We can call using Java interop forms. It provides syntax for accessing Java elements like classes, instances, constructors, methods and fields and can also wrap Java API. The “.” dot special form is used for accessing Java. Some Clojure syntax which can access Java API: 

{| class="wikitable" border="2"
|-
! Java
! Clojure
|-
| new Widget(“red”)
| (new Widget “red”)
|-
| Math.PI
| (.Math PI) or Math/PI
|-
| System.currentTimeMillis()
| (.System currentTimeMillis) or System/currentTimeMillis
|-
| rnd.nextInt()
| (.rnd nextInt) or (.nextInt rnd)
|-
|}

Clojure pass functions as arguments to other functions. But Java does not support this. So Clojure provides a member function memfn macro to wrap methods or can use anonymous function to wrap a method call.
(map (memfn toUpperCase) [“a” ,”short”,”message”])
or
(map #(.toUpperCase %)[“a”,”short”,”message”]) => #(body) represents the anonymous function in Clojure.

For example,
(def the-digits
(map #(Integer. (str %))(filter #(Character/isDigit %) (seq big-num-str))))

where (def big-num-str (str "123785334434se9088af8309304293872adbcdfd”))

The above code extracts the integers from string and discards the non-numeric characters. Lets look at the functions defined in the example. There are totally five functions defined.They are
(seq big-num-str) => get each character defined in big-num-str
(Character/isDigit %) => Checks whether the input is an integer
(filter #()) => Filter each string from str
(map #(Integer. (str %))) => Change the string to integer
(def the-digits) => Output the integers only in a string of characters.
Here,
#(Character/isDigit) represents the Java method Character.isDigit() and #(Integer.(str %)) represents the new java.lang.Integer(str(%))

Most of the Clojure library functions have defined semantics for objects of Java types. contains? and .get work on Java’s Maps, arrays, Strings, count works on Java Strings, Collections and arrays. Clojure is built around these aspects. It avails the performance of JVM and the richness of both the core APIs and the numerous third-party libraries written in the Java language and restrained from reinventing them.

=== Multiple Inheritance ===

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance][http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf 2] is the concept of using the methods and variables of more than one superclass to a sub class.Java was designed without multiple inheritance. But Java supports the solution of problems commonly solved with multiple inheritance in other ways with help of interfaces where the methods defined in it are not implemented.In Scala, classes are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance in Java.Lets see how multiple inheritance achieved in Scala:

As interfaces in Java, Scala allows traits but has some methods partially implemented. The only difference to classes is the traits may not have constructor parameters.

trait Similarity {
def isSimilar(x: Any): Boolean // not implemented
def isNotSimilar(x: Any): Boolean = !isSimilar(x) //implemented method
}

This trait defines two methods isSimilar and isNotSimilar where isSimilar does not provide a concrete method implementation (it is abstract in the terminology of Java), and the method isNotSimilar defines a concrete implementation. Consequently, classes that integrate this trait only have to provide a concrete implementation for isSimilar.

class Point(xc: Int, yc: Int) extends Similarity {
var x: Int = xc
var y: Int = yc
def isSimilar(obj: Any) = //need to implement the method here
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
}

object TraitsTest extends Application {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotSimilar(p2))
println(p1.isNotSimilar(p3)) //uses the already defined method
println(p1.isNotSimilar(2))
}

These are some of the aspects and traits of mixing functional and object-oriented approaches. As we discussed in the advantages section, both the approaches have their benefits and limitations. Mixing them aspect-wise enables the above features in such languages. Lets discuss those languages briefly in the next section.

== Languages Supporting Functional and OO code ==

OCaml and F#[[http://msdn.microsoft.com/en-us/library/dd233154.aspx 7]] are some of the languages which support both functional and object oriented programming. OCaml is as fast as C and its featured as [http://www.haskell.org/ Haskell] which is a pure functional language. F#[[http://oreilly.com/catalog/9780596153656 3]] is a dynamically typed language which can run on .NET framework and has supported immutable types i.e. tuples, records, discriminated unions and lists to work in Functional programming. It has functions that can either be in curried or in uncurried form. As in functional language it can pass functions as arguments to other functions, resulting in higher order functions. It also supports lambda functions and closures. F#,behaves like other .NET languages as both in imperative and object oriented style. 

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language and it is a dialect of Lisp. It is not a pure functional language and it is a dynamically typed language. Just like Java it runs on JVM platform. But its syntax differs from Java. It is represented as :

(functions arguments...)

The function followed by its arguments is enclosed in paranthesis. It has features like immutable data structures, high-order functions and recursion, easy and fast java interoperability. 

Python and Ruby are also the programming languages which offer the mix of functional and OO languages. But these languages doesn't support the algebraic data types and pattern matching.

==Conclusion ==
The above aspects of functional and object oriented programming techniques discuss some if their merits and demerits. Mixing them produces a new programming paradigm which leads to a new dimension in programming. A few fundamental concepts are explored in Clojure and Scala here. The ability of Clojure and Scala to run in JVM platform makes them more preferable than others in the market. Some of the merits like closure, less verbosity, high order functions, currying along with interoperation with previously written libraries in these languages make them more efficient and useful. There are also other languages which support functional and object oriented techniques. Mixing the approaches, evolve a new dimension in programming which is practical and opens doors to more exploration.

== References ==

# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-11T01:37:47Z

Dmcarmon: /* References */

= Introduction =

= Functional Programming =

Functional programming treats computation as the evaluation of mathematical functions. It is compute-centric rather than data-centric. Functional programming keeps no global state, does not use for or while loops, and data is immutable****. Instead, everything is done using functions, usually functions that evaluate mathematical expressions. Each of these functions maintain no internal state and will always produce the same output given the same input.

Let's look at an example. Suppose we have a list of numbers and we want to multiply each number in the list by 2. The first approach is the imperitive style:

array[] = {1,2,3,4,5}
for(i=0 ; i<array.length; i++){
array[i] = array[i] * 2;
}

In the above example, array[] is a global variable. If we fail to check the array length, then a runtime exception occurs which might result in the program being crashed. As far as functional style, there is a function called map(func,seq)(in python language) where the function 'func' is applied to each member of seq. The following code is written in a functional style.

numbers = [1,2,3,4,5]
/* define a method called compute on each number in the list */
def compute(var):
var = var * 2
return var
/* Now call the map function */
L = map(compute,numbers)
print L // L will print [1,4,6,8,10]

Notice that there is no global data nor any nested loops and the bound checking is handled internally within the map function. The programmer is relieved of of runtime errors and thus can debug the program easily.

Some advantages of this approach are:
* Easier debugging: Since every thing is broken down into small simple functions, the functions are often easy to debug.
* More compact code: Functional programming typically requires fewer lines of code. Since compution is done by function code reuse is prevelent.
* Nothing depends on state: Because functional programs keep no state information, the functions will always operate the same regardless of the past history of the program.

= Object-oriented Programming =
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] (OOP) is a programming paradigm organized around interacting "objects"(usually instances of a class) rather than "actions" and data rather than logic. A basic principle of OOP is that a program consists of a list of subroutines which can perform individually.

An object-oriented programming language provides support for the following object-oriented concepts--object, class, interface and inheritance. To illustrate this idea clearly and vividly let's review the following example-- your limbs. The "Limbs" is a class. Your body has two objects of type "limbs", named arms and legs. Their main functions are controlled/ managed by a set of biological signals sent from central nervous system( through an interface). So the nervous system is an interface which your body uses to interact with your limbs. The "limbs" is a well architected class. The "legs" has a subclass which contains "left leg" and "Right leg". The "legs" is being re-used to create the left leg and right leg by slightly changing the properties of it. If the "legs" owns attributes like length, color of skin etc, then the subclass, which contains "left leg" and "right leg" in this case, automatically inherit these attributes( that is called inheritance).

We could code in object-oriented paradigm as:

class Limbs /*define a class of limbs*/
def initialize(limbs,length,colorofskin)
@limbs=limbs
@length=length
@colorofskin=colorofskin
end
end
limbs=Limbs.new("legs","100cm","white") /*create a new object in class "Limbs"*/
class Legs<Limbs /*create a subclass "Legs",which belong to class"Limbs"*/
def initialize(legs,length,colorofskin)
super(length,colorofskin)
@legs=legs
end
end
legs=legs.new("left leg") /*create a new object in class of "Legs"*/

== Features of Object-oriented Programming ==
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]. A programmer can simply create a new object that inherits many of its features from super-class. And also, they can overwrite existing operations or add new ones.This makes object-oriented programs easier to modify.
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation].This refers to hiding the internal representation of the object from the outside view. You can hide unnecessary implementation details from the object user. One of the benefits of encapsulation is data protection.
* [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism].This allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects. Consider the operator '+', for numbers it will generate the sum, but for strings it will produce a third string which concatenates the input strings.

== Advantages of Object-oriented Programming ==
* Simplicity: we use software objects to simulate real world objects, so the complexity is reduced and the program structure is very clear.
* Modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system.
* Modifiability: programmers can easily make minor changes in the data representation or operations in an OOP. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods.
* Extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones.
* Maintainability: objects can be maintained separately, making locating and fixing problems easier.
* Re-usability: objects can be reused in different programs.

= Mixing Functional and Object-Oriented Programming =

Motivation for Mixing

== Functional Techniques useful for Object-Oriented Programming ==
In object-oriented world, data and operations are grouped together into modular units called objects and we combine objects into structured networks to form a program. The results are depend on arguments and objects' state at method invocation time. While in functional world, the basic elements are variables in the mathematical sense and functions in the mathematical sense. Functional programming can reduce side-effects. If there is no side-effects, it means your can apply the function at anywhere freely. No matter how you apply this function, the same input arguments produce the same results.

According to above-mentioned information, we can perform functional programming on an object-oriented programming language because:
1). object can have constant state
2). method can depend only on its arguments and context available at method definition time

Combining both these paradigms not only provide us a robust design structure, but also enable the programmers to develop solutions to complex problems quickly and effectively. One of the cornerstone of mixing functional and object-oriented code is treating functions as objects.It means that we can pass functions as arguments, store it and return them from other functions. This is highly useful in an user interface code where it can be used as call back functions which gets called when an event occurs(event driven programming).

Some of the basic features of Functional Programming which can be combined with Object Oriented paradigm are:

* Lambda Calculus
* Currying
* Powerful pattern matching

Let us now understand how each of the above feature of Functional language fits in the Object Oriented paradigm.

=== Lambda Calculus ===
Lambda calculus is the most critical basis of functional programming. A lambda expression is an anonymous expression that contain expressions and statements.Each expression stands for a function with one parameter.

Let consider the following function:

def f(x)
return x**2
print f(4)

We can use a lambda calculus to compute this expression without assigning it to a variable:

(lambda x:x**x)(4)

We can see that these two code snippets have the same results. It is more concise and flexible to define with lambda.
The above is a pure functional approach. In order to make code more state-less and concise, lambdas can be embedded inside the object-oriented language. The below code in Python demonstrates the use of lambda in a closure:

def fun(x):
return x%3==0
str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
filter(fun,str)

The above code works to find numbers which are divisible by 3.
We can simplify the code by the use of lambda as following:

str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print filter(lambda x: x%3==0, str)

=== Currying ===

=== Pattern Matching ===

== Examples of Mixing ==

A number of programming languages support mixing of both functional and object-oriented code. Three of these (Scala, Ruby, and Conjure), are described in more detail below.

=== Scala ===

[http://www.scala-lang.org/ Scala] is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. [http://www.scala-lang.org/ Scala] was conceived in 2001 and implemented by Martin Odersky. It supports mixing functional and object-oriented code.

==== Mixing Functional and Object-Oriented Code in Scala ====
[http://www.scala-lang.org/ Scala] is a strange specimen. It is a complete blend of object-oriented and functional programming. How can this happen? The functional world advocates immutability, but the object-oriented world focuses on the state and how to change it to fit your needs. [http://www.scala-lang.org/ Scala] allows you create both mutable and immutable objects. Consider the following example,
val str: String = "Hello World"
In the first line, an immutable version(a misnomer indeed) of <code>str</code> is being created . A rough translation into Java is below:

final String str = "Hello World"; //note the extra semi-colon
Consider the next example below,
val list: List[String] = List("Scala", "is", "the coolest", "language", "in the world!")

The same code can be written in Java as:

List<String> mutableList = new ArrayList<String>();
list.add("Scala");
list.add("is");
list.add("the coolest");
list.add("language");
list.add("in the world!");
List<String> immutableList = Collections.immutableList(mutableList);

Compared to Java, [http://www.scala-lang.org/ Scala] reduces the total number of lines you need to type and at the same time looks much simpler and less verbose. Even though the above example shows an immutable collection, scala also provides mutable collections and object types in the package <code>scala.collection.mutable.*</code>

As can be observed, even though [http://www.scala-lang.org/ Scala] advocates immutability, it does not restrict you from creating mutable objects. So it's the best of both worlds. Another part of the functional world is the concept of functions as ''''first class members'''' of the language. Some of the common languages like Ruby, Python and JavaScript all incorporate this feature. In the sense you can pass around functions to methods as a parameter. Enough talking;

Let us have a class say <code>'Person'</code> which has properties, <code>name</code> and another variable <code>age</code>.
In Java:

class Person{
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String s){
this.name = s;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}

In [http://www.scala-lang.org/ Scala]:
case class Person(name: String, age: Int)

This single line is equivalent to the above java code! Getters for <code>name</code> and <code>age</code>, <code>equals()</code>, and <code>hashCode()</code> method are automatically generated for you by the compiler. Isn't this an awesome feature?

Now assume we have a list of persons and we want to filter out all the persons who are of age 23. How would you do that in Java?

List<Person> persons; //has a bunch of person objects in it.
List<Person> twentyThree = new ArrayList<Person>();
for(Person p: persons){
if(p.getAge() == 23){
twentyThree.add(p);
}
}

In [http://www.scala-lang.org/ Scala]:

val twentyThree: List[Person] = persons.filter( _.age == 23)

That's it! In case you are wondering whats going on, filter is a method present on scala.List class and the code block <code>_.age == 23</code> is a function created on the fly and passed onto the filter method. More precisely its called a [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] - a functional concept which can be emulated in java only using anonymous inner classes. Scala's compiler transforms our one line function into some anonymous inner classes when generating java byte code, allowing developers to define functions in a simple manner.

In fact, every function is an object in [http://www.scala-lang.org/ Scala]. Scala's standard library has a number of functions which are objects themselves.

==== Implicits in Scala ====
In almost all programming languages, there is a necessity to profile the running time of the procedures and tune its performance. The old way of doing things in Java would be:

public class Main{
public static int factorial(int x){
if(x == 0 || x == 1) return 1
else return x * factorial(x-1)
}
public static void main(String [] args){
long beforeTime = System.currentTimeMillis();
int result = factorial(5);
System.out.println("Total time taken to execute factorial(5) is " + (System.currentTimeMillis() - result)+"ms");
System.out.println("factorial(5) = " + result);
}
}

However, if you want to find out the execution time of some other method, you would have to type in all the above lines again. So much for code re-use or [http://en.wikipedia.org/wiki/DRY DRY (dont't repeat yourself)]! Lets see how its done in [http://www.scala-lang.org/ Scala].

object Main{
def main(args: Array[String]){
def factorial(x: Int):Int = x match{
case 0 | 1 => 1
case _ => x * factorial(x-1)
}
import System.currentTimeMillis
def timeIt(msg: String = "Time to execute is: ")(func: => Unit){
val before = currentTimeMillis
func
println(msg + (currentTimeMillis - before) + "ms")
}
timeIt("Total time taken to execute factorial(5) is "){
val result = factorial(5)
println("factorial(5) = " + result)
}
}
//would print: factorial(5) = 120
// Total time taken to execute factorial(5) is 1ms

That's not right! The function <code>timeIt</code> looks like a feature built into the language. Try saving the above code into a separate file and run it - It will still work. Using this feature, it is possible to build powerful DSL languages which can run at full speed on JVM.

Ruby allows you to add new methods to objects. This feature is often called as [http://en.wikipedia.org/wiki/Monkey_patch Monkey Patching] because you are splitting open the class and adding/overriding methods (in)|(to) the class. Because other libraries may depend on some methods which you changed, often this leads to unexpected behavior at runtime. However, Scala provides yet another feature called [http://en.wikipedia.org/wiki/Implicit_function implicits] which helps you do this better.

In Java, <code>String</code> class is <code>final</code> so there is no way you can add new methods to it. But with implicits you can do more! Suppose you have some text in memory and you know it represents a number. But in Java the usual way to convert string to int is to do a <code>Integer.parseInt(string)</code> which seems so unnecessary. Let us make our lives easier...

implicit def strToInt(str: String) = new {
def asInt = Integer.parseInt(str)
}
val str = "1234"
println(str.asInt * 3) //prints out 3702

The above code gives us an impression as if String class has gained new <code>asInt</code> method. Can static object oriented languages do this? No! Infact scala cheats by calling our implicits to convert it into a different object as and when needed.

The above functionalities are purely object oriented, yet they are safe. They don't pollute the global namespace, unlike Ruby or Python.

=== Ruby ===

Ruby is another language that, like Scala, supports mixing functional and object-oriented code. It is a dynamically typed Object-Oriented Language which supports multiple programming paradigms, including functional, object-oriented, imperative and reflective. In Ruby, everything is an object, every bit of information and code can have its own properties and actions. However, Ruby’s blocks can be functional. A Ruby programmer can attach a closure to any method, which generates a functional block inside an object oriented code. A closure is a piece of code that can access the lexical environment of its definition [http://www.ruby-lang.org/en/ 11].

==== Ruby Mixing Example ====

Consider the following code snippet in Ruby which uses Object Oriented concepts like Classes and functional programming concepts like lambda.

class Multiply
def initialize(n)
@block = lambda {|a| n * a}
end
def mul(a)
@block.call a
end
end
twoMultiplier = Multiply.new 2
puts twoMultiplier.mul(6)

Here,'''''@block''''' is a closure. When we call the class ''Multiply'' using '''''twoAdder = Multiply.new 2''''' ,the ''initialize'' method is called by passing the parameter 2. Here n=2 binds itself to the block. So @block will be 2*a, that is,the closure remembers the parameter with which the initialize method was called even after the initialize method exits.

This value is used when the block is called in the add method.
Thus,'''''twoMultiplier.mul(6)''''' will return 2*6 = 12

==== Functional Style Coding in Ruby Blocks ====

Blocks are basically nameless functions which can be passed to a function and then that function can invoke the passed in nameless function. This is a common style called [http://en.wikipedia.org/wiki/Higher-order_function higher order functions] among languages that handle functions as first class objects. Basically blocks can be designed for loop abstraction and lets the user to design their own way of iterating the values, thereby hiding the implementation details.
For example, if we want to iterate backwards from the end to the beginning without revealing its internal implementations, we could implement the loop logic inside the block and pass it to a method or function.

Here is a [http://www.ruby-lang.org/en/ Ruby] implementation of block:

def printlist(array,&reverse)
array.each do |element|
puts "array element: #{element}"
end
reverse.call(array) /* Here it prints the reverse implementation of list*/
end

printlist([1,2,3,4,5,6]) { |array|
array.reverse.each do |element|
puts "array element: #{element}"
end
}
The statements between { } is a block and it gets called by <code>reverse.call(array)</code>within the printlist method.

=== Clojure ===

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language, and it is a dialect of Lisp. It is not a pure functional language. Instead, it is a dynamically typed language. Just like Java it runs on JVM platform, but its syntax differs from Java. It is represented as :

(functions arguments...)

The function and its arguments are enclosed in paranthesis. It has features like immutable data structures, high-order functions, recursion, and easy and fast java interoperability.

In Clojure's model, value calculation is purely functional. Values never change. New values are functions of old. But, logical identity is well supported via atomic references to values. The value of a reference (state of an identity) is always observable without coordination and freely shareable between threads.
When programs are constructed this way, functional value calculation is independent of identity-value association. This makes clojure easier to understand and test.

====Example Using Functional Technique in Clojure====

Consider the following functional programming example in Clojure-
(defn make-adder [x]
(let [y x]
(fn [z] (+ y z))))
(def add2 (make-adder 2))
(add2 4)

Here,'''''defn make-adder [x]''''' defines a function called ''make-adder''.'''''let [y x]''''' gives a local name y for the value x. Since the scope of any local names is lexical, a function created in the scope of local names will close over their values.'''''fn [z] (+ y z)''''' does the addition of y and z.
''
'''def add2 (make-adder 2)''''' calls the function ''make-adder'' passing the parameter 2 and calls this as ''add2''.Now, ''add2'' has computed 2+z. When '''''add2 4''''' is called it computes 2+4=6

====Example Using Object-Oriented Technique in Clojure====

The following program implements Run-Time Polymorphism which is an object-oriented programming concept.
(defmulti encounter (fn [x y] [(:Species x) (:Species y)]))
(defmethod encounter [:Bunny :Lion] [b l] :run-away)
(defmethod encounter [:Lion :Bunny] [l b] :eat)
(defmethod encounter [:Lion :Lion] [l1 l2] :fight)
(defmethod encounter [:Bunny :Bunny] [b1 b2] :mate)
(def b1 {:Species :Bunny :other :stuff})
(def b2 {:Species :Bunny :other :stuff})
(def l1 {:Species :Lion :other :stuff})
(def l2 {:Species :Lion :other :stuff})

(encounter b1 l1)
-> :run-away
(encounter l1 l2)
-> :fight

Here,'''''defmulti''''' is used to define multiple methods which have the same method name '''''encounter'''''.Depending on the parameters passed to the encounter method, one of the four methods is called.
'''''def''''' defines each of the different species.
When, '''''(encounter b1 l1)''''' is called, the first ''encounter'' method is called with the parameters ''Bunny'' and ''Lion''. As a result, ''run-away'' is printed.

= Conclusion =

= References =
#[http://en.wikipedia.org/wiki/Functional_programming Wikipedia - Functional Programming]
#[http://www.cs.cornell.edu/riccardo/prog-smlnj/notes-011001.pdf Notes on programming Standard ML of New Jersey]
#[http://users.dickinson.edu/~braught/courses/cs132f01/classes/code/Factorial.src.html Introduction to Computing - Dickinson College]
#[http://en.wikipedia.org/wiki/Object-oriented_programming Wikipedia - Object Oriented Programming]
#[http://searchsoa.techtarget.com/sDefinition/0,,sid26_gci212681,00.html More on Object Oriented Programming]
#[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas Understanding Ruby Blocks, Procs and Lambdas - Robert Sosinski]
#[http://www.codingday.com/power-of-functional-programming-its-features-and-its-future/ Power of Functional Programming, its Features and its Future]
#[http://skillsmatter.com/podcast/open-source-dot-net/mike-wagg-mark-needham-functional-and-oo-approaches-to-c-sharp-programming Mixing Functional and Object Oriented Approaches to Programming in C#]
#[http://en.wikipedia.org/wiki/Programming_paradigm Programming Paradigm]
#[http://en.wikipedia.org/wiki/Recursion Recursion]
#[http://www.scala-lang.org/ Scala]
#[http://en.wikipedia.org/wiki/Scala_%28programming_language%29 Scala Wikipedia]
#[http://clojure.org/ Clojure]
#[http://www.ruby-lang.org/en/ Ruby]
#[http://en.wikipedia.org/wiki/Standard_ML Standard ML]
#[http://en.wikipedia.org/wiki/Haskell_%28programming_language%29 Haskell]
#[http://en.wikipedia.org/wiki/ML_%28programming_language%29 ML Family]
#[http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java]
#[http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]
#[http://en.wikipedia.org/wiki/C%2B%2B C++ Programming Language]
#[http://en.wikipedia.org/wiki/Visual_Basic_.NET Visual Basic .Net]

= Mixing Functional & O-O code =

This chapter deals with the mixing of functional and object-oriented programming paradigms. We start with listing the different programming paradigms available today. We introduce functional and object-oriented approaches briefly and then discuss the advantages of one over the other. Following this, we discuss some aspects and features of mixing both the approaches. Finally, we talk about few languages that constitute such a mix.

== Programming Paradigms Today==

Several programmatic approaches to solve a particular task lead to distinct programming paradigms like, 
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
* Functional programming 
* Object Oriented programming 
* [http://en.wikipedia.org/wiki/Logic_programming Logical programming], etc. 
Lets focus on functional and object oriented programming approaches.

== Functional Programming ==

[http://en.wikipedia.org/wiki/Functional_programming Functional programming] is the task of decomposing a problem into a number of functions. Selectively executing these functions results in the solution to the problem. The functions mostly behave as mathematical. For given set of inputs the program should always return the same output. It usually concentrates on what type of problem we are dealing with rather than on the details of how to solve the problem. For example lets say there is a function which calculates area of a square. If we use it six times then we end up with area of a cube. Thus functional programming helps to build complex systems.

=== Approach ===

Expressions are the collection of variables and operations resulting in a single value this also deals with the way of solving the problem as expressions. Hence also called Expression related programming. It is structured as expression where each expression can be encapsulated in another yielding the result. Making the change in data structures as the program runs is called [http://en.wikipedia.org/wiki/Side_effect_(computer_science) side effects]. Purely functional language has no side effects. Language like Haskell is a pure functional language . Some languages need many approaches for achieving the desired result. Such languages are multi-paradigm. Examples for such languages are C++, Python,Lisp. Its like evaluating an expression and use the resulting value for something.

Structure of functional programming :

(fn2 ( fn1 ()[input list] ) []) => fn1 takes input list and the output of fn1 is used as input to fn2. Its a schematic representation of
how functional programming works.

Functional programming feature (Python) :

m = map(lambda i : i*i , numbers)
where ''numbers'' is an array of numbers and ''lambda'' is [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 closure].

Python has some functions like map, filter, reduce to support functional programming style. In the example above, the 'map' is a high-order function that takes a function and an array of numbers as input. The ''lambda'' takes i as input and returns i*i as output. Every result returned is appended to a list and produced as output. In functional programming, the programmer is given a natural framework for developing smaller, simpler, and more general modules, which are then glued together.

== Object Oriented Programming ==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] is a programming technique where everything is defined as an object. Objects are well-defined discrete bundles of data(attributes) and the associated functions(behavior). They are devised to resemble real-life objects and are uniquely identifiable by a name. The attributes could be of simple datatype(int, String, Boolean) or objects themselves. The behavior is defined by methods to use and manipulate the attributes. The values of attributes of an object at an instant is the state of the object. OO Programming allows objects to have their state retained throughout the code until manipulated otherwise. Objects are capable of housekeeping their own states, interacting and establishing relationships with other objects, inheriting, etc.

=== Fundamental concepts ===

A [http://en.wikipedia.org/wiki/Class_%28computer_science%29 class] is a user-defined datatype that provides implementation details to define the attributes and their properties. It is an abstract representation of an object(i.e.,) like a mold for objects.
An instance is an executable copy of a class. They are the actual objects created using the ‘class mold’ on run time.
Methods are a set of procedural statements or functions to define the behavior of an object, convey the current state, modify values of the attributes, etc.

Example :

An object in Java might look like this:

public class Person {
private String name;
public Person() {
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}

Here, OO Programming allows the programmer to set the ''name'' attribute of the class ''Person'' and get the name whenever needed in the code. An object of this class Person will remain in memory forever as long as there is a reference to it. As OO Programming allows objects to have their state retained, the value of the ''name'' attribute for a particular ''Person'' object remains the same across any part of the code until it is set differently.

=== Features ===

Three primary characteristics of object oriented programming are Encapsulation, Polymorphism, and Inheritance.
[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation] is the ability of objects to hide visibility of their attributes and behavior, thereby providing service independent of implementation.
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects.
[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance] is one where an existing type can be used to derive a new type. Derived types inherit the data and operations of the super-type. And also, they can overwrite existing operations or add new ones.

There are other important features of O-O programming like [http://en.wikipedia.org/wiki/Message_passing message passing], [http://en.wikipedia.org/wiki/Abstraction abstraction], delegation, etc.

Now, we have seen both the approaches and their features in brief. Lets discuss the advantages of one over the other.

== Advantages ==

=== Functional Approach over OO Approach[[http://www.jot.fm/issues/issue_2009_09/article5.pdf 8]]===
* Functional programming solves the problem with lesser number of lines of code than the OO programming style. 
* There is no side effect as they use immutable data structures also called [http://en.wikipedia.org/wiki/Persistent_data_structure Persistent Data Structure] which will have no change in the state of variables. Hence program dont have to depend on history. 
* There is no limit in the numeric types used as opposed to OO languages which mainly depend on primitive data types. 
* A programmer is given the freedom to think in terms of what to solve in the problem rather than concentrating on how to solve and the flow of the program. 
* Suitable for calculation intensive programs.

=== OO Approach over Functional Approach===
* Everything can be represented in an object and it has the attributes associated with it and hence the state of the object is known at any time. 
* A complex system can be subdivided into modules of objects where as in functional approach, many functions inter operate to form a complex system. 
* [http://en.wikipedia.org/wiki/Reusability Re-usability] (i.e.) OO approach enables programmers to create new objects that inherits many of its features from existing objects. This makes object-oriented programs easier to modify than functional. 
* [http://en.wikipedia.org/wiki/Debug Debugging] in Object Oriented environment is easy compared with functional approach where a small error in one function causes the whole system (i.e. all the functions) to fail. 
* Suitable for making application-oriented software. 

Both the approaches have their advantages and disadvantages. What if we could get the best of both the worlds? The next section deals with the aspects and features of how well both the approaches are mixed together in some languages.

== Mixing Functional & OO Code - Best of both the worlds ==

Languages that are a mix of functional and object oriented approaches(eg. Scala[[http://www.scala-lang.org/node/1305 1]], Clojure[[http://oreilly.com/catalog/9781934356333 10]], etc.) make use of best of both the worlds. They support various aspects of functional and object oriented approaches. They have a bunch of functional approach features[[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf 6]], which object oriented programming languages(like Java) lack which includes closures. Closures are first-class functions with free variables that are bound in the lexical environment. These languages also sport a very malleable syntax that makes them well suited for "domain specific languages" with the benefits of static typing. They are more expressive, extensible and allow reuse of programming abstractions.

Certain languages like Scala, Clojure, etc run on Java Virtual Machine(JVM) ensuring portability to all underlying platforms. They even support immutable objects. In Scala, new language constructs can be added in the form of libraries. They allow safe reuse[[http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf 9]] of programming abstractions and type-safe extension of software.

===Lambda===

A lambda[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] expression is an anonymous function that contain expressions and statements, and can be used to create delegates or expression types. Such kind of anonymous function can be defined and passed around as easily as other data types and can be used to contain functionality that need not be named. Some notable examples include closures[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] and currying. Lambda functions with no name can be called using the variable assigned to it.

g = lambda x: x*2
g(3)=6

We can have lambda function without assigning it to a variable which can be used as inline-function.

(lambda x: x*2)(3)

In [http://en.wikipedia.org/wiki/Clojure Clojure] as a functional language, the creation of a chunk of behavior that can be assigned to a variable (known as a lambda) is trivial. Below are two ways to create a lambda that returns the square of its argument.

(def square1 (fn [n] (* n n)))
(def square2 #(* % %))

===Currying ===

[http://en.wikipedia.org/wiki/Currying Currying] transforms a function that takes multiple parameters into a chain of functions, each taking a single parameter. It reuses a partially applied function where the function is originally defined as accepting n parameters.It can be interpreted as the technique to decompose a function that takes n parameters into n function each of them taking 1 parameter. For example to say in algebraic terms,consider the function f which takes 3 parameters x,y,z and Currying means that we can rewrite the function as a composition of 3 functions:

f(x,y,z) = 4*x+3*y+2*z
f(x)(y)(z) = 2*z+(3*y+(4*x))

In Scala, currying takes advantage of Scala’s syntactic sugar. Below is a currying example in Scala. This function creates a multiplier function which takes two arguments and partially defines it by assigning a constant to one argument and assigning it to a variable .Later the function is called by assigning the second argument.

def multiplier(i: Int)(factor: Int) = i * factor => method named multiplier which takes two parameters is defined
val byFive = multiplier(5) _ => The method is redefined with accepting one parameter and store it in a variable.
val byTen = multiplier(10) _

scala> byFive(2) => Method called by giving the second parameter.
res4: Int = 10

scala> byTen(2)
res5: Int = 20

===Less Verbosity===

In Java each variable should have its type defined beforehand. Whereas in languages like Scala, it is more concise and easier to read than the equivalent Java.

For example, a Map can be created with a simple syntax in Scala,Clojure than in Java:

<table>
<tr>
<td>
'''Java'''
Map<String, Integer> nMap = new HashMap<String, Integer>();
nMap.put("one", 1);
nMap.put("two", 2);
nMap.put("three", 3);
</td>
<td>
'''Scala'''

var nMap = Map("one" -> 1, "two" -> 2, "three" -> 3)

</td>
<td>
'''Clojure'''

(doto (new Java.util.HashMap)(.put “a” 1)(.put “b” 2))

</td>
</tr>
</table>

Here, Scala compiler knows that nMap uses Strings as keys, and Integers as values. Unlike Java, this need not be specified beforehand. Scala could figure it out itself. Moreover, Scala will give an error if a different key-value pair is tried to insert. This is called "type inference". This prevents a whole class of bugs at run time just like Java but with less verbosity.
In a similar way Clojure also involves only few lines of code compared with the object oriented Java language which takes many lines of code.A simple Clojure example and the associated Java code :
Example

(defn blank? [s] (every? #(Character/isWhitespace %) s))

The innermost function Character/isWhiteSpace checks the first argument % for any whitespace and returns true if it is. every? invoke the above inner function for all elements in the collection s.It has no variables, no branches etc.

Java code
isBlank() method checks to see whether a string is blank or contains only whitespace.

public class Stringcheck{
public static boolean isBlank(String str){
int len;
if(str==null || (strlen =str.length())==0)
return true;
for(int i=0; i<strlen;i++) {
if((Character.isWhitespace(str.charAt(i))==false)){
return false;
}
}
return true;
}
}

=== Pattern Matching ===

To say simply, a [http://en.wikipedia.org/wiki/Pattern_matching Pattern matching] is a technique to search string for the occurrence of any patterns or regularity. Pattern matching is an elegant way to decompose objects into their constituent parts for processing.Many languages support the concept of pattern matching. Perl supports pattern matching using the pattern definition mini language called regular expressions, also called regexes or REs, which is borrowed from the regular expressions used in many Unix tools, such as grep() and sed().The risk that the parts of an object might be changed outside of the control of the enclosing object is avoided. For example, if there is a Person class that contains a list of addresses, it will not be an issue to expose that list to clients if the list is immutable. The users will not be able to change the list unexpectedly.Given below is a simple example for pattern matching used in Perl:

$mystring = "Hello world!"; // Perls way of assigning string to a variable.
if($mystring =~ m/World/) { print "Yes"; } // Checks the string stored in variable mystring has the string "World".
$mystring =~ s/world/mom/; // Replaces the string "world" stored in mystring to mom.

Another sample of regular expression in java :

String mystring="Hello World" ;
Pattern str = Pattern.compile("\\w+"); => Pattern stored for matching.
Matcher fit = str.matcher(mystring); => Matcher class which perform matching of the string with the pattern defined.
if(fit.matches())

As languages like Scala and Clojure support procedural code, pattern matching is done as equal or with less difficulty compared with Java which needs to use regex. Scala can even be embedded into XML as its syntax is somewhat similar.Given below an overview of how regular expression is achieved in Clojure.
Data are manipulated in Clojure through the sequence called seq which is a logical list. Clojure can access java collections, its collections, Regular expression matches via the seq also called seq-able. Clojure's regular expression uses java.util.regex library at the lowest level. For achieving that the keyword re-seq is used.
Syntax:
(re-seq regexp string)
Example
(re-seq #"\w+" "Hello World") => ("Hello" "World") => #"\w+" represents the java.util.regex.Pattern

=== Java Interoperability ===
Considering Clojure, it gives clean, simple and direct access to java and can access Java API directly.Clojure doesnot wrap Java's string functions. We can call using Java interop forms. It provides syntax for accessing Java elements like classes, instances, constructors, methods and fields and can also wrap Java API. The “.” dot special form is used for accessing Java. Some Clojure syntax which can access Java API: 

{| class="wikitable" border="2"
|-
! Java
! Clojure
|-
| new Widget(“red”)
| (new Widget “red”)
|-
| Math.PI
| (.Math PI) or Math/PI
|-
| System.currentTimeMillis()
| (.System currentTimeMillis) or System/currentTimeMillis
|-
| rnd.nextInt()
| (.rnd nextInt) or (.nextInt rnd)
|-
|}

Clojure pass functions as arguments to other functions. But Java does not support this. So Clojure provides a member function memfn macro to wrap methods or can use anonymous function to wrap a method call.
(map (memfn toUpperCase) [“a” ,”short”,”message”])
or
(map #(.toUpperCase %)[“a”,”short”,”message”]) => #(body) represents the anonymous function in Clojure.

For example,
(def the-digits
(map #(Integer. (str %))(filter #(Character/isDigit %) (seq big-num-str))))

where (def big-num-str (str "123785334434se9088af8309304293872adbcdfd”))

The above code extracts the integers from string and discards the non-numeric characters. Lets look at the functions defined in the example. There are totally five functions defined.They are
(seq big-num-str) => get each character defined in big-num-str
(Character/isDigit %) => Checks whether the input is an integer
(filter #()) => Filter each string from str
(map #(Integer. (str %))) => Change the string to integer
(def the-digits) => Output the integers only in a string of characters.
Here,
#(Character/isDigit) represents the Java method Character.isDigit() and #(Integer.(str %)) represents the new java.lang.Integer(str(%))

Most of the Clojure library functions have defined semantics for objects of Java types. contains? and .get work on Java’s Maps, arrays, Strings, count works on Java Strings, Collections and arrays. Clojure is built around these aspects. It avails the performance of JVM and the richness of both the core APIs and the numerous third-party libraries written in the Java language and restrained from reinventing them.

=== Multiple Inheritance ===

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance][http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf 2] is the concept of using the methods and variables of more than one superclass to a sub class.Java was designed without multiple inheritance. But Java supports the solution of problems commonly solved with multiple inheritance in other ways with help of interfaces where the methods defined in it are not implemented.In Scala, classes are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance in Java.Lets see how multiple inheritance achieved in Scala:

As interfaces in Java, Scala allows traits but has some methods partially implemented. The only difference to classes is the traits may not have constructor parameters.

trait Similarity {
def isSimilar(x: Any): Boolean // not implemented
def isNotSimilar(x: Any): Boolean = !isSimilar(x) //implemented method
}

This trait defines two methods isSimilar and isNotSimilar where isSimilar does not provide a concrete method implementation (it is abstract in the terminology of Java), and the method isNotSimilar defines a concrete implementation. Consequently, classes that integrate this trait only have to provide a concrete implementation for isSimilar.

class Point(xc: Int, yc: Int) extends Similarity {
var x: Int = xc
var y: Int = yc
def isSimilar(obj: Any) = //need to implement the method here
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
}

object TraitsTest extends Application {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotSimilar(p2))
println(p1.isNotSimilar(p3)) //uses the already defined method
println(p1.isNotSimilar(2))
}

These are some of the aspects and traits of mixing functional and object-oriented approaches. As we discussed in the advantages section, both the approaches have their benefits and limitations. Mixing them aspect-wise enables the above features in such languages. Lets discuss those languages briefly in the next section.

== Languages Supporting Functional and OO code ==

OCaml and F#[[http://msdn.microsoft.com/en-us/library/dd233154.aspx 7]] are some of the languages which support both functional and object oriented programming. OCaml is as fast as C and its featured as [http://www.haskell.org/ Haskell] which is a pure functional language. F#[[http://oreilly.com/catalog/9780596153656 3]] is a dynamically typed language which can run on .NET framework and has supported immutable types i.e. tuples, records, discriminated unions and lists to work in Functional programming. It has functions that can either be in curried or in uncurried form. As in functional language it can pass functions as arguments to other functions, resulting in higher order functions. It also supports lambda functions and closures. F#,behaves like other .NET languages as both in imperative and object oriented style. 

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language and it is a dialect of Lisp. It is not a pure functional language and it is a dynamically typed language. Just like Java it runs on JVM platform. But its syntax differs from Java. It is represented as :

(functions arguments...)

The function followed by its arguments is enclosed in paranthesis. It has features like immutable data structures, high-order functions and recursion, easy and fast java interoperability. 

Python and Ruby are also the programming languages which offer the mix of functional and OO languages. But these languages doesn't support the algebraic data types and pattern matching.

==Conclusion ==
The above aspects of functional and object oriented programming techniques discuss some if their merits and demerits. Mixing them produces a new programming paradigm which leads to a new dimension in programming. A few fundamental concepts are explored in Clojure and Scala here. The ability of Clojure and Scala to run in JVM platform makes them more preferable than others in the market. Some of the merits like closure, less verbosity, high order functions, currying along with interoperation with previously written libraries in these languages make them more efficient and useful. There are also other languages which support functional and object oriented techniques. Mixing the approaches, evolve a new dimension in programming which is practical and opens doors to more exploration.

== References ==

# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-11T01:33:22Z

Dmcarmon: /* Mixing Functional and Object-Oriented Code in Scala */

= Introduction =

= Functional Programming =

Functional programming treats computation as the evaluation of mathematical functions. It is compute-centric rather than data-centric. Functional programming keeps no global state, does not use for or while loops, and data is immutable****. Instead, everything is done using functions, usually functions that evaluate mathematical expressions. Each of these functions maintain no internal state and will always produce the same output given the same input.

Let's look at an example. Suppose we have a list of numbers and we want to multiply each number in the list by 2. The first approach is the imperitive style:

array[] = {1,2,3,4,5}
for(i=0 ; i<array.length; i++){
array[i] = array[i] * 2;
}

In the above example, array[] is a global variable. If we fail to check the array length, then a runtime exception occurs which might result in the program being crashed. As far as functional style, there is a function called map(func,seq)(in python language) where the function 'func' is applied to each member of seq. The following code is written in a functional style.

numbers = [1,2,3,4,5]
/* define a method called compute on each number in the list */
def compute(var):
var = var * 2
return var
/* Now call the map function */
L = map(compute,numbers)
print L // L will print [1,4,6,8,10]

Notice that there is no global data nor any nested loops and the bound checking is handled internally within the map function. The programmer is relieved of of runtime errors and thus can debug the program easily.

Some advantages of this approach are:
* Easier debugging: Since every thing is broken down into small simple functions, the functions are often easy to debug.
* More compact code: Functional programming typically requires fewer lines of code. Since compution is done by function code reuse is prevelent.
* Nothing depends on state: Because functional programs keep no state information, the functions will always operate the same regardless of the past history of the program.

= Object-oriented Programming =
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] (OOP) is a programming paradigm organized around interacting "objects"(usually instances of a class) rather than "actions" and data rather than logic. A basic principle of OOP is that a program consists of a list of subroutines which can perform individually.

An object-oriented programming language provides support for the following object-oriented concepts--object, class, interface and inheritance. To illustrate this idea clearly and vividly let's review the following example-- your limbs. The "Limbs" is a class. Your body has two objects of type "limbs", named arms and legs. Their main functions are controlled/ managed by a set of biological signals sent from central nervous system( through an interface). So the nervous system is an interface which your body uses to interact with your limbs. The "limbs" is a well architected class. The "legs" has a subclass which contains "left leg" and "Right leg". The "legs" is being re-used to create the left leg and right leg by slightly changing the properties of it. If the "legs" owns attributes like length, color of skin etc, then the subclass, which contains "left leg" and "right leg" in this case, automatically inherit these attributes( that is called inheritance).

We could code in object-oriented paradigm as:

class Limbs /*define a class of limbs*/
def initialize(limbs,length,colorofskin)
@limbs=limbs
@length=length
@colorofskin=colorofskin
end
end
limbs=Limbs.new("legs","100cm","white") /*create a new object in class "Limbs"*/
class Legs<Limbs /*create a subclass "Legs",which belong to class"Limbs"*/
def initialize(legs,length,colorofskin)
super(length,colorofskin)
@legs=legs
end
end
legs=legs.new("left leg") /*create a new object in class of "Legs"*/

== Features of Object-oriented Programming ==
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]. A programmer can simply create a new object that inherits many of its features from super-class. And also, they can overwrite existing operations or add new ones.This makes object-oriented programs easier to modify.
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation].This refers to hiding the internal representation of the object from the outside view. You can hide unnecessary implementation details from the object user. One of the benefits of encapsulation is data protection.
* [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism].This allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects. Consider the operator '+', for numbers it will generate the sum, but for strings it will produce a third string which concatenates the input strings.

== Advantages of Object-oriented Programming ==
* Simplicity: we use software objects to simulate real world objects, so the complexity is reduced and the program structure is very clear.
* Modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system.
* Modifiability: programmers can easily make minor changes in the data representation or operations in an OOP. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods.
* Extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones.
* Maintainability: objects can be maintained separately, making locating and fixing problems easier.
* Re-usability: objects can be reused in different programs.

= Mixing Functional and Object-Oriented Programming =

Motivation for Mixing

== Functional Techniques useful for Object-Oriented Programming ==
In object-oriented world, data and operations are grouped together into modular units called objects and we combine objects into structured networks to form a program. The results are depend on arguments and objects' state at method invocation time. While in functional world, the basic elements are variables in the mathematical sense and functions in the mathematical sense. Functional programming can reduce side-effects. If there is no side-effects, it means your can apply the function at anywhere freely. No matter how you apply this function, the same input arguments produce the same results.

According to above-mentioned information, we can perform functional programming on an object-oriented programming language because:
1). object can have constant state
2). method can depend only on its arguments and context available at method definition time

Combining both these paradigms not only provide us a robust design structure, but also enable the programmers to develop solutions to complex problems quickly and effectively. One of the cornerstone of mixing functional and object-oriented code is treating functions as objects.It means that we can pass functions as arguments, store it and return them from other functions. This is highly useful in an user interface code where it can be used as call back functions which gets called when an event occurs(event driven programming).

Some of the basic features of Functional Programming which can be combined with Object Oriented paradigm are:

* Lambda Calculus
* Currying
* Powerful pattern matching

Let us now understand how each of the above feature of Functional language fits in the Object Oriented paradigm.

=== Lambda Calculus ===
Lambda calculus is the most critical basis of functional programming. A lambda expression is an anonymous expression that contain expressions and statements.Each expression stands for a function with one parameter.

Let consider the following function:

def f(x)
return x**2
print f(4)

We can use a lambda calculus to compute this expression without assigning it to a variable:

(lambda x:x**x)(4)

We can see that these two code snippets have the same results. It is more concise and flexible to define with lambda.
The above is a pure functional approach. In order to make code more state-less and concise, lambdas can be embedded inside the object-oriented language. The below code in Python demonstrates the use of lambda in a closure:

def fun(x):
return x%3==0
str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
filter(fun,str)

The above code works to find numbers which are divisible by 3.
We can simplify the code by the use of lambda as following:

str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print filter(lambda x: x%3==0, str)

=== Currying ===

=== Pattern Matching ===

== Examples of Mixing ==

A number of programming languages support mixing of both functional and object-oriented code. Three of these (Scala, Ruby, and Conjure), are described in more detail below.

=== Scala ===

[http://www.scala-lang.org/ Scala] is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. [http://www.scala-lang.org/ Scala] was conceived in 2001 and implemented by Martin Odersky. It supports mixing functional and object-oriented code.

==== Mixing Functional and Object-Oriented Code in Scala ====
[http://www.scala-lang.org/ Scala] is a strange specimen. It is a complete blend of object-oriented and functional programming. How can this happen? The functional world advocates immutability, but the object-oriented world focuses on the state and how to change it to fit your needs. [http://www.scala-lang.org/ Scala] allows you create both mutable and immutable objects. Consider the following example,
val str: String = "Hello World"
In the first line, an immutable version(a misnomer indeed) of <code>str</code> is being created . A rough translation into Java is below:

final String str = "Hello World"; //note the extra semi-colon
Consider the next example below,
val list: List[String] = List("Scala", "is", "the coolest", "language", "in the world!")

The same code can be written in Java as:

List<String> mutableList = new ArrayList<String>();
list.add("Scala");
list.add("is");
list.add("the coolest");
list.add("language");
list.add("in the world!");
List<String> immutableList = Collections.immutableList(mutableList);

Compared to Java, [http://www.scala-lang.org/ Scala] reduces the total number of lines you need to type and at the same time looks much simpler and less verbose. Even though the above example shows an immutable collection, scala also provides mutable collections and object types in the package <code>scala.collection.mutable.*</code>

As can be observed, even though [http://www.scala-lang.org/ Scala] advocates immutability, it does not restrict you from creating mutable objects. So it's the best of both worlds. Another part of the functional world is the concept of functions as ''''first class members'''' of the language. Some of the common languages like Ruby, Python and JavaScript all incorporate this feature. In the sense you can pass around functions to methods as a parameter. Enough talking;

Let us have a class say <code>'Person'</code> which has properties, <code>name</code> and another variable <code>age</code>.
In Java:

class Person{
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String s){
this.name = s;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}

In [http://www.scala-lang.org/ Scala]:
case class Person(name: String, age: Int)

This single line is equivalent to the above java code! Getters for <code>name</code> and <code>age</code>, <code>equals()</code>, and <code>hashCode()</code> method are automatically generated for you by the compiler. Isn't this an awesome feature?

Now assume we have a list of persons and we want to filter out all the persons who are of age 23. How would you do that in Java?

List<Person> persons; //has a bunch of person objects in it.
List<Person> twentyThree = new ArrayList<Person>();
for(Person p: persons){
if(p.getAge() == 23){
twentyThree.add(p);
}
}

In [http://www.scala-lang.org/ Scala]:

val twentyThree: List[Person] = persons.filter( _.age == 23)

That's it! In case you are wondering whats going on, filter is a method present on scala.List class and the code block <code>_.age == 23</code> is a function created on the fly and passed onto the filter method. More precisely its called a [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] - a functional concept which can be emulated in java only using anonymous inner classes. Scala's compiler transforms our one line function into some anonymous inner classes when generating java byte code, allowing developers to define functions in a simple manner.

In fact, every function is an object in [http://www.scala-lang.org/ Scala]. Scala's standard library has a number of functions which are objects themselves.

==== Implicits in Scala ====
In almost all programming languages, there is a necessity to profile the running time of the procedures and tune its performance. The old way of doing things in Java would be:

public class Main{
public static int factorial(int x){
if(x == 0 || x == 1) return 1
else return x * factorial(x-1)
}
public static void main(String [] args){
long beforeTime = System.currentTimeMillis();
int result = factorial(5);
System.out.println("Total time taken to execute factorial(5) is " + (System.currentTimeMillis() - result)+"ms");
System.out.println("factorial(5) = " + result);
}
}

However, if you want to find out the execution time of some other method, you would have to type in all the above lines again. So much for code re-use or [http://en.wikipedia.org/wiki/DRY DRY (dont't repeat yourself)]! Lets see how its done in [http://www.scala-lang.org/ Scala].

object Main{
def main(args: Array[String]){
def factorial(x: Int):Int = x match{
case 0 | 1 => 1
case _ => x * factorial(x-1)
}
import System.currentTimeMillis
def timeIt(msg: String = "Time to execute is: ")(func: => Unit){
val before = currentTimeMillis
func
println(msg + (currentTimeMillis - before) + "ms")
}
timeIt("Total time taken to execute factorial(5) is "){
val result = factorial(5)
println("factorial(5) = " + result)
}
}
//would print: factorial(5) = 120
// Total time taken to execute factorial(5) is 1ms

That's not right! The function <code>timeIt</code> looks like a feature built into the language. Try saving the above code into a separate file and run it - It will still work. Using this feature, it is possible to build powerful DSL languages which can run at full speed on JVM.

Ruby allows you to add new methods to objects. This feature is often called as [http://en.wikipedia.org/wiki/Monkey_patch Monkey Patching] because you are splitting open the class and adding/overriding methods (in)|(to) the class. Because other libraries may depend on some methods which you changed, often this leads to unexpected behavior at runtime. However, Scala provides yet another feature called [http://en.wikipedia.org/wiki/Implicit_function implicits] which helps you do this better.

In Java, <code>String</code> class is <code>final</code> so there is no way you can add new methods to it. But with implicits you can do more! Suppose you have some text in memory and you know it represents a number. But in Java the usual way to convert string to int is to do a <code>Integer.parseInt(string)</code> which seems so unnecessary. Let us make our lives easier...

implicit def strToInt(str: String) = new {
def asInt = Integer.parseInt(str)
}
val str = "1234"
println(str.asInt * 3) //prints out 3702

The above code gives us an impression as if String class has gained new <code>asInt</code> method. Can static object oriented languages do this? No! Infact scala cheats by calling our implicits to convert it into a different object as and when needed.

The above functionalities are purely object oriented, yet they are safe. They don't pollute the global namespace, unlike Ruby or Python.

=== Ruby ===

Ruby is another language that, like Scala, supports mixing functional and object-oriented code. It is a dynamically typed Object-Oriented Language which supports multiple programming paradigms, including functional, object-oriented, imperative and reflective. In Ruby, everything is an object, every bit of information and code can have its own properties and actions. However, Ruby’s blocks can be functional. A Ruby programmer can attach a closure to any method, which generates a functional block inside an object oriented code. A closure is a piece of code that can access the lexical environment of its definition [http://www.ruby-lang.org/en/ 11].

==== Ruby Mixing Example ====

Consider the following code snippet in Ruby which uses Object Oriented concepts like Classes and functional programming concepts like lambda.

class Multiply
def initialize(n)
@block = lambda {|a| n * a}
end
def mul(a)
@block.call a
end
end
twoMultiplier = Multiply.new 2
puts twoMultiplier.mul(6)

Here,'''''@block''''' is a closure. When we call the class ''Multiply'' using '''''twoAdder = Multiply.new 2''''' ,the ''initialize'' method is called by passing the parameter 2. Here n=2 binds itself to the block. So @block will be 2*a, that is,the closure remembers the parameter with which the initialize method was called even after the initialize method exits.

This value is used when the block is called in the add method.
Thus,'''''twoMultiplier.mul(6)''''' will return 2*6 = 12

==== Functional Style Coding in Ruby Blocks ====

Blocks are basically nameless functions which can be passed to a function and then that function can invoke the passed in nameless function. This is a common style called [http://en.wikipedia.org/wiki/Higher-order_function higher order functions] among languages that handle functions as first class objects. Basically blocks can be designed for loop abstraction and lets the user to design their own way of iterating the values, thereby hiding the implementation details.
For example, if we want to iterate backwards from the end to the beginning without revealing its internal implementations, we could implement the loop logic inside the block and pass it to a method or function.

Here is a [http://www.ruby-lang.org/en/ Ruby] implementation of block:

def printlist(array,&reverse)
array.each do |element|
puts "array element: #{element}"
end
reverse.call(array) /* Here it prints the reverse implementation of list*/
end

printlist([1,2,3,4,5,6]) { |array|
array.reverse.each do |element|
puts "array element: #{element}"
end
}
The statements between { } is a block and it gets called by <code>reverse.call(array)</code>within the printlist method.

=== Clojure ===

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language, and it is a dialect of Lisp. It is not a pure functional language. Instead, it is a dynamically typed language. Just like Java it runs on JVM platform, but its syntax differs from Java. It is represented as :

(functions arguments...)

The function and its arguments are enclosed in paranthesis. It has features like immutable data structures, high-order functions, recursion, and easy and fast java interoperability.

In Clojure's model, value calculation is purely functional. Values never change. New values are functions of old. But, logical identity is well supported via atomic references to values. The value of a reference (state of an identity) is always observable without coordination and freely shareable between threads.
When programs are constructed this way, functional value calculation is independent of identity-value association. This makes clojure easier to understand and test.

====Example Using Functional Technique in Clojure====

Consider the following functional programming example in Clojure-
(defn make-adder [x]
(let [y x]
(fn [z] (+ y z))))
(def add2 (make-adder 2))
(add2 4)

Here,'''''defn make-adder [x]''''' defines a function called ''make-adder''.'''''let [y x]''''' gives a local name y for the value x. Since the scope of any local names is lexical, a function created in the scope of local names will close over their values.'''''fn [z] (+ y z)''''' does the addition of y and z.
''
'''def add2 (make-adder 2)''''' calls the function ''make-adder'' passing the parameter 2 and calls this as ''add2''.Now, ''add2'' has computed 2+z. When '''''add2 4''''' is called it computes 2+4=6

====Example Using Object-Oriented Technique in Clojure====

The following program implements Run-Time Polymorphism which is an object-oriented programming concept.
(defmulti encounter (fn [x y] [(:Species x) (:Species y)]))
(defmethod encounter [:Bunny :Lion] [b l] :run-away)
(defmethod encounter [:Lion :Bunny] [l b] :eat)
(defmethod encounter [:Lion :Lion] [l1 l2] :fight)
(defmethod encounter [:Bunny :Bunny] [b1 b2] :mate)
(def b1 {:Species :Bunny :other :stuff})
(def b2 {:Species :Bunny :other :stuff})
(def l1 {:Species :Lion :other :stuff})
(def l2 {:Species :Lion :other :stuff})

(encounter b1 l1)
-> :run-away
(encounter l1 l2)
-> :fight

Here,'''''defmulti''''' is used to define multiple methods which have the same method name '''''encounter'''''.Depending on the parameters passed to the encounter method, one of the four methods is called.
'''''def''''' defines each of the different species.
When, '''''(encounter b1 l1)''''' is called, the first ''encounter'' method is called with the parameters ''Bunny'' and ''Lion''. As a result, ''run-away'' is printed.

= Conclusion =

= References =

= Mixing Functional & O-O code =

This chapter deals with the mixing of functional and object-oriented programming paradigms. We start with listing the different programming paradigms available today. We introduce functional and object-oriented approaches briefly and then discuss the advantages of one over the other. Following this, we discuss some aspects and features of mixing both the approaches. Finally, we talk about few languages that constitute such a mix.

== Programming Paradigms Today==

Several programmatic approaches to solve a particular task lead to distinct programming paradigms like, 
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
* Functional programming 
* Object Oriented programming 
* [http://en.wikipedia.org/wiki/Logic_programming Logical programming], etc. 
Lets focus on functional and object oriented programming approaches.

== Functional Programming ==

[http://en.wikipedia.org/wiki/Functional_programming Functional programming] is the task of decomposing a problem into a number of functions. Selectively executing these functions results in the solution to the problem. The functions mostly behave as mathematical. For given set of inputs the program should always return the same output. It usually concentrates on what type of problem we are dealing with rather than on the details of how to solve the problem. For example lets say there is a function which calculates area of a square. If we use it six times then we end up with area of a cube. Thus functional programming helps to build complex systems.

=== Approach ===

Expressions are the collection of variables and operations resulting in a single value this also deals with the way of solving the problem as expressions. Hence also called Expression related programming. It is structured as expression where each expression can be encapsulated in another yielding the result. Making the change in data structures as the program runs is called [http://en.wikipedia.org/wiki/Side_effect_(computer_science) side effects]. Purely functional language has no side effects. Language like Haskell is a pure functional language . Some languages need many approaches for achieving the desired result. Such languages are multi-paradigm. Examples for such languages are C++, Python,Lisp. Its like evaluating an expression and use the resulting value for something.

Structure of functional programming :

(fn2 ( fn1 ()[input list] ) []) => fn1 takes input list and the output of fn1 is used as input to fn2. Its a schematic representation of
how functional programming works.

Functional programming feature (Python) :

m = map(lambda i : i*i , numbers)
where ''numbers'' is an array of numbers and ''lambda'' is [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 closure].

Python has some functions like map, filter, reduce to support functional programming style. In the example above, the 'map' is a high-order function that takes a function and an array of numbers as input. The ''lambda'' takes i as input and returns i*i as output. Every result returned is appended to a list and produced as output. In functional programming, the programmer is given a natural framework for developing smaller, simpler, and more general modules, which are then glued together.

== Object Oriented Programming ==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] is a programming technique where everything is defined as an object. Objects are well-defined discrete bundles of data(attributes) and the associated functions(behavior). They are devised to resemble real-life objects and are uniquely identifiable by a name. The attributes could be of simple datatype(int, String, Boolean) or objects themselves. The behavior is defined by methods to use and manipulate the attributes. The values of attributes of an object at an instant is the state of the object. OO Programming allows objects to have their state retained throughout the code until manipulated otherwise. Objects are capable of housekeeping their own states, interacting and establishing relationships with other objects, inheriting, etc.

=== Fundamental concepts ===

A [http://en.wikipedia.org/wiki/Class_%28computer_science%29 class] is a user-defined datatype that provides implementation details to define the attributes and their properties. It is an abstract representation of an object(i.e.,) like a mold for objects.
An instance is an executable copy of a class. They are the actual objects created using the ‘class mold’ on run time.
Methods are a set of procedural statements or functions to define the behavior of an object, convey the current state, modify values of the attributes, etc.

Example :

An object in Java might look like this:

public class Person {
private String name;
public Person() {
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}

Here, OO Programming allows the programmer to set the ''name'' attribute of the class ''Person'' and get the name whenever needed in the code. An object of this class Person will remain in memory forever as long as there is a reference to it. As OO Programming allows objects to have their state retained, the value of the ''name'' attribute for a particular ''Person'' object remains the same across any part of the code until it is set differently.

=== Features ===

Three primary characteristics of object oriented programming are Encapsulation, Polymorphism, and Inheritance.
[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation] is the ability of objects to hide visibility of their attributes and behavior, thereby providing service independent of implementation.
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects.
[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance] is one where an existing type can be used to derive a new type. Derived types inherit the data and operations of the super-type. And also, they can overwrite existing operations or add new ones.

There are other important features of O-O programming like [http://en.wikipedia.org/wiki/Message_passing message passing], [http://en.wikipedia.org/wiki/Abstraction abstraction], delegation, etc.

Now, we have seen both the approaches and their features in brief. Lets discuss the advantages of one over the other.

== Advantages ==

=== Functional Approach over OO Approach[[http://www.jot.fm/issues/issue_2009_09/article5.pdf 8]]===
* Functional programming solves the problem with lesser number of lines of code than the OO programming style. 
* There is no side effect as they use immutable data structures also called [http://en.wikipedia.org/wiki/Persistent_data_structure Persistent Data Structure] which will have no change in the state of variables. Hence program dont have to depend on history. 
* There is no limit in the numeric types used as opposed to OO languages which mainly depend on primitive data types. 
* A programmer is given the freedom to think in terms of what to solve in the problem rather than concentrating on how to solve and the flow of the program. 
* Suitable for calculation intensive programs.

=== OO Approach over Functional Approach===
* Everything can be represented in an object and it has the attributes associated with it and hence the state of the object is known at any time. 
* A complex system can be subdivided into modules of objects where as in functional approach, many functions inter operate to form a complex system. 
* [http://en.wikipedia.org/wiki/Reusability Re-usability] (i.e.) OO approach enables programmers to create new objects that inherits many of its features from existing objects. This makes object-oriented programs easier to modify than functional. 
* [http://en.wikipedia.org/wiki/Debug Debugging] in Object Oriented environment is easy compared with functional approach where a small error in one function causes the whole system (i.e. all the functions) to fail. 
* Suitable for making application-oriented software. 

Both the approaches have their advantages and disadvantages. What if we could get the best of both the worlds? The next section deals with the aspects and features of how well both the approaches are mixed together in some languages.

== Mixing Functional & OO Code - Best of both the worlds ==

Languages that are a mix of functional and object oriented approaches(eg. Scala[[http://www.scala-lang.org/node/1305 1]], Clojure[[http://oreilly.com/catalog/9781934356333 10]], etc.) make use of best of both the worlds. They support various aspects of functional and object oriented approaches. They have a bunch of functional approach features[[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf 6]], which object oriented programming languages(like Java) lack which includes closures. Closures are first-class functions with free variables that are bound in the lexical environment. These languages also sport a very malleable syntax that makes them well suited for "domain specific languages" with the benefits of static typing. They are more expressive, extensible and allow reuse of programming abstractions.

Certain languages like Scala, Clojure, etc run on Java Virtual Machine(JVM) ensuring portability to all underlying platforms. They even support immutable objects. In Scala, new language constructs can be added in the form of libraries. They allow safe reuse[[http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf 9]] of programming abstractions and type-safe extension of software.

===Lambda===

A lambda[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] expression is an anonymous function that contain expressions and statements, and can be used to create delegates or expression types. Such kind of anonymous function can be defined and passed around as easily as other data types and can be used to contain functionality that need not be named. Some notable examples include closures[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] and currying. Lambda functions with no name can be called using the variable assigned to it.

g = lambda x: x*2
g(3)=6

We can have lambda function without assigning it to a variable which can be used as inline-function.

(lambda x: x*2)(3)

In [http://en.wikipedia.org/wiki/Clojure Clojure] as a functional language, the creation of a chunk of behavior that can be assigned to a variable (known as a lambda) is trivial. Below are two ways to create a lambda that returns the square of its argument.

(def square1 (fn [n] (* n n)))
(def square2 #(* % %))

===Currying ===

[http://en.wikipedia.org/wiki/Currying Currying] transforms a function that takes multiple parameters into a chain of functions, each taking a single parameter. It reuses a partially applied function where the function is originally defined as accepting n parameters.It can be interpreted as the technique to decompose a function that takes n parameters into n function each of them taking 1 parameter. For example to say in algebraic terms,consider the function f which takes 3 parameters x,y,z and Currying means that we can rewrite the function as a composition of 3 functions:

f(x,y,z) = 4*x+3*y+2*z
f(x)(y)(z) = 2*z+(3*y+(4*x))

In Scala, currying takes advantage of Scala’s syntactic sugar. Below is a currying example in Scala. This function creates a multiplier function which takes two arguments and partially defines it by assigning a constant to one argument and assigning it to a variable .Later the function is called by assigning the second argument.

def multiplier(i: Int)(factor: Int) = i * factor => method named multiplier which takes two parameters is defined
val byFive = multiplier(5) _ => The method is redefined with accepting one parameter and store it in a variable.
val byTen = multiplier(10) _

scala> byFive(2) => Method called by giving the second parameter.
res4: Int = 10

scala> byTen(2)
res5: Int = 20

===Less Verbosity===

In Java each variable should have its type defined beforehand. Whereas in languages like Scala, it is more concise and easier to read than the equivalent Java.

For example, a Map can be created with a simple syntax in Scala,Clojure than in Java:

<table>
<tr>
<td>
'''Java'''
Map<String, Integer> nMap = new HashMap<String, Integer>();
nMap.put("one", 1);
nMap.put("two", 2);
nMap.put("three", 3);
</td>
<td>
'''Scala'''

var nMap = Map("one" -> 1, "two" -> 2, "three" -> 3)

</td>
<td>
'''Clojure'''

(doto (new Java.util.HashMap)(.put “a” 1)(.put “b” 2))

</td>
</tr>
</table>

Here, Scala compiler knows that nMap uses Strings as keys, and Integers as values. Unlike Java, this need not be specified beforehand. Scala could figure it out itself. Moreover, Scala will give an error if a different key-value pair is tried to insert. This is called "type inference". This prevents a whole class of bugs at run time just like Java but with less verbosity.
In a similar way Clojure also involves only few lines of code compared with the object oriented Java language which takes many lines of code.A simple Clojure example and the associated Java code :
Example

(defn blank? [s] (every? #(Character/isWhitespace %) s))

The innermost function Character/isWhiteSpace checks the first argument % for any whitespace and returns true if it is. every? invoke the above inner function for all elements in the collection s.It has no variables, no branches etc.

Java code
isBlank() method checks to see whether a string is blank or contains only whitespace.

public class Stringcheck{
public static boolean isBlank(String str){
int len;
if(str==null || (strlen =str.length())==0)
return true;
for(int i=0; i<strlen;i++) {
if((Character.isWhitespace(str.charAt(i))==false)){
return false;
}
}
return true;
}
}

=== Pattern Matching ===

To say simply, a [http://en.wikipedia.org/wiki/Pattern_matching Pattern matching] is a technique to search string for the occurrence of any patterns or regularity. Pattern matching is an elegant way to decompose objects into their constituent parts for processing.Many languages support the concept of pattern matching. Perl supports pattern matching using the pattern definition mini language called regular expressions, also called regexes or REs, which is borrowed from the regular expressions used in many Unix tools, such as grep() and sed().The risk that the parts of an object might be changed outside of the control of the enclosing object is avoided. For example, if there is a Person class that contains a list of addresses, it will not be an issue to expose that list to clients if the list is immutable. The users will not be able to change the list unexpectedly.Given below is a simple example for pattern matching used in Perl:

$mystring = "Hello world!"; // Perls way of assigning string to a variable.
if($mystring =~ m/World/) { print "Yes"; } // Checks the string stored in variable mystring has the string "World".
$mystring =~ s/world/mom/; // Replaces the string "world" stored in mystring to mom.

Another sample of regular expression in java :

String mystring="Hello World" ;
Pattern str = Pattern.compile("\\w+"); => Pattern stored for matching.
Matcher fit = str.matcher(mystring); => Matcher class which perform matching of the string with the pattern defined.
if(fit.matches())

As languages like Scala and Clojure support procedural code, pattern matching is done as equal or with less difficulty compared with Java which needs to use regex. Scala can even be embedded into XML as its syntax is somewhat similar.Given below an overview of how regular expression is achieved in Clojure.
Data are manipulated in Clojure through the sequence called seq which is a logical list. Clojure can access java collections, its collections, Regular expression matches via the seq also called seq-able. Clojure's regular expression uses java.util.regex library at the lowest level. For achieving that the keyword re-seq is used.
Syntax:
(re-seq regexp string)
Example
(re-seq #"\w+" "Hello World") => ("Hello" "World") => #"\w+" represents the java.util.regex.Pattern

=== Java Interoperability ===
Considering Clojure, it gives clean, simple and direct access to java and can access Java API directly.Clojure doesnot wrap Java's string functions. We can call using Java interop forms. It provides syntax for accessing Java elements like classes, instances, constructors, methods and fields and can also wrap Java API. The “.” dot special form is used for accessing Java. Some Clojure syntax which can access Java API: 

{| class="wikitable" border="2"
|-
! Java
! Clojure
|-
| new Widget(“red”)
| (new Widget “red”)
|-
| Math.PI
| (.Math PI) or Math/PI
|-
| System.currentTimeMillis()
| (.System currentTimeMillis) or System/currentTimeMillis
|-
| rnd.nextInt()
| (.rnd nextInt) or (.nextInt rnd)
|-
|}

Clojure pass functions as arguments to other functions. But Java does not support this. So Clojure provides a member function memfn macro to wrap methods or can use anonymous function to wrap a method call.
(map (memfn toUpperCase) [“a” ,”short”,”message”])
or
(map #(.toUpperCase %)[“a”,”short”,”message”]) => #(body) represents the anonymous function in Clojure.

For example,
(def the-digits
(map #(Integer. (str %))(filter #(Character/isDigit %) (seq big-num-str))))

where (def big-num-str (str "123785334434se9088af8309304293872adbcdfd”))

The above code extracts the integers from string and discards the non-numeric characters. Lets look at the functions defined in the example. There are totally five functions defined.They are
(seq big-num-str) => get each character defined in big-num-str
(Character/isDigit %) => Checks whether the input is an integer
(filter #()) => Filter each string from str
(map #(Integer. (str %))) => Change the string to integer
(def the-digits) => Output the integers only in a string of characters.
Here,
#(Character/isDigit) represents the Java method Character.isDigit() and #(Integer.(str %)) represents the new java.lang.Integer(str(%))

Most of the Clojure library functions have defined semantics for objects of Java types. contains? and .get work on Java’s Maps, arrays, Strings, count works on Java Strings, Collections and arrays. Clojure is built around these aspects. It avails the performance of JVM and the richness of both the core APIs and the numerous third-party libraries written in the Java language and restrained from reinventing them.

=== Multiple Inheritance ===

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance][http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf 2] is the concept of using the methods and variables of more than one superclass to a sub class.Java was designed without multiple inheritance. But Java supports the solution of problems commonly solved with multiple inheritance in other ways with help of interfaces where the methods defined in it are not implemented.In Scala, classes are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance in Java.Lets see how multiple inheritance achieved in Scala:

As interfaces in Java, Scala allows traits but has some methods partially implemented. The only difference to classes is the traits may not have constructor parameters.

trait Similarity {
def isSimilar(x: Any): Boolean // not implemented
def isNotSimilar(x: Any): Boolean = !isSimilar(x) //implemented method
}

This trait defines two methods isSimilar and isNotSimilar where isSimilar does not provide a concrete method implementation (it is abstract in the terminology of Java), and the method isNotSimilar defines a concrete implementation. Consequently, classes that integrate this trait only have to provide a concrete implementation for isSimilar.

class Point(xc: Int, yc: Int) extends Similarity {
var x: Int = xc
var y: Int = yc
def isSimilar(obj: Any) = //need to implement the method here
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
}

object TraitsTest extends Application {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotSimilar(p2))
println(p1.isNotSimilar(p3)) //uses the already defined method
println(p1.isNotSimilar(2))
}

These are some of the aspects and traits of mixing functional and object-oriented approaches. As we discussed in the advantages section, both the approaches have their benefits and limitations. Mixing them aspect-wise enables the above features in such languages. Lets discuss those languages briefly in the next section.

== Languages Supporting Functional and OO code ==

OCaml and F#[[http://msdn.microsoft.com/en-us/library/dd233154.aspx 7]] are some of the languages which support both functional and object oriented programming. OCaml is as fast as C and its featured as [http://www.haskell.org/ Haskell] which is a pure functional language. F#[[http://oreilly.com/catalog/9780596153656 3]] is a dynamically typed language which can run on .NET framework and has supported immutable types i.e. tuples, records, discriminated unions and lists to work in Functional programming. It has functions that can either be in curried or in uncurried form. As in functional language it can pass functions as arguments to other functions, resulting in higher order functions. It also supports lambda functions and closures. F#,behaves like other .NET languages as both in imperative and object oriented style. 

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language and it is a dialect of Lisp. It is not a pure functional language and it is a dynamically typed language. Just like Java it runs on JVM platform. But its syntax differs from Java. It is represented as :

(functions arguments...)

The function followed by its arguments is enclosed in paranthesis. It has features like immutable data structures, high-order functions and recursion, easy and fast java interoperability. 

Python and Ruby are also the programming languages which offer the mix of functional and OO languages. But these languages doesn't support the algebraic data types and pattern matching.

==Conclusion ==
The above aspects of functional and object oriented programming techniques discuss some if their merits and demerits. Mixing them produces a new programming paradigm which leads to a new dimension in programming. A few fundamental concepts are explored in Clojure and Scala here. The ability of Clojure and Scala to run in JVM platform makes them more preferable than others in the market. Some of the merits like closure, less verbosity, high order functions, currying along with interoperation with previously written libraries in these languages make them more efficient and useful. There are also other languages which support functional and object oriented techniques. Mixing the approaches, evolve a new dimension in programming which is practical and opens doors to more exploration.

== References ==

# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-11T01:26:52Z

Dmcarmon: Deleted unrelevant sections about Scala

= Introduction =

= Functional Programming =

Functional programming treats computation as the evaluation of mathematical functions. It is compute-centric rather than data-centric. Functional programming keeps no global state, does not use for or while loops, and data is immutable****. Instead, everything is done using functions, usually functions that evaluate mathematical expressions. Each of these functions maintain no internal state and will always produce the same output given the same input.

Let's look at an example. Suppose we have a list of numbers and we want to multiply each number in the list by 2. The first approach is the imperitive style:

array[] = {1,2,3,4,5}
for(i=0 ; i<array.length; i++){
array[i] = array[i] * 2;
}

In the above example, array[] is a global variable. If we fail to check the array length, then a runtime exception occurs which might result in the program being crashed. As far as functional style, there is a function called map(func,seq)(in python language) where the function 'func' is applied to each member of seq. The following code is written in a functional style.

numbers = [1,2,3,4,5]
/* define a method called compute on each number in the list */
def compute(var):
var = var * 2
return var
/* Now call the map function */
L = map(compute,numbers)
print L // L will print [1,4,6,8,10]

Notice that there is no global data nor any nested loops and the bound checking is handled internally within the map function. The programmer is relieved of of runtime errors and thus can debug the program easily.

Some advantages of this approach are:
* Easier debugging: Since every thing is broken down into small simple functions, the functions are often easy to debug.
* More compact code: Functional programming typically requires fewer lines of code. Since compution is done by function code reuse is prevelent.
* Nothing depends on state: Because functional programs keep no state information, the functions will always operate the same regardless of the past history of the program.

= Object-oriented Programming =
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] (OOP) is a programming paradigm organized around interacting "objects"(usually instances of a class) rather than "actions" and data rather than logic. A basic principle of OOP is that a program consists of a list of subroutines which can perform individually.

An object-oriented programming language provides support for the following object-oriented concepts--object, class, interface and inheritance. To illustrate this idea clearly and vividly let's review the following example-- your limbs. The "Limbs" is a class. Your body has two objects of type "limbs", named arms and legs. Their main functions are controlled/ managed by a set of biological signals sent from central nervous system( through an interface). So the nervous system is an interface which your body uses to interact with your limbs. The "limbs" is a well architected class. The "legs" has a subclass which contains "left leg" and "Right leg". The "legs" is being re-used to create the left leg and right leg by slightly changing the properties of it. If the "legs" owns attributes like length, color of skin etc, then the subclass, which contains "left leg" and "right leg" in this case, automatically inherit these attributes( that is called inheritance).

We could code in object-oriented paradigm as:

class Limbs /*define a class of limbs*/
def initialize(limbs,length,colorofskin)
@limbs=limbs
@length=length
@colorofskin=colorofskin
end
end
limbs=Limbs.new("legs","100cm","white") /*create a new object in class "Limbs"*/
class Legs<Limbs /*create a subclass "Legs",which belong to class"Limbs"*/
def initialize(legs,length,colorofskin)
super(length,colorofskin)
@legs=legs
end
end
legs=legs.new("left leg") /*create a new object in class of "Legs"*/

== Features of Object-oriented Programming ==
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]. A programmer can simply create a new object that inherits many of its features from super-class. And also, they can overwrite existing operations or add new ones.This makes object-oriented programs easier to modify.
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation].This refers to hiding the internal representation of the object from the outside view. You can hide unnecessary implementation details from the object user. One of the benefits of encapsulation is data protection.
* [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism].This allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects. Consider the operator '+', for numbers it will generate the sum, but for strings it will produce a third string which concatenates the input strings.

== Advantages of Object-oriented Programming ==
* Simplicity: we use software objects to simulate real world objects, so the complexity is reduced and the program structure is very clear.
* Modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system.
* Modifiability: programmers can easily make minor changes in the data representation or operations in an OOP. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods.
* Extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones.
* Maintainability: objects can be maintained separately, making locating and fixing problems easier.
* Re-usability: objects can be reused in different programs.

= Mixing Functional and Object-Oriented Programming =

Motivation for Mixing

== Functional Techniques useful for Object-Oriented Programming ==
In object-oriented world, data and operations are grouped together into modular units called objects and we combine objects into structured networks to form a program. The results are depend on arguments and objects' state at method invocation time. While in functional world, the basic elements are variables in the mathematical sense and functions in the mathematical sense. Functional programming can reduce side-effects. If there is no side-effects, it means your can apply the function at anywhere freely. No matter how you apply this function, the same input arguments produce the same results.

According to above-mentioned information, we can perform functional programming on an object-oriented programming language because:
1). object can have constant state
2). method can depend only on its arguments and context available at method definition time

Combining both these paradigms not only provide us a robust design structure, but also enable the programmers to develop solutions to complex problems quickly and effectively. One of the cornerstone of mixing functional and object-oriented code is treating functions as objects.It means that we can pass functions as arguments, store it and return them from other functions. This is highly useful in an user interface code where it can be used as call back functions which gets called when an event occurs(event driven programming).

Some of the basic features of Functional Programming which can be combined with Object Oriented paradigm are:

* Lambda Calculus
* Currying
* Powerful pattern matching

Let us now understand how each of the above feature of Functional language fits in the Object Oriented paradigm.

=== Lambda Calculus ===
Lambda calculus is the most critical basis of functional programming. A lambda expression is an anonymous expression that contain expressions and statements.Each expression stands for a function with one parameter.

Let consider the following function:

def f(x)
return x**2
print f(4)

We can use a lambda calculus to compute this expression without assigning it to a variable:

(lambda x:x**x)(4)

We can see that these two code snippets have the same results. It is more concise and flexible to define with lambda.
The above is a pure functional approach. In order to make code more state-less and concise, lambdas can be embedded inside the object-oriented language. The below code in Python demonstrates the use of lambda in a closure:

def fun(x):
return x%3==0
str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
filter(fun,str)

The above code works to find numbers which are divisible by 3.
We can simplify the code by the use of lambda as following:

str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print filter(lambda x: x%3==0, str)

=== Currying ===

=== Pattern Matching ===

== Examples of Mixing ==

A number of programming languages support mixing of both functional and object-oriented code. Three of these (Scala, Ruby, and Conjure), are described in more detail below.

=== Scala ===

[http://www.scala-lang.org/ Scala] is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. [http://www.scala-lang.org/ Scala] was conceived in 2001 and implemented by Martin Odersky. It supports mixing functional and object-oriented code.

==== Mixing Functional and Object-Oriented Code in Scala ====
[http://www.scala-lang.org/ Scala] is a strange specimen. It is a complete blend of object-oriented and functional programming. How can this happen? Functional world advocates immutability but object oriented world is all about state and how do you mutate it to fit your needs. [http://www.scala-lang.org/ Scala] allows you create both mutable and immutable objects. Consider the following example,
val str: String = "Hello World"
In the first line, an immutable version(a misnomer indeed) of <code>str</code> is being created . Roughly translating the above line to Java is below:

final String str = "Hello World"; //note the extra semi-colon
Consider the next example below,
val list: List[String] = List("Scala", "is", "the coolest", "language", "in the world!")

The same code can be written in Java as below

List<String> mutableList = new ArrayList<String>();
list.add("Scala");
list.add("is");
list.add("the coolest");
list.add("language");
list.add("in the world!");
List<String> immutableList = Collections.immutableList(mutableList);

Compared to Java, [http://www.scala-lang.org/ Scala] reduces the total number of lines you need to type and at the same time looks so much simpler and less verbose. Even though the above example shows immutable collection example, scala also provides mutable collection and object types under the package <code>scala.collection.mutable.*</code>

As it can be observed, even though [http://www.scala-lang.org/ Scala] advocates immutability, it does not restrict you from creating mutable objects. So its the best of both worlds. Another part of functional world is the concept of functions as ''''first class members'''' of the language. Some of the common languages like Ruby, Python and JavaScript all incorporate this feature. In the sense you can pass around functions to methods as a parameter. Enough talking;

Let us have a class say <code>'Person'</code> which has properties, <code>name</code> and another variable <code>age</code>.
In Java:

class Person{
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String s){
this.name = s;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}

In [http://www.scala-lang.org/ Scala]:
case class Person(name: String, age: Int)

This single line is equivalent to the above java code! Getters for <code>name</code> and <code>age</code>, <code>equals()</code>, and <code>hashCode()</code> method are automatically generated for you by the compiler. Isn't this an awesome feature?

Now assume we have a list of persons and we want to filter out all the persons who are of age 23. How would you do that in Java?

List<Person> persons; //has a bunch of person objects in it.
List<Person> twentyThree = new ArrayList<Person>();
for(Person p: persons){
if(p.getAge() == 23){
twentyThree.add(p);
}
}

In [http://www.scala-lang.org/ Scala]:

val twentyThree: List[Person] = persons.filter( _.age == 23)

That's it! In case you are wondering whats going on, filter is a method present on scala.List class and the code block <code>_.age == 23</code> is a function created on the fly and passed onto the filter method. More precisely its called a [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] - a functional concept which can be emulated in java only using anonymous inner classes. Scala's compiler transforms our one line function into some anonymous inner classes when generating java byte code, allowing developers to define functions in a simple manner.

In fact, every function is an object in [http://www.scala-lang.org/ Scala]. Scala's standard library has a number of functions which are objects themselves.

==== Implicits in Scala ====
In almost all programming languages, there is a necessity to profile the running time of the procedures and tune its performance. The old way of doing things in Java would be:

public class Main{
public static int factorial(int x){
if(x == 0 || x == 1) return 1
else return x * factorial(x-1)
}
public static void main(String [] args){
long beforeTime = System.currentTimeMillis();
int result = factorial(5);
System.out.println("Total time taken to execute factorial(5) is " + (System.currentTimeMillis() - result)+"ms");
System.out.println("factorial(5) = " + result);
}
}

However, if you want to find out the execution time of some other method, you would have to type in all the above lines again. So much for code re-use or [http://en.wikipedia.org/wiki/DRY DRY (dont't repeat yourself)]! Lets see how its done in [http://www.scala-lang.org/ Scala].

object Main{
def main(args: Array[String]){
def factorial(x: Int):Int = x match{
case 0 | 1 => 1
case _ => x * factorial(x-1)
}
import System.currentTimeMillis
def timeIt(msg: String = "Time to execute is: ")(func: => Unit){
val before = currentTimeMillis
func
println(msg + (currentTimeMillis - before) + "ms")
}
timeIt("Total time taken to execute factorial(5) is "){
val result = factorial(5)
println("factorial(5) = " + result)
}
}
//would print: factorial(5) = 120
// Total time taken to execute factorial(5) is 1ms

That's not right! The function <code>timeIt</code> looks like a feature built into the language. Try saving the above code into a separate file and run it - It will still work. Using this feature, it is possible to build powerful DSL languages which can run at full speed on JVM.

Ruby allows you to add new methods to objects. This feature is often called as [http://en.wikipedia.org/wiki/Monkey_patch Monkey Patching] because you are splitting open the class and adding/overriding methods (in)|(to) the class. Because other libraries may depend on some methods which you changed, often this leads to unexpected behavior at runtime. However, Scala provides yet another feature called [http://en.wikipedia.org/wiki/Implicit_function implicits] which helps you do this better.

In Java, <code>String</code> class is <code>final</code> so there is no way you can add new methods to it. But with implicits you can do more! Suppose you have some text in memory and you know it represents a number. But in Java the usual way to convert string to int is to do a <code>Integer.parseInt(string)</code> which seems so unnecessary. Let us make our lives easier...

implicit def strToInt(str: String) = new {
def asInt = Integer.parseInt(str)
}
val str = "1234"
println(str.asInt * 3) //prints out 3702

The above code gives us an impression as if String class has gained new <code>asInt</code> method. Can static object oriented languages do this? No! Infact scala cheats by calling our implicits to convert it into a different object as and when needed.

The above functionalities are purely object oriented, yet they are safe. They don't pollute the global namespace, unlike Ruby or Python.

=== Ruby ===

Ruby is another language that, like Scala, supports mixing functional and object-oriented code. It is a dynamically typed Object-Oriented Language which supports multiple programming paradigms, including functional, object-oriented, imperative and reflective. In Ruby, everything is an object, every bit of information and code can have its own properties and actions. However, Ruby’s blocks can be functional. A Ruby programmer can attach a closure to any method, which generates a functional block inside an object oriented code. A closure is a piece of code that can access the lexical environment of its definition [http://www.ruby-lang.org/en/ 11].

==== Ruby Mixing Example ====

Consider the following code snippet in Ruby which uses Object Oriented concepts like Classes and functional programming concepts like lambda.

class Multiply
def initialize(n)
@block = lambda {|a| n * a}
end
def mul(a)
@block.call a
end
end
twoMultiplier = Multiply.new 2
puts twoMultiplier.mul(6)

Here,'''''@block''''' is a closure. When we call the class ''Multiply'' using '''''twoAdder = Multiply.new 2''''' ,the ''initialize'' method is called by passing the parameter 2. Here n=2 binds itself to the block. So @block will be 2*a, that is,the closure remembers the parameter with which the initialize method was called even after the initialize method exits.

This value is used when the block is called in the add method.
Thus,'''''twoMultiplier.mul(6)''''' will return 2*6 = 12

==== Functional Style Coding in Ruby Blocks ====

Blocks are basically nameless functions which can be passed to a function and then that function can invoke the passed in nameless function. This is a common style called [http://en.wikipedia.org/wiki/Higher-order_function higher order functions] among languages that handle functions as first class objects. Basically blocks can be designed for loop abstraction and lets the user to design their own way of iterating the values, thereby hiding the implementation details.
For example, if we want to iterate backwards from the end to the beginning without revealing its internal implementations, we could implement the loop logic inside the block and pass it to a method or function.

Here is a [http://www.ruby-lang.org/en/ Ruby] implementation of block:

def printlist(array,&reverse)
array.each do |element|
puts "array element: #{element}"
end
reverse.call(array) /* Here it prints the reverse implementation of list*/
end

printlist([1,2,3,4,5,6]) { |array|
array.reverse.each do |element|
puts "array element: #{element}"
end
}
The statements between { } is a block and it gets called by <code>reverse.call(array)</code>within the printlist method.

=== Clojure ===

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language, and it is a dialect of Lisp. It is not a pure functional language. Instead, it is a dynamically typed language. Just like Java it runs on JVM platform, but its syntax differs from Java. It is represented as :

(functions arguments...)

The function and its arguments are enclosed in paranthesis. It has features like immutable data structures, high-order functions, recursion, and easy and fast java interoperability.

In Clojure's model, value calculation is purely functional. Values never change. New values are functions of old. But, logical identity is well supported via atomic references to values. The value of a reference (state of an identity) is always observable without coordination and freely shareable between threads.
When programs are constructed this way, functional value calculation is independent of identity-value association. This makes clojure easier to understand and test.

====Example Using Functional Technique in Clojure====

Consider the following functional programming example in Clojure-
(defn make-adder [x]
(let [y x]
(fn [z] (+ y z))))
(def add2 (make-adder 2))
(add2 4)

Here,'''''defn make-adder [x]''''' defines a function called ''make-adder''.'''''let [y x]''''' gives a local name y for the value x. Since the scope of any local names is lexical, a function created in the scope of local names will close over their values.'''''fn [z] (+ y z)''''' does the addition of y and z.
''
'''def add2 (make-adder 2)''''' calls the function ''make-adder'' passing the parameter 2 and calls this as ''add2''.Now, ''add2'' has computed 2+z. When '''''add2 4''''' is called it computes 2+4=6

====Example Using Object-Oriented Technique in Clojure====

The following program implements Run-Time Polymorphism which is an object-oriented programming concept.
(defmulti encounter (fn [x y] [(:Species x) (:Species y)]))
(defmethod encounter [:Bunny :Lion] [b l] :run-away)
(defmethod encounter [:Lion :Bunny] [l b] :eat)
(defmethod encounter [:Lion :Lion] [l1 l2] :fight)
(defmethod encounter [:Bunny :Bunny] [b1 b2] :mate)
(def b1 {:Species :Bunny :other :stuff})
(def b2 {:Species :Bunny :other :stuff})
(def l1 {:Species :Lion :other :stuff})
(def l2 {:Species :Lion :other :stuff})

(encounter b1 l1)
-> :run-away
(encounter l1 l2)
-> :fight

Here,'''''defmulti''''' is used to define multiple methods which have the same method name '''''encounter'''''.Depending on the parameters passed to the encounter method, one of the four methods is called.
'''''def''''' defines each of the different species.
When, '''''(encounter b1 l1)''''' is called, the first ''encounter'' method is called with the parameters ''Bunny'' and ''Lion''. As a result, ''run-away'' is printed.

= Conclusion =

= References =

= Mixing Functional & O-O code =

This chapter deals with the mixing of functional and object-oriented programming paradigms. We start with listing the different programming paradigms available today. We introduce functional and object-oriented approaches briefly and then discuss the advantages of one over the other. Following this, we discuss some aspects and features of mixing both the approaches. Finally, we talk about few languages that constitute such a mix.

== Programming Paradigms Today==

Several programmatic approaches to solve a particular task lead to distinct programming paradigms like, 
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
* Functional programming 
* Object Oriented programming 
* [http://en.wikipedia.org/wiki/Logic_programming Logical programming], etc. 
Lets focus on functional and object oriented programming approaches.

== Functional Programming ==

[http://en.wikipedia.org/wiki/Functional_programming Functional programming] is the task of decomposing a problem into a number of functions. Selectively executing these functions results in the solution to the problem. The functions mostly behave as mathematical. For given set of inputs the program should always return the same output. It usually concentrates on what type of problem we are dealing with rather than on the details of how to solve the problem. For example lets say there is a function which calculates area of a square. If we use it six times then we end up with area of a cube. Thus functional programming helps to build complex systems.

=== Approach ===

Expressions are the collection of variables and operations resulting in a single value this also deals with the way of solving the problem as expressions. Hence also called Expression related programming. It is structured as expression where each expression can be encapsulated in another yielding the result. Making the change in data structures as the program runs is called [http://en.wikipedia.org/wiki/Side_effect_(computer_science) side effects]. Purely functional language has no side effects. Language like Haskell is a pure functional language . Some languages need many approaches for achieving the desired result. Such languages are multi-paradigm. Examples for such languages are C++, Python,Lisp. Its like evaluating an expression and use the resulting value for something.

Structure of functional programming :

(fn2 ( fn1 ()[input list] ) []) => fn1 takes input list and the output of fn1 is used as input to fn2. Its a schematic representation of
how functional programming works.

Functional programming feature (Python) :

m = map(lambda i : i*i , numbers)
where ''numbers'' is an array of numbers and ''lambda'' is [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 closure].

Python has some functions like map, filter, reduce to support functional programming style. In the example above, the 'map' is a high-order function that takes a function and an array of numbers as input. The ''lambda'' takes i as input and returns i*i as output. Every result returned is appended to a list and produced as output. In functional programming, the programmer is given a natural framework for developing smaller, simpler, and more general modules, which are then glued together.

== Object Oriented Programming ==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] is a programming technique where everything is defined as an object. Objects are well-defined discrete bundles of data(attributes) and the associated functions(behavior). They are devised to resemble real-life objects and are uniquely identifiable by a name. The attributes could be of simple datatype(int, String, Boolean) or objects themselves. The behavior is defined by methods to use and manipulate the attributes. The values of attributes of an object at an instant is the state of the object. OO Programming allows objects to have their state retained throughout the code until manipulated otherwise. Objects are capable of housekeeping their own states, interacting and establishing relationships with other objects, inheriting, etc.

=== Fundamental concepts ===

A [http://en.wikipedia.org/wiki/Class_%28computer_science%29 class] is a user-defined datatype that provides implementation details to define the attributes and their properties. It is an abstract representation of an object(i.e.,) like a mold for objects.
An instance is an executable copy of a class. They are the actual objects created using the ‘class mold’ on run time.
Methods are a set of procedural statements or functions to define the behavior of an object, convey the current state, modify values of the attributes, etc.

Example :

An object in Java might look like this:

public class Person {
private String name;
public Person() {
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}

Here, OO Programming allows the programmer to set the ''name'' attribute of the class ''Person'' and get the name whenever needed in the code. An object of this class Person will remain in memory forever as long as there is a reference to it. As OO Programming allows objects to have their state retained, the value of the ''name'' attribute for a particular ''Person'' object remains the same across any part of the code until it is set differently.

=== Features ===

Three primary characteristics of object oriented programming are Encapsulation, Polymorphism, and Inheritance.
[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation] is the ability of objects to hide visibility of their attributes and behavior, thereby providing service independent of implementation.
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects.
[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance] is one where an existing type can be used to derive a new type. Derived types inherit the data and operations of the super-type. And also, they can overwrite existing operations or add new ones.

There are other important features of O-O programming like [http://en.wikipedia.org/wiki/Message_passing message passing], [http://en.wikipedia.org/wiki/Abstraction abstraction], delegation, etc.

Now, we have seen both the approaches and their features in brief. Lets discuss the advantages of one over the other.

== Advantages ==

=== Functional Approach over OO Approach[[http://www.jot.fm/issues/issue_2009_09/article5.pdf 8]]===
* Functional programming solves the problem with lesser number of lines of code than the OO programming style. 
* There is no side effect as they use immutable data structures also called [http://en.wikipedia.org/wiki/Persistent_data_structure Persistent Data Structure] which will have no change in the state of variables. Hence program dont have to depend on history. 
* There is no limit in the numeric types used as opposed to OO languages which mainly depend on primitive data types. 
* A programmer is given the freedom to think in terms of what to solve in the problem rather than concentrating on how to solve and the flow of the program. 
* Suitable for calculation intensive programs.

=== OO Approach over Functional Approach===
* Everything can be represented in an object and it has the attributes associated with it and hence the state of the object is known at any time. 
* A complex system can be subdivided into modules of objects where as in functional approach, many functions inter operate to form a complex system. 
* [http://en.wikipedia.org/wiki/Reusability Re-usability] (i.e.) OO approach enables programmers to create new objects that inherits many of its features from existing objects. This makes object-oriented programs easier to modify than functional. 
* [http://en.wikipedia.org/wiki/Debug Debugging] in Object Oriented environment is easy compared with functional approach where a small error in one function causes the whole system (i.e. all the functions) to fail. 
* Suitable for making application-oriented software. 

Both the approaches have their advantages and disadvantages. What if we could get the best of both the worlds? The next section deals with the aspects and features of how well both the approaches are mixed together in some languages.

== Mixing Functional & OO Code - Best of both the worlds ==

Languages that are a mix of functional and object oriented approaches(eg. Scala[[http://www.scala-lang.org/node/1305 1]], Clojure[[http://oreilly.com/catalog/9781934356333 10]], etc.) make use of best of both the worlds. They support various aspects of functional and object oriented approaches. They have a bunch of functional approach features[[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf 6]], which object oriented programming languages(like Java) lack which includes closures. Closures are first-class functions with free variables that are bound in the lexical environment. These languages also sport a very malleable syntax that makes them well suited for "domain specific languages" with the benefits of static typing. They are more expressive, extensible and allow reuse of programming abstractions.

Certain languages like Scala, Clojure, etc run on Java Virtual Machine(JVM) ensuring portability to all underlying platforms. They even support immutable objects. In Scala, new language constructs can be added in the form of libraries. They allow safe reuse[[http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf 9]] of programming abstractions and type-safe extension of software.

===Lambda===

A lambda[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] expression is an anonymous function that contain expressions and statements, and can be used to create delegates or expression types. Such kind of anonymous function can be defined and passed around as easily as other data types and can be used to contain functionality that need not be named. Some notable examples include closures[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] and currying. Lambda functions with no name can be called using the variable assigned to it.

g = lambda x: x*2
g(3)=6

We can have lambda function without assigning it to a variable which can be used as inline-function.

(lambda x: x*2)(3)

In [http://en.wikipedia.org/wiki/Clojure Clojure] as a functional language, the creation of a chunk of behavior that can be assigned to a variable (known as a lambda) is trivial. Below are two ways to create a lambda that returns the square of its argument.

(def square1 (fn [n] (* n n)))
(def square2 #(* % %))

===Currying ===

[http://en.wikipedia.org/wiki/Currying Currying] transforms a function that takes multiple parameters into a chain of functions, each taking a single parameter. It reuses a partially applied function where the function is originally defined as accepting n parameters.It can be interpreted as the technique to decompose a function that takes n parameters into n function each of them taking 1 parameter. For example to say in algebraic terms,consider the function f which takes 3 parameters x,y,z and Currying means that we can rewrite the function as a composition of 3 functions:

f(x,y,z) = 4*x+3*y+2*z
f(x)(y)(z) = 2*z+(3*y+(4*x))

In Scala, currying takes advantage of Scala’s syntactic sugar. Below is a currying example in Scala. This function creates a multiplier function which takes two arguments and partially defines it by assigning a constant to one argument and assigning it to a variable .Later the function is called by assigning the second argument.

def multiplier(i: Int)(factor: Int) = i * factor => method named multiplier which takes two parameters is defined
val byFive = multiplier(5) _ => The method is redefined with accepting one parameter and store it in a variable.
val byTen = multiplier(10) _

scala> byFive(2) => Method called by giving the second parameter.
res4: Int = 10

scala> byTen(2)
res5: Int = 20

===Less Verbosity===

In Java each variable should have its type defined beforehand. Whereas in languages like Scala, it is more concise and easier to read than the equivalent Java.

For example, a Map can be created with a simple syntax in Scala,Clojure than in Java:

<table>
<tr>
<td>
'''Java'''
Map<String, Integer> nMap = new HashMap<String, Integer>();
nMap.put("one", 1);
nMap.put("two", 2);
nMap.put("three", 3);
</td>
<td>
'''Scala'''

var nMap = Map("one" -> 1, "two" -> 2, "three" -> 3)

</td>
<td>
'''Clojure'''

(doto (new Java.util.HashMap)(.put “a” 1)(.put “b” 2))

</td>
</tr>
</table>

Here, Scala compiler knows that nMap uses Strings as keys, and Integers as values. Unlike Java, this need not be specified beforehand. Scala could figure it out itself. Moreover, Scala will give an error if a different key-value pair is tried to insert. This is called "type inference". This prevents a whole class of bugs at run time just like Java but with less verbosity.
In a similar way Clojure also involves only few lines of code compared with the object oriented Java language which takes many lines of code.A simple Clojure example and the associated Java code :
Example

(defn blank? [s] (every? #(Character/isWhitespace %) s))

The innermost function Character/isWhiteSpace checks the first argument % for any whitespace and returns true if it is. every? invoke the above inner function for all elements in the collection s.It has no variables, no branches etc.

Java code
isBlank() method checks to see whether a string is blank or contains only whitespace.

public class Stringcheck{
public static boolean isBlank(String str){
int len;
if(str==null || (strlen =str.length())==0)
return true;
for(int i=0; i<strlen;i++) {
if((Character.isWhitespace(str.charAt(i))==false)){
return false;
}
}
return true;
}
}

=== Pattern Matching ===

To say simply, a [http://en.wikipedia.org/wiki/Pattern_matching Pattern matching] is a technique to search string for the occurrence of any patterns or regularity. Pattern matching is an elegant way to decompose objects into their constituent parts for processing.Many languages support the concept of pattern matching. Perl supports pattern matching using the pattern definition mini language called regular expressions, also called regexes or REs, which is borrowed from the regular expressions used in many Unix tools, such as grep() and sed().The risk that the parts of an object might be changed outside of the control of the enclosing object is avoided. For example, if there is a Person class that contains a list of addresses, it will not be an issue to expose that list to clients if the list is immutable. The users will not be able to change the list unexpectedly.Given below is a simple example for pattern matching used in Perl:

$mystring = "Hello world!"; // Perls way of assigning string to a variable.
if($mystring =~ m/World/) { print "Yes"; } // Checks the string stored in variable mystring has the string "World".
$mystring =~ s/world/mom/; // Replaces the string "world" stored in mystring to mom.

Another sample of regular expression in java :

String mystring="Hello World" ;
Pattern str = Pattern.compile("\\w+"); => Pattern stored for matching.
Matcher fit = str.matcher(mystring); => Matcher class which perform matching of the string with the pattern defined.
if(fit.matches())

As languages like Scala and Clojure support procedural code, pattern matching is done as equal or with less difficulty compared with Java which needs to use regex. Scala can even be embedded into XML as its syntax is somewhat similar.Given below an overview of how regular expression is achieved in Clojure.
Data are manipulated in Clojure through the sequence called seq which is a logical list. Clojure can access java collections, its collections, Regular expression matches via the seq also called seq-able. Clojure's regular expression uses java.util.regex library at the lowest level. For achieving that the keyword re-seq is used.
Syntax:
(re-seq regexp string)
Example
(re-seq #"\w+" "Hello World") => ("Hello" "World") => #"\w+" represents the java.util.regex.Pattern

=== Java Interoperability ===
Considering Clojure, it gives clean, simple and direct access to java and can access Java API directly.Clojure doesnot wrap Java's string functions. We can call using Java interop forms. It provides syntax for accessing Java elements like classes, instances, constructors, methods and fields and can also wrap Java API. The “.” dot special form is used for accessing Java. Some Clojure syntax which can access Java API: 

{| class="wikitable" border="2"
|-
! Java
! Clojure
|-
| new Widget(“red”)
| (new Widget “red”)
|-
| Math.PI
| (.Math PI) or Math/PI
|-
| System.currentTimeMillis()
| (.System currentTimeMillis) or System/currentTimeMillis
|-
| rnd.nextInt()
| (.rnd nextInt) or (.nextInt rnd)
|-
|}

Clojure pass functions as arguments to other functions. But Java does not support this. So Clojure provides a member function memfn macro to wrap methods or can use anonymous function to wrap a method call.
(map (memfn toUpperCase) [“a” ,”short”,”message”])
or
(map #(.toUpperCase %)[“a”,”short”,”message”]) => #(body) represents the anonymous function in Clojure.

For example,
(def the-digits
(map #(Integer. (str %))(filter #(Character/isDigit %) (seq big-num-str))))

where (def big-num-str (str "123785334434se9088af8309304293872adbcdfd”))

The above code extracts the integers from string and discards the non-numeric characters. Lets look at the functions defined in the example. There are totally five functions defined.They are
(seq big-num-str) => get each character defined in big-num-str
(Character/isDigit %) => Checks whether the input is an integer
(filter #()) => Filter each string from str
(map #(Integer. (str %))) => Change the string to integer
(def the-digits) => Output the integers only in a string of characters.
Here,
#(Character/isDigit) represents the Java method Character.isDigit() and #(Integer.(str %)) represents the new java.lang.Integer(str(%))

Most of the Clojure library functions have defined semantics for objects of Java types. contains? and .get work on Java’s Maps, arrays, Strings, count works on Java Strings, Collections and arrays. Clojure is built around these aspects. It avails the performance of JVM and the richness of both the core APIs and the numerous third-party libraries written in the Java language and restrained from reinventing them.

=== Multiple Inheritance ===

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance][http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf 2] is the concept of using the methods and variables of more than one superclass to a sub class.Java was designed without multiple inheritance. But Java supports the solution of problems commonly solved with multiple inheritance in other ways with help of interfaces where the methods defined in it are not implemented.In Scala, classes are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance in Java.Lets see how multiple inheritance achieved in Scala:

As interfaces in Java, Scala allows traits but has some methods partially implemented. The only difference to classes is the traits may not have constructor parameters.

trait Similarity {
def isSimilar(x: Any): Boolean // not implemented
def isNotSimilar(x: Any): Boolean = !isSimilar(x) //implemented method
}

This trait defines two methods isSimilar and isNotSimilar where isSimilar does not provide a concrete method implementation (it is abstract in the terminology of Java), and the method isNotSimilar defines a concrete implementation. Consequently, classes that integrate this trait only have to provide a concrete implementation for isSimilar.

class Point(xc: Int, yc: Int) extends Similarity {
var x: Int = xc
var y: Int = yc
def isSimilar(obj: Any) = //need to implement the method here
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
}

object TraitsTest extends Application {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotSimilar(p2))
println(p1.isNotSimilar(p3)) //uses the already defined method
println(p1.isNotSimilar(2))
}

These are some of the aspects and traits of mixing functional and object-oriented approaches. As we discussed in the advantages section, both the approaches have their benefits and limitations. Mixing them aspect-wise enables the above features in such languages. Lets discuss those languages briefly in the next section.

== Languages Supporting Functional and OO code ==

OCaml and F#[[http://msdn.microsoft.com/en-us/library/dd233154.aspx 7]] are some of the languages which support both functional and object oriented programming. OCaml is as fast as C and its featured as [http://www.haskell.org/ Haskell] which is a pure functional language. F#[[http://oreilly.com/catalog/9780596153656 3]] is a dynamically typed language which can run on .NET framework and has supported immutable types i.e. tuples, records, discriminated unions and lists to work in Functional programming. It has functions that can either be in curried or in uncurried form. As in functional language it can pass functions as arguments to other functions, resulting in higher order functions. It also supports lambda functions and closures. F#,behaves like other .NET languages as both in imperative and object oriented style. 

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language and it is a dialect of Lisp. It is not a pure functional language and it is a dynamically typed language. Just like Java it runs on JVM platform. But its syntax differs from Java. It is represented as :

(functions arguments...)

The function followed by its arguments is enclosed in paranthesis. It has features like immutable data structures, high-order functions and recursion, easy and fast java interoperability. 

Python and Ruby are also the programming languages which offer the mix of functional and OO languages. But these languages doesn't support the algebraic data types and pattern matching.

==Conclusion ==
The above aspects of functional and object oriented programming techniques discuss some if their merits and demerits. Mixing them produces a new programming paradigm which leads to a new dimension in programming. A few fundamental concepts are explored in Clojure and Scala here. The ability of Clojure and Scala to run in JVM platform makes them more preferable than others in the market. Some of the merits like closure, less verbosity, high order functions, currying along with interoperation with previously written libraries in these languages make them more efficient and useful. There are also other languages which support functional and object oriented techniques. Mixing the approaches, evolve a new dimension in programming which is practical and opens doors to more exploration.

== References ==

# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-11T01:18:02Z

Dmcarmon: Added Clojure Section and corrected grammar.

= Introduction =

= Functional Programming =

Functional programming treats computation as the evaluation of mathematical functions. It is compute-centric rather than data-centric. Functional programming keeps no global state, does not use for or while loops, and data is immutable****. Instead, everything is done using functions, usually functions that evaluate mathematical expressions. Each of these functions maintain no internal state and will always produce the same output given the same input.

Let's look at an example. Suppose we have a list of numbers and we want to multiply each number in the list by 2. The first approach is the imperitive style:

array[] = {1,2,3,4,5}
for(i=0 ; i<array.length; i++){
array[i] = array[i] * 2;
}

In the above example, array[] is a global variable. If we fail to check the array length, then a runtime exception occurs which might result in the program being crashed. As far as functional style, there is a function called map(func,seq)(in python language) where the function 'func' is applied to each member of seq. The following code is written in a functional style.

numbers = [1,2,3,4,5]
/* define a method called compute on each number in the list */
def compute(var):
var = var * 2
return var
/* Now call the map function */
L = map(compute,numbers)
print L // L will print [1,4,6,8,10]

Notice that there is no global data nor any nested loops and the bound checking is handled internally within the map function. The programmer is relieved of of runtime errors and thus can debug the program easily.

Some advantages of this approach are:
* Easier debugging: Since every thing is broken down into small simple functions, the functions are often easy to debug.
* More compact code: Functional programming typically requires fewer lines of code. Since compution is done by function code reuse is prevelent.
* Nothing depends on state: Because functional programs keep no state information, the functions will always operate the same regardless of the past history of the program.

= Object-oriented Programming =
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] (OOP) is a programming paradigm organized around interacting "objects"(usually instances of a class) rather than "actions" and data rather than logic. A basic principle of OOP is that a program consists of a list of subroutines which can perform individually.

An object-oriented programming language provides support for the following object-oriented concepts--object, class, interface and inheritance. To illustrate this idea clearly and vividly let's review the following example-- your limbs. The "Limbs" is a class. Your body has two objects of type "limbs", named arms and legs. Their main functions are controlled/ managed by a set of biological signals sent from central nervous system( through an interface). So the nervous system is an interface which your body uses to interact with your limbs. The "limbs" is a well architected class. The "legs" has a subclass which contains "left leg" and "Right leg". The "legs" is being re-used to create the left leg and right leg by slightly changing the properties of it. If the "legs" owns attributes like length, color of skin etc, then the subclass, which contains "left leg" and "right leg" in this case, automatically inherit these attributes( that is called inheritance).

We could code in object-oriented paradigm as:

class Limbs /*define a class of limbs*/
def initialize(limbs,length,colorofskin)
@limbs=limbs
@length=length
@colorofskin=colorofskin
end
end
limbs=Limbs.new("legs","100cm","white") /*create a new object in class "Limbs"*/
class Legs<Limbs /*create a subclass "Legs",which belong to class"Limbs"*/
def initialize(legs,length,colorofskin)
super(length,colorofskin)
@legs=legs
end
end
legs=legs.new("left leg") /*create a new object in class of "Legs"*/

== Features of Object-oriented Programming ==
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]. A programmer can simply create a new object that inherits many of its features from super-class. And also, they can overwrite existing operations or add new ones.This makes object-oriented programs easier to modify.
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation].This refers to hiding the internal representation of the object from the outside view. You can hide unnecessary implementation details from the object user. One of the benefits of encapsulation is data protection.
* [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism].This allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects. Consider the operator '+', for numbers it will generate the sum, but for strings it will produce a third string which concatenates the input strings.

== Advantages of Object-oriented Programming ==
* Simplicity: we use software objects to simulate real world objects, so the complexity is reduced and the program structure is very clear.
* Modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system.
* Modifiability: programmers can easily make minor changes in the data representation or operations in an OOP. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods.
* Extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones.
* Maintainability: objects can be maintained separately, making locating and fixing problems easier.
* Re-usability: objects can be reused in different programs.

= Mixing Functional and Object-Oriented Programming =

Motivation for Mixing

== Functional Techniques useful for Object-Oriented Programming ==
In object-oriented world, data and operations are grouped together into modular units called objects and we combine objects into structured networks to form a program. The results are depend on arguments and objects' state at method invocation time. While in functional world, the basic elements are variables in the mathematical sense and functions in the mathematical sense. Functional programming can reduce side-effects. If there is no side-effects, it means your can apply the function at anywhere freely. No matter how you apply this function, the same input arguments produce the same results.

According to above-mentioned information, we can perform functional programming on an object-oriented programming language because:
1). object can have constant state
2). method can depend only on its arguments and context available at method definition time

Combining both these paradigms not only provide us a robust design structure, but also enable the programmers to develop solutions to complex problems quickly and effectively. One of the cornerstone of mixing functional and object-oriented code is treating functions as objects.It means that we can pass functions as arguments, store it and return them from other functions. This is highly useful in an user interface code where it can be used as call back functions which gets called when an event occurs(event driven programming).

Some of the basic features of Functional Programming which can be combined with Object Oriented paradigm are:

* Lambda Calculus
* Currying
* Powerful pattern matching

Let us now understand how each of the above feature of Functional language fits in the Object Oriented paradigm.

=== Lambda Calculus ===
Lambda calculus is the most critical basis of functional programming. A lambda expression is an anonymous expression that contain expressions and statements.Each expression stands for a function with one parameter.

Let consider the following function:

def f(x)
return x**2
print f(4)

We can use a lambda calculus to compute this expression without assigning it to a variable:

(lambda x:x**x)(4)

We can see that these two code snippets have the same results. It is more concise and flexible to define with lambda.
The above is a pure functional approach. In order to make code more state-less and concise, lambdas can be embedded inside the object-oriented language. The below code in Python demonstrates the use of lambda in a closure:

def fun(x):
return x%3==0
str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
filter(fun,str)

The above code works to find numbers which are divisible by 3.
We can simplify the code by the use of lambda as following:

str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print filter(lambda x: x%3==0, str)

=== Currying ===

=== Pattern Matching ===

== Examples of Mixing ==

A number of programming languages support mixing of both functional and object-oriented code. Three of these (Scala, Ruby, and Conjure), are described in more detail below.

=== Scala ===

[http://www.scala-lang.org/ Scala] is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. [http://www.scala-lang.org/ Scala] was conceived in 2001 and implemented by Martin Odersky. It has a number of features.

==== Statically Typed ====
[http://www.scala-lang.org/ Scala] belongs to the family of languages which encode the type information of each and every variable in the generated code. The compiler makes sure you are not doing something incorrectly. For example, lets consider the following example of code where the type is not encoded,

In [http://www.ruby-lang.org/en/ Ruby],
irb(main):001:0> str="Hello World"
=> "Hello World"
irb(main):002:0> puts str.class
String
irb(main):003:0> str=123
=> 123
irb(main):004:0> puts str.class
Fixnum

In the above example, first we define 'str' variable to be of type String and then as a number. So basically, no type information is associated with the variable at any point in the program. Hence we can easily reassociate that variable with an object/instance
of a different type. This is a feature of all dynamically typed languages(like Ruby, Python, Clojure). However most of the statically typed languages such as Scala, Java, C/C++ do not allow you do so. In [http://www.scala-lang.org/ Scala],

scala> var str="Hello World"
str: java.lang.String = Hello World
scala> str=123
<console>:6: error: type mismatch;
found : Int(123)
required: java.lang.String
str=123

==== Mixed paradigm ====
[http://www.scala-lang.org/ Scala] is a strange specimen. It is a complete blend of object oriented and functional programming. How can this happen? Functional world advocates immutability but object oriented world is all about state and how do you mutate it to fit your needs. [http://www.scala-lang.org/ Scala] allows you create both mutable and immutable objects. Consider the following example,
val str: String = "Hello World"
In the first line, an immutable version(a misnomer indeed) of <code>str</code> is being created . Roughly translating the above line to Java is below:

final String str = "Hello World"; //note the extra semi-colon
Consider the next example below,
val list: List[String] = List("Scala", "is", "the coolest", "language", "in the world!")

The same code can be written in Java as below

List<String> mutableList = new ArrayList<String>();
list.add("Scala");
list.add("is");
list.add("the coolest");
list.add("language");
list.add("in the world!");
List<String> immutableList = Collections.immutableList(mutableList);

Compared to Java, [http://www.scala-lang.org/ Scala] reduces the total number of lines you need to type and at the same time looks so much simpler and less verbose. Even though the above example shows immutable collection example, scala also provides mutable collection and object types under the package <code>scala.collection.mutable.*</code>

As it can be observed, even though [http://www.scala-lang.org/ Scala] advocates immutability, it does not restrict you from creating mutable objects. So its the best of both worlds. Another part of functional world is the concept of functions as ''''first class members'''' of the language. Some of the common languages like Ruby, Python and JavaScript all incorporate this feature. In the sense you can pass around functions to methods as a parameter. Enough talking;

Let us have a class say <code>'Person'</code> which has properties, <code>name</code> and another variable <code>age</code>.
In Java:

class Person{
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String s){
this.name = s;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}

In [http://www.scala-lang.org/ Scala]:
case class Person(name: String, age: Int)

This single line is equivalent to the above java code! Getters for <code>name</code> and <code>age</code>, <code>equals()</code>, and <code>hashCode()</code> method are automatically generated for you by the compiler. Isn't this an awesome feature?

Now assume we have a list of persons and we want to filter out all the persons who are of age 23. How would you do that in Java?

List<Person> persons; //has a bunch of person objects in it.
List<Person> twentyThree = new ArrayList<Person>();
for(Person p: persons){
if(p.getAge() == 23){
twentyThree.add(p);
}
}

In [http://www.scala-lang.org/ Scala]:

val twentyThree: List[Person] = persons.filter( _.age == 23)

That's it! In case you are wondering whats going on, filter is a method present on scala.List class and the code block <code>_.age == 23</code> is a function created on the fly and passed onto the filter method. More precisely its called a [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] - a functional concept which can be emulated in java only using anonymous inner classes. Scala's compiler transforms our one line function into some anonymous inner classes when generating java byte code, allowing developers to define functions in a simple manner.

In fact, every function is an object in [http://www.scala-lang.org/ Scala]. Scala's standard library has a number of functions which are objects themselves.

==== Sophisticated Syntax/Features ====
Sophisticated syntax and features are present in other functional languages like Haskell, (O)Caml and Erlang. Consider the following example,

val name = "Jackie Chan"
println(name.getClass) //prints out String.

Previously we saw that [http://www.scala-lang.org/ Scala] is a statically typed language and yet in the above example we don't specify what type <code>name</code> is. In Java, you would type in the following:

String name = "Jackie Chan"

In Java you specify what type the name variable is, but the [http://www.scala-lang.org/ scala] compiler can automatically detect the type of the variable even if you don't specify it. Consider the following example,

case class Person(name: String, age: Int)
val persons = List(
Person("Jackie Chan", 51), Person("Jet Li", 41),
Person("RajniKanth", 51), Person("Kamal Hasan", 44),
Person("Martin Odersky", 18), Person("Steve Yegge", 23))
//notice that you don't have to use 'new' keyword to create new instances. This is taken care of by the companion objects.

The above lines of code create a list with 6 different persons(An immutable list)

Now, just like ruby, scala supports the concepts of [http://en.wikipedia.org/wiki/Closure_(computer_science) closure]. Let's see what it is.

val twentyThree: List[Person] = persons.filter( { p: Person => p.age == 3})

In the above set of lines, the code within the '{ }' brackets is a function's body. The compiler created a function which takes a single argument and returns either true or false.

==== A Scalable Language ====
In almost all programming languages, there is a necessity to profile the running time of the procedures and tune its performance. The old way of doing things in Java would be:

public class Main{
public static int factorial(int x){
if(x == 0 || x == 1) return 1
else return x * factorial(x-1)
}
public static void main(String [] args){
long beforeTime = System.currentTimeMillis();
int result = factorial(5);
System.out.println("Total time taken to execute factorial(5) is " + (System.currentTimeMillis() - result)+"ms");
System.out.println("factorial(5) = " + result);
}
}

However, if you want to find out the execution time of some other method, you would have to type in all the above lines again. So much for code re-use or [http://en.wikipedia.org/wiki/DRY DRY (dont't repeat yourself)]! Lets see how its done in [http://www.scala-lang.org/ Scala].

object Main{
def main(args: Array[String]){
def factorial(x: Int):Int = x match{
case 0 | 1 => 1
case _ => x * factorial(x-1)
}
import System.currentTimeMillis
def timeIt(msg: String = "Time to execute is: ")(func: => Unit){
val before = currentTimeMillis
func
println(msg + (currentTimeMillis - before) + "ms")
}
timeIt("Total time taken to execute factorial(5) is "){
val result = factorial(5)
println("factorial(5) = " + result)
}
}
//would print: factorial(5) = 120
// Total time taken to execute factorial(5) is 1ms

That's not right! The function <code>timeIt</code> looks like a feature built into the language. Try saving the above code into a separate file and run it - It will still work. Using this feature, it is possible to build powerful DSL languages which can run at full speed on JVM.

Ruby allows you to add new methods to objects. This feature is often called as [http://en.wikipedia.org/wiki/Monkey_patch Monkey Patching] because you are splitting open the class and adding/overriding methods (in)|(to) the class. Because other libraries may depend on some methods which you changed, often this leads to unexpected behavior at runtime. However, Scala provides yet another feature called implicits which helps you do this better.

In Java, <code>String</code> class is <code>final</code> so there is no way you can add new methods to it. But with implicits you can do more! Suppose you have some text in memory and you know it represents a number. But in Java the usual way to convert string to int is to do a <code>Integer.parseInt(string)</code> which seems so unnecessary. Let us make our lives easier...

implicit def strToInt(str: String) = new {
def asInt = Integer.parseInt(str)
}
val str = "1234"
println(str.asInt * 3) //prints out 3702

The above code gives us an impression as if String class has gained new <code>asInt</code> method. Can static object oriented languages do this? No! Infact scala cheats by calling our implicits to convert it into a different object as and when needed.

The above functionalities are purely object oriented, yet they are safe. They don't pollute the global namespace, unlike Ruby or Python.

=== Ruby ===

Ruby is another language that, like Scala, supports mixing functional and object-oriented code. It is a dynamically typed Object-Oriented Language which supports multiple programming paradigms, including functional, object-oriented, imperative and reflective. In Ruby, everything is an object, every bit of information and code can have its own properties and actions. However, Ruby’s blocks can be functional. A Ruby programmer can attach a closure to any method, which generates a functional block inside an object oriented code. A closure is a piece of code that can access the lexical environment of its definition [http://www.ruby-lang.org/en/ 11].

==== Ruby Mixing Example ====

Consider the following code snippet in Ruby which uses Object Oriented concepts like Classes and functional programming concepts like lambda.

class Multiply
def initialize(n)
@block = lambda {|a| n * a}
end
def mul(a)
@block.call a
end
end
twoMultiplier = Multiply.new 2
puts twoMultiplier.mul(6)

Here,'''''@block''''' is a closure. When we call the class ''Multiply'' using '''''twoAdder = Multiply.new 2''''' ,the ''initialize'' method is called by passing the parameter 2. Here n=2 binds itself to the block. So @block will be 2*a, that is,the closure remembers the parameter with which the initialize method was called even after the initialize method exits.

This value is used when the block is called in the add method.
Thus,'''''twoMultiplier.mul(6)''''' will return 2*6 = 12

==== Functional Style Coding in Ruby Blocks ====

Blocks are basically nameless functions which can be passed to a function and then that function can invoke the passed in nameless function. This is a common style called [http://en.wikipedia.org/wiki/Higher-order_function higher order functions] among languages that handle functions as first class objects. Basically blocks can be designed for loop abstraction and lets the user to design their own way of iterating the values, thereby hiding the implementation details.
For example, if we want to iterate backwards from the end to the beginning without revealing its internal implementations, we could implement the loop logic inside the block and pass it to a method or function.

Here is a [http://www.ruby-lang.org/en/ Ruby] implementation of block:

def printlist(array,&reverse)
array.each do |element|
puts "array element: #{element}"
end
reverse.call(array) /* Here it prints the reverse implementation of list*/
end

printlist([1,2,3,4,5,6]) { |array|
array.reverse.each do |element|
puts "array element: #{element}"
end
}
The statements between { } is a block and it gets called by <code>reverse.call(array)</code>within the printlist method.

=== Clojure ===

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language, and it is a dialect of Lisp. It is not a pure functional language. Instead, it is a dynamically typed language. Just like Java it runs on JVM platform, but its syntax differs from Java. It is represented as :

(functions arguments...)

The function and its arguments are enclosed in paranthesis. It has features like immutable data structures, high-order functions, recursion, and easy and fast java interoperability.

In Clojure's model, value calculation is purely functional. Values never change. New values are functions of old. But, logical identity is well supported via atomic references to values. The value of a reference (state of an identity) is always observable without coordination and freely shareable between threads.
When programs are constructed this way, functional value calculation is independent of identity-value association. This makes clojure easier to understand and test.

====Example Using Function Technique in Clojure====

Consider the following functional programming example in Clojure-
(defn make-adder [x]
(let [y x]
(fn [z] (+ y z))))
(def add2 (make-adder 2))
(add2 4)

Here,'''''defn make-adder [x]''''' defines a function called ''make-adder''.'''''let [y x]''''' gives a local name y for the value x. Since the scope of any local names is lexical, a function created in the scope of local names will close over their values.'''''fn [z] (+ y z)''''' does the addition of y and z.
''
'''def add2 (make-adder 2)''''' calls the function ''make-adder'' passing the parameter 2 and calls this as ''add2''.Now, ''add2'' has computed 2+z. When '''''add2 4''''' is called it computes 2+4=6

====Example Using Object-Oriented Technique in Clojure====

The following program implements Run-Time Polymorphism which is an object-oriented programming concept.
(defmulti encounter (fn [x y] [(:Species x) (:Species y)]))
(defmethod encounter [:Bunny :Lion] [b l] :run-away)
(defmethod encounter [:Lion :Bunny] [l b] :eat)
(defmethod encounter [:Lion :Lion] [l1 l2] :fight)
(defmethod encounter [:Bunny :Bunny] [b1 b2] :mate)
(def b1 {:Species :Bunny :other :stuff})
(def b2 {:Species :Bunny :other :stuff})
(def l1 {:Species :Lion :other :stuff})
(def l2 {:Species :Lion :other :stuff})

(encounter b1 l1)
-> :run-away
(encounter l1 l2)
-> :fight

Here,'''''defmulti''''' is used to define multiple methods which have the same method name '''''encounter'''''.Depending on the parameters passed to the encounter method, one of the four methods is called.
'''''def''''' defines each of the different species.
When, '''''(encounter b1 l1)''''' is called, the first ''encounter'' method is called with the parameters ''Bunny'' and ''Lion''. As a result, ''run-away'' is printed.

= Conclusion =

= References =

= Mixing Functional & O-O code =

This chapter deals with the mixing of functional and object-oriented programming paradigms. We start with listing the different programming paradigms available today. We introduce functional and object-oriented approaches briefly and then discuss the advantages of one over the other. Following this, we discuss some aspects and features of mixing both the approaches. Finally, we talk about few languages that constitute such a mix.

== Programming Paradigms Today==

Several programmatic approaches to solve a particular task lead to distinct programming paradigms like, 
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
* Functional programming 
* Object Oriented programming 
* [http://en.wikipedia.org/wiki/Logic_programming Logical programming], etc. 
Lets focus on functional and object oriented programming approaches.

== Functional Programming ==

[http://en.wikipedia.org/wiki/Functional_programming Functional programming] is the task of decomposing a problem into a number of functions. Selectively executing these functions results in the solution to the problem. The functions mostly behave as mathematical. For given set of inputs the program should always return the same output. It usually concentrates on what type of problem we are dealing with rather than on the details of how to solve the problem. For example lets say there is a function which calculates area of a square. If we use it six times then we end up with area of a cube. Thus functional programming helps to build complex systems.

=== Approach ===

Expressions are the collection of variables and operations resulting in a single value this also deals with the way of solving the problem as expressions. Hence also called Expression related programming. It is structured as expression where each expression can be encapsulated in another yielding the result. Making the change in data structures as the program runs is called [http://en.wikipedia.org/wiki/Side_effect_(computer_science) side effects]. Purely functional language has no side effects. Language like Haskell is a pure functional language . Some languages need many approaches for achieving the desired result. Such languages are multi-paradigm. Examples for such languages are C++, Python,Lisp. Its like evaluating an expression and use the resulting value for something.

Structure of functional programming :

(fn2 ( fn1 ()[input list] ) []) => fn1 takes input list and the output of fn1 is used as input to fn2. Its a schematic representation of
how functional programming works.

Functional programming feature (Python) :

m = map(lambda i : i*i , numbers)
where ''numbers'' is an array of numbers and ''lambda'' is [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 closure].

Python has some functions like map, filter, reduce to support functional programming style. In the example above, the 'map' is a high-order function that takes a function and an array of numbers as input. The ''lambda'' takes i as input and returns i*i as output. Every result returned is appended to a list and produced as output. In functional programming, the programmer is given a natural framework for developing smaller, simpler, and more general modules, which are then glued together.

== Object Oriented Programming ==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] is a programming technique where everything is defined as an object. Objects are well-defined discrete bundles of data(attributes) and the associated functions(behavior). They are devised to resemble real-life objects and are uniquely identifiable by a name. The attributes could be of simple datatype(int, String, Boolean) or objects themselves. The behavior is defined by methods to use and manipulate the attributes. The values of attributes of an object at an instant is the state of the object. OO Programming allows objects to have their state retained throughout the code until manipulated otherwise. Objects are capable of housekeeping their own states, interacting and establishing relationships with other objects, inheriting, etc.

=== Fundamental concepts ===

A [http://en.wikipedia.org/wiki/Class_%28computer_science%29 class] is a user-defined datatype that provides implementation details to define the attributes and their properties. It is an abstract representation of an object(i.e.,) like a mold for objects.
An instance is an executable copy of a class. They are the actual objects created using the ‘class mold’ on run time.
Methods are a set of procedural statements or functions to define the behavior of an object, convey the current state, modify values of the attributes, etc.

Example :

An object in Java might look like this:

public class Person {
private String name;
public Person() {
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}

Here, OO Programming allows the programmer to set the ''name'' attribute of the class ''Person'' and get the name whenever needed in the code. An object of this class Person will remain in memory forever as long as there is a reference to it. As OO Programming allows objects to have their state retained, the value of the ''name'' attribute for a particular ''Person'' object remains the same across any part of the code until it is set differently.

=== Features ===

Three primary characteristics of object oriented programming are Encapsulation, Polymorphism, and Inheritance.
[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation] is the ability of objects to hide visibility of their attributes and behavior, thereby providing service independent of implementation.
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects.
[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance] is one where an existing type can be used to derive a new type. Derived types inherit the data and operations of the super-type. And also, they can overwrite existing operations or add new ones.

There are other important features of O-O programming like [http://en.wikipedia.org/wiki/Message_passing message passing], [http://en.wikipedia.org/wiki/Abstraction abstraction], delegation, etc.

Now, we have seen both the approaches and their features in brief. Lets discuss the advantages of one over the other.

== Advantages ==

=== Functional Approach over OO Approach[[http://www.jot.fm/issues/issue_2009_09/article5.pdf 8]]===
* Functional programming solves the problem with lesser number of lines of code than the OO programming style. 
* There is no side effect as they use immutable data structures also called [http://en.wikipedia.org/wiki/Persistent_data_structure Persistent Data Structure] which will have no change in the state of variables. Hence program dont have to depend on history. 
* There is no limit in the numeric types used as opposed to OO languages which mainly depend on primitive data types. 
* A programmer is given the freedom to think in terms of what to solve in the problem rather than concentrating on how to solve and the flow of the program. 
* Suitable for calculation intensive programs.

=== OO Approach over Functional Approach===
* Everything can be represented in an object and it has the attributes associated with it and hence the state of the object is known at any time. 
* A complex system can be subdivided into modules of objects where as in functional approach, many functions inter operate to form a complex system. 
* [http://en.wikipedia.org/wiki/Reusability Re-usability] (i.e.) OO approach enables programmers to create new objects that inherits many of its features from existing objects. This makes object-oriented programs easier to modify than functional. 
* [http://en.wikipedia.org/wiki/Debug Debugging] in Object Oriented environment is easy compared with functional approach where a small error in one function causes the whole system (i.e. all the functions) to fail. 
* Suitable for making application-oriented software. 

Both the approaches have their advantages and disadvantages. What if we could get the best of both the worlds? The next section deals with the aspects and features of how well both the approaches are mixed together in some languages.

== Mixing Functional & OO Code - Best of both the worlds ==

Languages that are a mix of functional and object oriented approaches(eg. Scala[[http://www.scala-lang.org/node/1305 1]], Clojure[[http://oreilly.com/catalog/9781934356333 10]], etc.) make use of best of both the worlds. They support various aspects of functional and object oriented approaches. They have a bunch of functional approach features[[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf 6]], which object oriented programming languages(like Java) lack which includes closures. Closures are first-class functions with free variables that are bound in the lexical environment. These languages also sport a very malleable syntax that makes them well suited for "domain specific languages" with the benefits of static typing. They are more expressive, extensible and allow reuse of programming abstractions.

Certain languages like Scala, Clojure, etc run on Java Virtual Machine(JVM) ensuring portability to all underlying platforms. They even support immutable objects. In Scala, new language constructs can be added in the form of libraries. They allow safe reuse[[http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf 9]] of programming abstractions and type-safe extension of software.

===Lambda===

A lambda[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] expression is an anonymous function that contain expressions and statements, and can be used to create delegates or expression types. Such kind of anonymous function can be defined and passed around as easily as other data types and can be used to contain functionality that need not be named. Some notable examples include closures[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] and currying. Lambda functions with no name can be called using the variable assigned to it.

g = lambda x: x*2
g(3)=6

We can have lambda function without assigning it to a variable which can be used as inline-function.

(lambda x: x*2)(3)

In [http://en.wikipedia.org/wiki/Clojure Clojure] as a functional language, the creation of a chunk of behavior that can be assigned to a variable (known as a lambda) is trivial. Below are two ways to create a lambda that returns the square of its argument.

(def square1 (fn [n] (* n n)))
(def square2 #(* % %))

===Currying ===

[http://en.wikipedia.org/wiki/Currying Currying] transforms a function that takes multiple parameters into a chain of functions, each taking a single parameter. It reuses a partially applied function where the function is originally defined as accepting n parameters.It can be interpreted as the technique to decompose a function that takes n parameters into n function each of them taking 1 parameter. For example to say in algebraic terms,consider the function f which takes 3 parameters x,y,z and Currying means that we can rewrite the function as a composition of 3 functions:

f(x,y,z) = 4*x+3*y+2*z
f(x)(y)(z) = 2*z+(3*y+(4*x))

In Scala, currying takes advantage of Scala’s syntactic sugar. Below is a currying example in Scala. This function creates a multiplier function which takes two arguments and partially defines it by assigning a constant to one argument and assigning it to a variable .Later the function is called by assigning the second argument.

def multiplier(i: Int)(factor: Int) = i * factor => method named multiplier which takes two parameters is defined
val byFive = multiplier(5) _ => The method is redefined with accepting one parameter and store it in a variable.
val byTen = multiplier(10) _

scala> byFive(2) => Method called by giving the second parameter.
res4: Int = 10

scala> byTen(2)
res5: Int = 20

===Less Verbosity===

In Java each variable should have its type defined beforehand. Whereas in languages like Scala, it is more concise and easier to read than the equivalent Java.

For example, a Map can be created with a simple syntax in Scala,Clojure than in Java:

<table>
<tr>
<td>
'''Java'''
Map<String, Integer> nMap = new HashMap<String, Integer>();
nMap.put("one", 1);
nMap.put("two", 2);
nMap.put("three", 3);
</td>
<td>
'''Scala'''

var nMap = Map("one" -> 1, "two" -> 2, "three" -> 3)

</td>
<td>
'''Clojure'''

(doto (new Java.util.HashMap)(.put “a” 1)(.put “b” 2))

</td>
</tr>
</table>

Here, Scala compiler knows that nMap uses Strings as keys, and Integers as values. Unlike Java, this need not be specified beforehand. Scala could figure it out itself. Moreover, Scala will give an error if a different key-value pair is tried to insert. This is called "type inference". This prevents a whole class of bugs at run time just like Java but with less verbosity.
In a similar way Clojure also involves only few lines of code compared with the object oriented Java language which takes many lines of code.A simple Clojure example and the associated Java code :
Example

(defn blank? [s] (every? #(Character/isWhitespace %) s))

The innermost function Character/isWhiteSpace checks the first argument % for any whitespace and returns true if it is. every? invoke the above inner function for all elements in the collection s.It has no variables, no branches etc.

Java code
isBlank() method checks to see whether a string is blank or contains only whitespace.

public class Stringcheck{
public static boolean isBlank(String str){
int len;
if(str==null || (strlen =str.length())==0)
return true;
for(int i=0; i<strlen;i++) {
if((Character.isWhitespace(str.charAt(i))==false)){
return false;
}
}
return true;
}
}

=== Pattern Matching ===

To say simply, a [http://en.wikipedia.org/wiki/Pattern_matching Pattern matching] is a technique to search string for the occurrence of any patterns or regularity. Pattern matching is an elegant way to decompose objects into their constituent parts for processing.Many languages support the concept of pattern matching. Perl supports pattern matching using the pattern definition mini language called regular expressions, also called regexes or REs, which is borrowed from the regular expressions used in many Unix tools, such as grep() and sed().The risk that the parts of an object might be changed outside of the control of the enclosing object is avoided. For example, if there is a Person class that contains a list of addresses, it will not be an issue to expose that list to clients if the list is immutable. The users will not be able to change the list unexpectedly.Given below is a simple example for pattern matching used in Perl:

$mystring = "Hello world!"; // Perls way of assigning string to a variable.
if($mystring =~ m/World/) { print "Yes"; } // Checks the string stored in variable mystring has the string "World".
$mystring =~ s/world/mom/; // Replaces the string "world" stored in mystring to mom.

Another sample of regular expression in java :

String mystring="Hello World" ;
Pattern str = Pattern.compile("\\w+"); => Pattern stored for matching.
Matcher fit = str.matcher(mystring); => Matcher class which perform matching of the string with the pattern defined.
if(fit.matches())

As languages like Scala and Clojure support procedural code, pattern matching is done as equal or with less difficulty compared with Java which needs to use regex. Scala can even be embedded into XML as its syntax is somewhat similar.Given below an overview of how regular expression is achieved in Clojure.
Data are manipulated in Clojure through the sequence called seq which is a logical list. Clojure can access java collections, its collections, Regular expression matches via the seq also called seq-able. Clojure's regular expression uses java.util.regex library at the lowest level. For achieving that the keyword re-seq is used.
Syntax:
(re-seq regexp string)
Example
(re-seq #"\w+" "Hello World") => ("Hello" "World") => #"\w+" represents the java.util.regex.Pattern

=== Java Interoperability ===
Considering Clojure, it gives clean, simple and direct access to java and can access Java API directly.Clojure doesnot wrap Java's string functions. We can call using Java interop forms. It provides syntax for accessing Java elements like classes, instances, constructors, methods and fields and can also wrap Java API. The “.” dot special form is used for accessing Java. Some Clojure syntax which can access Java API: 

{| class="wikitable" border="2"
|-
! Java
! Clojure
|-
| new Widget(“red”)
| (new Widget “red”)
|-
| Math.PI
| (.Math PI) or Math/PI
|-
| System.currentTimeMillis()
| (.System currentTimeMillis) or System/currentTimeMillis
|-
| rnd.nextInt()
| (.rnd nextInt) or (.nextInt rnd)
|-
|}

Clojure pass functions as arguments to other functions. But Java does not support this. So Clojure provides a member function memfn macro to wrap methods or can use anonymous function to wrap a method call.
(map (memfn toUpperCase) [“a” ,”short”,”message”])
or
(map #(.toUpperCase %)[“a”,”short”,”message”]) => #(body) represents the anonymous function in Clojure.

For example,
(def the-digits
(map #(Integer. (str %))(filter #(Character/isDigit %) (seq big-num-str))))

where (def big-num-str (str "123785334434se9088af8309304293872adbcdfd”))

The above code extracts the integers from string and discards the non-numeric characters. Lets look at the functions defined in the example. There are totally five functions defined.They are
(seq big-num-str) => get each character defined in big-num-str
(Character/isDigit %) => Checks whether the input is an integer
(filter #()) => Filter each string from str
(map #(Integer. (str %))) => Change the string to integer
(def the-digits) => Output the integers only in a string of characters.
Here,
#(Character/isDigit) represents the Java method Character.isDigit() and #(Integer.(str %)) represents the new java.lang.Integer(str(%))

Most of the Clojure library functions have defined semantics for objects of Java types. contains? and .get work on Java’s Maps, arrays, Strings, count works on Java Strings, Collections and arrays. Clojure is built around these aspects. It avails the performance of JVM and the richness of both the core APIs and the numerous third-party libraries written in the Java language and restrained from reinventing them.

=== Multiple Inheritance ===

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance][http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf 2] is the concept of using the methods and variables of more than one superclass to a sub class.Java was designed without multiple inheritance. But Java supports the solution of problems commonly solved with multiple inheritance in other ways with help of interfaces where the methods defined in it are not implemented.In Scala, classes are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance in Java.Lets see how multiple inheritance achieved in Scala:

As interfaces in Java, Scala allows traits but has some methods partially implemented. The only difference to classes is the traits may not have constructor parameters.

trait Similarity {
def isSimilar(x: Any): Boolean // not implemented
def isNotSimilar(x: Any): Boolean = !isSimilar(x) //implemented method
}

This trait defines two methods isSimilar and isNotSimilar where isSimilar does not provide a concrete method implementation (it is abstract in the terminology of Java), and the method isNotSimilar defines a concrete implementation. Consequently, classes that integrate this trait only have to provide a concrete implementation for isSimilar.

class Point(xc: Int, yc: Int) extends Similarity {
var x: Int = xc
var y: Int = yc
def isSimilar(obj: Any) = //need to implement the method here
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
}

object TraitsTest extends Application {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotSimilar(p2))
println(p1.isNotSimilar(p3)) //uses the already defined method
println(p1.isNotSimilar(2))
}

These are some of the aspects and traits of mixing functional and object-oriented approaches. As we discussed in the advantages section, both the approaches have their benefits and limitations. Mixing them aspect-wise enables the above features in such languages. Lets discuss those languages briefly in the next section.

== Languages Supporting Functional and OO code ==

OCaml and F#[[http://msdn.microsoft.com/en-us/library/dd233154.aspx 7]] are some of the languages which support both functional and object oriented programming. OCaml is as fast as C and its featured as [http://www.haskell.org/ Haskell] which is a pure functional language. F#[[http://oreilly.com/catalog/9780596153656 3]] is a dynamically typed language which can run on .NET framework and has supported immutable types i.e. tuples, records, discriminated unions and lists to work in Functional programming. It has functions that can either be in curried or in uncurried form. As in functional language it can pass functions as arguments to other functions, resulting in higher order functions. It also supports lambda functions and closures. F#,behaves like other .NET languages as both in imperative and object oriented style. 

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language and it is a dialect of Lisp. It is not a pure functional language and it is a dynamically typed language. Just like Java it runs on JVM platform. But its syntax differs from Java. It is represented as :

(functions arguments...)

The function followed by its arguments is enclosed in paranthesis. It has features like immutable data structures, high-order functions and recursion, easy and fast java interoperability. 

Python and Ruby are also the programming languages which offer the mix of functional and OO languages. But these languages doesn't support the algebraic data types and pattern matching.

==Conclusion ==
The above aspects of functional and object oriented programming techniques discuss some if their merits and demerits. Mixing them produces a new programming paradigm which leads to a new dimension in programming. A few fundamental concepts are explored in Clojure and Scala here. The ability of Clojure and Scala to run in JVM platform makes them more preferable than others in the market. Some of the merits like closure, less verbosity, high order functions, currying along with interoperation with previously written libraries in these languages make them more efficient and useful. There are also other languages which support functional and object oriented techniques. Mixing the approaches, evolve a new dimension in programming which is practical and opens doors to more exploration.

== References ==

# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-09T22:41:11Z

Dmcarmon: /* Ruby */

= Introduction =

= Functional Programming =

Functional programming treats computation as the evaluation of mathematical functions. It is compute-centric rather than data-centric. Functional programming keeps no global state, does not use for or while loops, and data is immutable****. Instead, everything is done using functions, usually functions that evaluate mathematical expressions. Each of these functions maintain no internal state and will always produce the same output given the same input.

Let's look at an example. Suppose we have a list of numbers and we want to multiply each number in the list by 2. The first approach is the imperitive style:

array[] = {1,2,3,4,5}
for(i=0 ; i<array.length; i++){
array[i] = array[i] * 2;
}

In the above example, array[] is a global variable. If we fail to check the array length, then a runtime exception occurs which might result in the program being crashed. As far as functional style, there is a function called map(func,seq)(in python language) where the function 'func' is applied to each member of seq. The following code is written in a functional style.

numbers = [1,2,3,4,5]
/* define a method called compute on each number in the list */
def compute(var):
var = var * 2
return var
/* Now call the map function */
L = map(compute,numbers)
print L // L will print [1,4,6,8,10]

Notice that there is no global data nor any nested loops and the bound checking is handled internally within the map function. The programmer is relieved of of runtime errors and thus can debug the program easily.

Some advantages of this approach are:
* Easier debugging: Since every thing is broken down into small simple functions, the functions are often easy to debug.
* More compact code: Functional programming typically requires fewer lines of code. Since compution is done by function code reuse is prevelent.
* Nothing depends on state: Because functional programs keep no state information, the functions will always operate the same regardless of the past history of the program.

= Object-oriented Programming =
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] (OOP) is a programming paradigm organized around interacting "objects"(usually instances of a class) rather than "actions" and data rather than logic. A basic principle of OOP is that a program consists of a list of subroutines which can perform individually.

An object-oriented programming language provides support for the following object-oriented concepts--object, class, interface and inheritance. To illustrate this idea clearly and vividly let's review the following example-- your limbs. The "Limbs" is a class. Your body has two objects of type "limbs", named arms and legs. Their main functions are controlled/ managed by a set of biological signals sent from central nervous system( through an interface). So the nervous system is an interface which your body uses to interact with your limbs. The "limbs" is a well architected class. The "legs" has a subclass which contains "left leg" and "Right leg". The "legs" is being re-used to create the left leg and right leg by slightly changing the properties of it. If the "legs" owns attributes like length, color of skin etc, then the subclass, which contains "left leg" and "right leg" in this case, automatically inherit these attributes( that is called inheritance).

We could code in object-oriented paradigm as:

class Limbs /*define a class of limbs*/
def initialize(limbs,length,colorofskin)
@limbs=limbs
@length=length
@colorofskin=colorofskin
end
end
limbs=Limbs.new("legs","100cm","white") /*create a new object in class "Limbs"*/
class Legs<Limbs /*create a subclass "Legs",which belong to class"Limbs"*/
def initialize(legs,length,colorofskin)
super(length,colorofskin)
@legs=legs
end
end
legs=legs.new("left leg") /*create a new object in class of "Legs"*/

== Features of Object-oriented Programming ==
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]. A programmer can simply create a new object that inherits many of its features from super-class. And also, they can overwrite existing operations or add new ones.This makes object-oriented programs easier to modify.
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation].This refers to hiding the internal representation of the object from the outside view. You can hide unnecessary implementation details from the object user. One of the benefits of encapsulation is data protection.
* [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism].This allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects. Consider the operator '+', for numbers it will generate the sum, but for strings it will produce a third string which concatenates the input strings.

== Advantages of Object-oriented Programming ==
* Simplicity: we use software objects to simulate real world objects, so the complexity is reduced and the program structure is very clear.
* Modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system.
* Modifiability: programmers can easily make minor changes in the data representation or operations in an OOP. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods.
* Extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones.
* Maintainability: objects can be maintained separately, making locating and fixing problems easier.
* Re-usability: objects can be reused in different programs.

= Mixing Functional and Object-Oriented Programming =

Motivation for Mixing

== Functional Techniques useful for Object-Oriented Programming ==
In object-oriented world, data and operations are grouped together into modular units called objects and we combine objects into structured networks to form a program. The results are depend on arguments and objects' state at method invocation time. While in functional world, the basic elements are variables in the mathematical sense and functions in the mathematical sense. Functional programming can reduce side-effects. If there is no side-effects, it means your can apply the function at anywhere freely. No matter how you apply this function, the same input arguments produce the same results.

According to above-mentioned information, we can perform functional programming on an object-oriented programming language because:
1). object can have constant state
2). method can depend only on its arguments and context available at method definition time

Combining both these paradigms not only provide us a robust design structure, but also enable the programmers to develop solutions to complex problems quickly and effectively. One of the cornerstone of mixing functional and object-oriented code is treating functions as objects.It means that we can pass functions as arguments, store it and return them from other functions. This is highly useful in an user interface code where it can be used as call back functions which gets called when an event occurs(event driven programming).

Some of the basic features of Functional Programming which can be combined with Object Oriented paradigm are:

* Lambda Calculus
* Currying
* Powerful pattern matching

Let us now understand how each of the above feature of Functional language fits in the Object Oriented paradigm.

=== Lambda Calculus ===
Lambda calculus is the most critical basis of functional programming. A lambda expression is an anonymous expression that contain expressions and statements.Each expression stands for a function with one parameter.

Let consider the following function:

def f(x)
return x**2
print f(4)

We can use a lambda calculus to compute this expression without assigning it to a variable:

(lambda x:x**x)(4)

We can see that these two code snippets have the same results. It is more concise and flexible to define with lambda.
The above is a pure functional approach. In order to make code more state-less and concise, lambdas can be embedded inside the object-oriented language. The below code in Python demonstrates the use of lambda in a closure:

def fun(x):
return x%3==0
str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
filter(fun,str)

The above code works to find numbers which are divisible by 3.
We can simplify the code by the use of lambda as following:

str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print filter(lambda x: x%3==0, str)

=== Currying ===

=== Pattern Matching ===

== Examples of Mixing ==

A number of programming languages support mixing of both functional and object-oriented code. Three of these (Scala, Ruby, and Conjure), are described in more detail below.

=== Scala ===

[http://www.scala-lang.org/ Scala] is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. [http://www.scala-lang.org/ Scala] was conceived in 2001 and implemented by Martin Odersky. It has a number of features.

==== Statically Typed ====
[http://www.scala-lang.org/ Scala] belongs to the family of languages which encode the type information of each and every variable in the generated code. The compiler makes sure you are not doing something incorrectly. For example, lets consider the following example of code where the type is not encoded,

In [http://www.ruby-lang.org/en/ Ruby],
irb(main):001:0> str="Hello World"
=> "Hello World"
irb(main):002:0> puts str.class
String
irb(main):003:0> str=123
=> 123
irb(main):004:0> puts str.class
Fixnum

In the above example, first we define 'str' variable to be of type String and then as a number. So basically, no type information is associated with the variable at any point in the program. Hence we can easily reassociate that variable with an object/instance
of a different type. This is a feature of all dynamically typed languages(like Ruby, Python, Clojure). However most of the statically typed languages such as Scala, Java, C/C++ do not allow you do so. In [http://www.scala-lang.org/ Scala],

scala> var str="Hello World"
str: java.lang.String = Hello World
scala> str=123
<console>:6: error: type mismatch;
found : Int(123)
required: java.lang.String
str=123

==== Mixed paradigm ====
[http://www.scala-lang.org/ Scala] is a strange specimen. It is a complete blend of object oriented and functional programming. How can this happen? Functional world advocates immutability but object oriented world is all about state and how do you mutate it to fit your needs. [http://www.scala-lang.org/ Scala] allows you create both mutable and immutable objects. Consider the following example,
val str: String = "Hello World"
In the first line, an immutable version(a misnomer indeed) of <code>str</code> is being created . Roughly translating the above line to Java is below:

final String str = "Hello World"; //note the extra semi-colon
Consider the next example below,
val list: List[String] = List("Scala", "is", "the coolest", "language", "in the world!")

The same code can be written in Java as below

List<String> mutableList = new ArrayList<String>();
list.add("Scala");
list.add("is");
list.add("the coolest");
list.add("language");
list.add("in the world!");
List<String> immutableList = Collections.immutableList(mutableList);

Compared to Java, [http://www.scala-lang.org/ Scala] reduces the total number of lines you need to type and at the same time looks so much simpler and less verbose. Even though the above example shows immutable collection example, scala also provides mutable collection and object types under the package <code>scala.collection.mutable.*</code>

As it can be observed, even though [http://www.scala-lang.org/ Scala] advocates immutability, it does not restrict you from creating mutable objects. So its the best of both worlds. Another part of functional world is the concept of functions as ''''first class members'''' of the language. Some of the common languages like Ruby, Python and JavaScript all incorporate this feature. In the sense you can pass around functions to methods as a parameter. Enough talking;

Let us have a class say <code>'Person'</code> which has properties, <code>name</code> and another variable <code>age</code>.
In Java:

class Person{
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String s){
this.name = s;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}

In [http://www.scala-lang.org/ Scala]:
case class Person(name: String, age: Int)

This single line is equivalent to the above java code! Getters for <code>name</code> and <code>age</code>, <code>equals()</code>, and <code>hashCode()</code> method are automatically generated for you by the compiler. Isn't this an awesome feature?

Now assume we have a list of persons and we want to filter out all the persons who are of age 23. How would you do that in Java?

List<Person> persons; //has a bunch of person objects in it.
List<Person> twentyThree = new ArrayList<Person>();
for(Person p: persons){
if(p.getAge() == 23){
twentyThree.add(p);
}
}

In [http://www.scala-lang.org/ Scala]:

val twentyThree: List[Person] = persons.filter( _.age == 23)

That's it! In case you are wondering whats going on, filter is a method present on scala.List class and the code block <code>_.age == 23</code> is a function created on the fly and passed onto the filter method. More precisely its called a [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] - a functional concept which can be emulated in java only using anonymous inner classes. Scala's compiler transforms our one line function into some anonymous inner classes when generating java byte code, allowing developers to define functions in a simple manner.

In fact, every function is an object in [http://www.scala-lang.org/ Scala]. Scala's standard library has a number of functions which are objects themselves.

==== Sophisticated Syntax/Features ====
Sophisticated syntax and features are present in other functional languages like Haskell, (O)Caml and Erlang. Consider the following example,

val name = "Jackie Chan"
println(name.getClass) //prints out String.

Previously we saw that [http://www.scala-lang.org/ Scala] is a statically typed language and yet in the above example we don't specify what type <code>name</code> is. In Java, you would type in the following:

String name = "Jackie Chan"

In Java you specify what type the name variable is, but the [http://www.scala-lang.org/ scala] compiler can automatically detect the type of the variable even if you don't specify it. Consider the following example,

case class Person(name: String, age: Int)
val persons = List(
Person("Jackie Chan", 51), Person("Jet Li", 41),
Person("RajniKanth", 51), Person("Kamal Hasan", 44),
Person("Martin Odersky", 18), Person("Steve Yegge", 23))
//notice that you don't have to use 'new' keyword to create new instances. This is taken care of by the companion objects.

The above lines of code create a list with 6 different persons(An immutable list)

Now, just like ruby, scala supports the concepts of [http://en.wikipedia.org/wiki/Closure_(computer_science) closure]. Let's see what it is.

val twentyThree: List[Person] = persons.filter( { p: Person => p.age == 3})

In the above set of lines, the code within the '{ }' brackets is a function's body. The compiler created a function which takes a single argument and returns either true or false.

==== A Scalable Language ====
In almost all programming languages, there is a necessity to profile the running time of the procedures and tune its performance. The old way of doing things in Java would be:

public class Main{
public static int factorial(int x){
if(x == 0 || x == 1) return 1
else return x * factorial(x-1)
}
public static void main(String [] args){
long beforeTime = System.currentTimeMillis();
int result = factorial(5);
System.out.println("Total time taken to execute factorial(5) is " + (System.currentTimeMillis() - result)+"ms");
System.out.println("factorial(5) = " + result);
}
}

However, if you want to find out the execution time of some other method, you would have to type in all the above lines again. So much for code re-use or [http://en.wikipedia.org/wiki/DRY DRY (dont't repeat yourself)]! Lets see how its done in [http://www.scala-lang.org/ Scala].

object Main{
def main(args: Array[String]){
def factorial(x: Int):Int = x match{
case 0 | 1 => 1
case _ => x * factorial(x-1)
}
import System.currentTimeMillis
def timeIt(msg: String = "Time to execute is: ")(func: => Unit){
val before = currentTimeMillis
func
println(msg + (currentTimeMillis - before) + "ms")
}
timeIt("Total time taken to execute factorial(5) is "){
val result = factorial(5)
println("factorial(5) = " + result)
}
}
//would print: factorial(5) = 120
// Total time taken to execute factorial(5) is 1ms

That's not right! The function <code>timeIt</code> looks like a feature built into the language. Try saving the above code into a separate file and run it - It will still work. Using this feature, it is possible to build powerful DSL languages which can run at full speed on JVM.

Ruby allows you to add new methods to objects. This feature is often called as [http://en.wikipedia.org/wiki/Monkey_patch Monkey Patching] because you are splitting open the class and adding/overriding methods (in)|(to) the class. Often this leads to unexpected behavior at runtime because, other libraries including into build path may depend on some methods which you changed. Scala provides yet another feature called implicits.

In Java, <code>String</code> class is <code>final</code> so there is no way you can add new methods to it. But with implicits you can do more! Suppose you have some text in memory and you know it represents a number. But in Java the usual way to convert string to int is to do a <code>Integer.parseInt(string)</code> which seems so unnecessary. Let us make our lives easier...

implicit def strToInt(str: String) = new {
def asInt = Integer.parseInt(str)
}
val str = "1234"
println(str.asInt * 3) //prints out 3702

The above code gives us an impression as if String class has gained new <code>asInt</code> method. Can static object oriented languages do this? No! Infact scala cheats by calling our implicits to convert it into a different object as and when needed.

The above functionalities are purely object oriented, yet they are safe. They don't pollute the global namespace, unlike Ruby or Python.

=== Ruby ===

Ruby is another language that, like Scala, supports mixing functional and object-oriented code. It is a dynamically typed Object-Oriented Language which supports multiple programming paradigms, including functional, object-oriented, imperative and reflective. In Ruby, everything is an object, every bit of information and code can have its own properties and actions. However, Ruby’s blocks can be functional. A Ruby programmer can attach a closure to any method, which generates a functional block inside an object oriented code. A closure is a piece of code that can access the lexical environment of its definition [http://www.ruby-lang.org/en/ 11].

==== Ruby Mixing example ====

Consider the following code snippet in Ruby which uses Object Oriented concepts like Classes and functional programming concepts like lambda.

class Multiply
def initialize(n)
@block = lambda {|a| n * a}
end
def mul(a)
@block.call a
end
end
twoMultiplier = Multiply.new 2
puts twoMultiplier.mul(6)

Here,'''''@block''''' is a closure. When we call the class ''Multiply'' using '''''twoAdder = Multiply.new 2''''' ,the ''initialize'' method is called by passing the parameter 2. Here n=2 binds itself to the block. So @block will be 2*a, that is,the closure remembers the parameter with which the initialize method was called even after the initialize method exits.

This value is used when the block is called in the add method.
Thus,'''''twoMultiplier.mul(6)''''' will return 2*6 = 12

==== Functional Style Coding in Ruby Blocks ====

Blocks are basically nameless functions which can be passed to a function and then that function can invoke the passed in nameless function. This is a common style called [http://en.wikipedia.org/wiki/Higher-order_function higher order functions] among languages that handle functions as first class objects. Basically blocks can be designed for loop abstraction and lets the user to design their own way of iterating the values, thereby hiding the implementation details.
For example, if we want to iterate backwards from the end to the beginning without revealing its internal implementations, we could implement the loop logic inside the block and pass it to a method or function.

Here is a [http://www.ruby-lang.org/en/ Ruby] implementation of block:

def printlist(array,&reverse)
array.each do |element|
puts "array element: #{element}"
end
reverse.call(array) /* Here it prints the reverse implementation of list*/
end

printlist([1,2,3,4,5,6]) { |array|
array.reverse.each do |element|
puts "array element: #{element}"
end
}
The statements between { } is a block and it gets called by <code>reverse.call(array)</code>within the printlist method.

=== Clojure ===

= Conclusion =

= References =

= Mixing Functional & O-O code =

This chapter deals with the mixing of functional and object-oriented programming paradigms. We start with listing the different programming paradigms available today. We introduce functional and object-oriented approaches briefly and then discuss the advantages of one over the other. Following this, we discuss some aspects and features of mixing both the approaches. Finally, we talk about few languages that constitute such a mix.

== Programming Paradigms Today==

Several programmatic approaches to solve a particular task lead to distinct programming paradigms like, 
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
* Functional programming 
* Object Oriented programming 
* [http://en.wikipedia.org/wiki/Logic_programming Logical programming], etc. 
Lets focus on functional and object oriented programming approaches.

== Functional Programming ==

[http://en.wikipedia.org/wiki/Functional_programming Functional programming] is the task of decomposing a problem into a number of functions. Selectively executing these functions results in the solution to the problem. The functions mostly behave as mathematical. For given set of inputs the program should always return the same output. It usually concentrates on what type of problem we are dealing with rather than on the details of how to solve the problem. For example lets say there is a function which calculates area of a square. If we use it six times then we end up with area of a cube. Thus functional programming helps to build complex systems.

=== Approach ===

Expressions are the collection of variables and operations resulting in a single value this also deals with the way of solving the problem as expressions. Hence also called Expression related programming. It is structured as expression where each expression can be encapsulated in another yielding the result. Making the change in data structures as the program runs is called [http://en.wikipedia.org/wiki/Side_effect_(computer_science) side effects]. Purely functional language has no side effects. Language like Haskell is a pure functional language . Some languages need many approaches for achieving the desired result. Such languages are multi-paradigm. Examples for such languages are C++, Python,Lisp. Its like evaluating an expression and use the resulting value for something.

Structure of functional programming :

(fn2 ( fn1 ()[input list] ) []) => fn1 takes input list and the output of fn1 is used as input to fn2. Its a schematic representation of
how functional programming works.

Functional programming feature (Python) :

m = map(lambda i : i*i , numbers)
where ''numbers'' is an array of numbers and ''lambda'' is [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 closure].

Python has some functions like map, filter, reduce to support functional programming style. In the example above, the 'map' is a high-order function that takes a function and an array of numbers as input. The ''lambda'' takes i as input and returns i*i as output. Every result returned is appended to a list and produced as output. In functional programming, the programmer is given a natural framework for developing smaller, simpler, and more general modules, which are then glued together.

== Object Oriented Programming ==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] is a programming technique where everything is defined as an object. Objects are well-defined discrete bundles of data(attributes) and the associated functions(behavior). They are devised to resemble real-life objects and are uniquely identifiable by a name. The attributes could be of simple datatype(int, String, Boolean) or objects themselves. The behavior is defined by methods to use and manipulate the attributes. The values of attributes of an object at an instant is the state of the object. OO Programming allows objects to have their state retained throughout the code until manipulated otherwise. Objects are capable of housekeeping their own states, interacting and establishing relationships with other objects, inheriting, etc.

=== Fundamental concepts ===

A [http://en.wikipedia.org/wiki/Class_%28computer_science%29 class] is a user-defined datatype that provides implementation details to define the attributes and their properties. It is an abstract representation of an object(i.e.,) like a mold for objects.
An instance is an executable copy of a class. They are the actual objects created using the ‘class mold’ on run time.
Methods are a set of procedural statements or functions to define the behavior of an object, convey the current state, modify values of the attributes, etc.

Example :

An object in Java might look like this:

public class Person {
private String name;
public Person() {
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}

Here, OO Programming allows the programmer to set the ''name'' attribute of the class ''Person'' and get the name whenever needed in the code. An object of this class Person will remain in memory forever as long as there is a reference to it. As OO Programming allows objects to have their state retained, the value of the ''name'' attribute for a particular ''Person'' object remains the same across any part of the code until it is set differently.

=== Features ===

Three primary characteristics of object oriented programming are Encapsulation, Polymorphism, and Inheritance.
[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation] is the ability of objects to hide visibility of their attributes and behavior, thereby providing service independent of implementation.
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects.
[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance] is one where an existing type can be used to derive a new type. Derived types inherit the data and operations of the super-type. And also, they can overwrite existing operations or add new ones.

There are other important features of O-O programming like [http://en.wikipedia.org/wiki/Message_passing message passing], [http://en.wikipedia.org/wiki/Abstraction abstraction], delegation, etc.

Now, we have seen both the approaches and their features in brief. Lets discuss the advantages of one over the other.

== Advantages ==

=== Functional Approach over OO Approach[[http://www.jot.fm/issues/issue_2009_09/article5.pdf 8]]===
* Functional programming solves the problem with lesser number of lines of code than the OO programming style. 
* There is no side effect as they use immutable data structures also called [http://en.wikipedia.org/wiki/Persistent_data_structure Persistent Data Structure] which will have no change in the state of variables. Hence program dont have to depend on history. 
* There is no limit in the numeric types used as opposed to OO languages which mainly depend on primitive data types. 
* A programmer is given the freedom to think in terms of what to solve in the problem rather than concentrating on how to solve and the flow of the program. 
* Suitable for calculation intensive programs.

=== OO Approach over Functional Approach===
* Everything can be represented in an object and it has the attributes associated with it and hence the state of the object is known at any time. 
* A complex system can be subdivided into modules of objects where as in functional approach, many functions inter operate to form a complex system. 
* [http://en.wikipedia.org/wiki/Reusability Re-usability] (i.e.) OO approach enables programmers to create new objects that inherits many of its features from existing objects. This makes object-oriented programs easier to modify than functional. 
* [http://en.wikipedia.org/wiki/Debug Debugging] in Object Oriented environment is easy compared with functional approach where a small error in one function causes the whole system (i.e. all the functions) to fail. 
* Suitable for making application-oriented software. 

Both the approaches have their advantages and disadvantages. What if we could get the best of both the worlds? The next section deals with the aspects and features of how well both the approaches are mixed together in some languages.

== Mixing Functional & OO Code - Best of both the worlds ==

Languages that are a mix of functional and object oriented approaches(eg. Scala[[http://www.scala-lang.org/node/1305 1]], Clojure[[http://oreilly.com/catalog/9781934356333 10]], etc.) make use of best of both the worlds. They support various aspects of functional and object oriented approaches. They have a bunch of functional approach features[[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf 6]], which object oriented programming languages(like Java) lack which includes closures. Closures are first-class functions with free variables that are bound in the lexical environment. These languages also sport a very malleable syntax that makes them well suited for "domain specific languages" with the benefits of static typing. They are more expressive, extensible and allow reuse of programming abstractions.

Certain languages like Scala, Clojure, etc run on Java Virtual Machine(JVM) ensuring portability to all underlying platforms. They even support immutable objects. In Scala, new language constructs can be added in the form of libraries. They allow safe reuse[[http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf 9]] of programming abstractions and type-safe extension of software.

===Lambda===

A lambda[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] expression is an anonymous function that contain expressions and statements, and can be used to create delegates or expression types. Such kind of anonymous function can be defined and passed around as easily as other data types and can be used to contain functionality that need not be named. Some notable examples include closures[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] and currying. Lambda functions with no name can be called using the variable assigned to it.

g = lambda x: x*2
g(3)=6

We can have lambda function without assigning it to a variable which can be used as inline-function.

(lambda x: x*2)(3)

In [http://en.wikipedia.org/wiki/Clojure Clojure] as a functional language, the creation of a chunk of behavior that can be assigned to a variable (known as a lambda) is trivial. Below are two ways to create a lambda that returns the square of its argument.

(def square1 (fn [n] (* n n)))
(def square2 #(* % %))

===Currying ===

[http://en.wikipedia.org/wiki/Currying Currying] transforms a function that takes multiple parameters into a chain of functions, each taking a single parameter. It reuses a partially applied function where the function is originally defined as accepting n parameters.It can be interpreted as the technique to decompose a function that takes n parameters into n function each of them taking 1 parameter. For example to say in algebraic terms,consider the function f which takes 3 parameters x,y,z and Currying means that we can rewrite the function as a composition of 3 functions:

f(x,y,z) = 4*x+3*y+2*z
f(x)(y)(z) = 2*z+(3*y+(4*x))

In Scala, currying takes advantage of Scala’s syntactic sugar. Below is a currying example in Scala. This function creates a multiplier function which takes two arguments and partially defines it by assigning a constant to one argument and assigning it to a variable .Later the function is called by assigning the second argument.

def multiplier(i: Int)(factor: Int) = i * factor => method named multiplier which takes two parameters is defined
val byFive = multiplier(5) _ => The method is redefined with accepting one parameter and store it in a variable.
val byTen = multiplier(10) _

scala> byFive(2) => Method called by giving the second parameter.
res4: Int = 10

scala> byTen(2)
res5: Int = 20

===Less Verbosity===

In Java each variable should have its type defined beforehand. Whereas in languages like Scala, it is more concise and easier to read than the equivalent Java.

For example, a Map can be created with a simple syntax in Scala,Clojure than in Java:

<table>
<tr>
<td>
'''Java'''
Map<String, Integer> nMap = new HashMap<String, Integer>();
nMap.put("one", 1);
nMap.put("two", 2);
nMap.put("three", 3);
</td>
<td>
'''Scala'''

var nMap = Map("one" -> 1, "two" -> 2, "three" -> 3)

</td>
<td>
'''Clojure'''

(doto (new Java.util.HashMap)(.put “a” 1)(.put “b” 2))

</td>
</tr>
</table>

Here, Scala compiler knows that nMap uses Strings as keys, and Integers as values. Unlike Java, this need not be specified beforehand. Scala could figure it out itself. Moreover, Scala will give an error if a different key-value pair is tried to insert. This is called "type inference". This prevents a whole class of bugs at run time just like Java but with less verbosity.
In a similar way Clojure also involves only few lines of code compared with the object oriented Java language which takes many lines of code.A simple Clojure example and the associated Java code :
Example

(defn blank? [s] (every? #(Character/isWhitespace %) s))

The innermost function Character/isWhiteSpace checks the first argument % for any whitespace and returns true if it is. every? invoke the above inner function for all elements in the collection s.It has no variables, no branches etc.

Java code
isBlank() method checks to see whether a string is blank or contains only whitespace.

public class Stringcheck{
public static boolean isBlank(String str){
int len;
if(str==null || (strlen =str.length())==0)
return true;
for(int i=0; i<strlen;i++) {
if((Character.isWhitespace(str.charAt(i))==false)){
return false;
}
}
return true;
}
}

=== Pattern Matching ===

To say simply, a [http://en.wikipedia.org/wiki/Pattern_matching Pattern matching] is a technique to search string for the occurrence of any patterns or regularity. Pattern matching is an elegant way to decompose objects into their constituent parts for processing.Many languages support the concept of pattern matching. Perl supports pattern matching using the pattern definition mini language called regular expressions, also called regexes or REs, which is borrowed from the regular expressions used in many Unix tools, such as grep() and sed().The risk that the parts of an object might be changed outside of the control of the enclosing object is avoided. For example, if there is a Person class that contains a list of addresses, it will not be an issue to expose that list to clients if the list is immutable. The users will not be able to change the list unexpectedly.Given below is a simple example for pattern matching used in Perl:

$mystring = "Hello world!"; // Perls way of assigning string to a variable.
if($mystring =~ m/World/) { print "Yes"; } // Checks the string stored in variable mystring has the string "World".
$mystring =~ s/world/mom/; // Replaces the string "world" stored in mystring to mom.

Another sample of regular expression in java :

String mystring="Hello World" ;
Pattern str = Pattern.compile("\\w+"); => Pattern stored for matching.
Matcher fit = str.matcher(mystring); => Matcher class which perform matching of the string with the pattern defined.
if(fit.matches())

As languages like Scala and Clojure support procedural code, pattern matching is done as equal or with less difficulty compared with Java which needs to use regex. Scala can even be embedded into XML as its syntax is somewhat similar.Given below an overview of how regular expression is achieved in Clojure.
Data are manipulated in Clojure through the sequence called seq which is a logical list. Clojure can access java collections, its collections, Regular expression matches via the seq also called seq-able. Clojure's regular expression uses java.util.regex library at the lowest level. For achieving that the keyword re-seq is used.
Syntax:
(re-seq regexp string)
Example
(re-seq #"\w+" "Hello World") => ("Hello" "World") => #"\w+" represents the java.util.regex.Pattern

=== Java Interoperability ===
Considering Clojure, it gives clean, simple and direct access to java and can access Java API directly.Clojure doesnot wrap Java's string functions. We can call using Java interop forms. It provides syntax for accessing Java elements like classes, instances, constructors, methods and fields and can also wrap Java API. The “.” dot special form is used for accessing Java. Some Clojure syntax which can access Java API: 

{| class="wikitable" border="2"
|-
! Java
! Clojure
|-
| new Widget(“red”)
| (new Widget “red”)
|-
| Math.PI
| (.Math PI) or Math/PI
|-
| System.currentTimeMillis()
| (.System currentTimeMillis) or System/currentTimeMillis
|-
| rnd.nextInt()
| (.rnd nextInt) or (.nextInt rnd)
|-
|}

Clojure pass functions as arguments to other functions. But Java does not support this. So Clojure provides a member function memfn macro to wrap methods or can use anonymous function to wrap a method call.
(map (memfn toUpperCase) [“a” ,”short”,”message”])
or
(map #(.toUpperCase %)[“a”,”short”,”message”]) => #(body) represents the anonymous function in Clojure.

For example,
(def the-digits
(map #(Integer. (str %))(filter #(Character/isDigit %) (seq big-num-str))))

where (def big-num-str (str "123785334434se9088af8309304293872adbcdfd”))

The above code extracts the integers from string and discards the non-numeric characters. Lets look at the functions defined in the example. There are totally five functions defined.They are
(seq big-num-str) => get each character defined in big-num-str
(Character/isDigit %) => Checks whether the input is an integer
(filter #()) => Filter each string from str
(map #(Integer. (str %))) => Change the string to integer
(def the-digits) => Output the integers only in a string of characters.
Here,
#(Character/isDigit) represents the Java method Character.isDigit() and #(Integer.(str %)) represents the new java.lang.Integer(str(%))

Most of the Clojure library functions have defined semantics for objects of Java types. contains? and .get work on Java’s Maps, arrays, Strings, count works on Java Strings, Collections and arrays. Clojure is built around these aspects. It avails the performance of JVM and the richness of both the core APIs and the numerous third-party libraries written in the Java language and restrained from reinventing them.

=== Multiple Inheritance ===

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance][http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf 2] is the concept of using the methods and variables of more than one superclass to a sub class.Java was designed without multiple inheritance. But Java supports the solution of problems commonly solved with multiple inheritance in other ways with help of interfaces where the methods defined in it are not implemented.In Scala, classes are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance in Java.Lets see how multiple inheritance achieved in Scala:

As interfaces in Java, Scala allows traits but has some methods partially implemented. The only difference to classes is the traits may not have constructor parameters.

trait Similarity {
def isSimilar(x: Any): Boolean // not implemented
def isNotSimilar(x: Any): Boolean = !isSimilar(x) //implemented method
}

This trait defines two methods isSimilar and isNotSimilar where isSimilar does not provide a concrete method implementation (it is abstract in the terminology of Java), and the method isNotSimilar defines a concrete implementation. Consequently, classes that integrate this trait only have to provide a concrete implementation for isSimilar.

class Point(xc: Int, yc: Int) extends Similarity {
var x: Int = xc
var y: Int = yc
def isSimilar(obj: Any) = //need to implement the method here
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
}

object TraitsTest extends Application {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotSimilar(p2))
println(p1.isNotSimilar(p3)) //uses the already defined method
println(p1.isNotSimilar(2))
}

These are some of the aspects and traits of mixing functional and object-oriented approaches. As we discussed in the advantages section, both the approaches have their benefits and limitations. Mixing them aspect-wise enables the above features in such languages. Lets discuss those languages briefly in the next section.

== Languages Supporting Functional and OO code ==

OCaml and F#[[http://msdn.microsoft.com/en-us/library/dd233154.aspx 7]] are some of the languages which support both functional and object oriented programming. OCaml is as fast as C and its featured as [http://www.haskell.org/ Haskell] which is a pure functional language. F#[[http://oreilly.com/catalog/9780596153656 3]] is a dynamically typed language which can run on .NET framework and has supported immutable types i.e. tuples, records, discriminated unions and lists to work in Functional programming. It has functions that can either be in curried or in uncurried form. As in functional language it can pass functions as arguments to other functions, resulting in higher order functions. It also supports lambda functions and closures. F#,behaves like other .NET languages as both in imperative and object oriented style. 

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language and it is a dialect of Lisp. It is not a pure functional language and it is a dynamically typed language. Just like Java it runs on JVM platform. But its syntax differs from Java. It is represented as :

(functions arguments...)

The function followed by its arguments is enclosed in paranthesis. It has features like immutable data structures, high-order functions and recursion, easy and fast java interoperability. 

Python and Ruby are also the programming languages which offer the mix of functional and OO languages. But these languages doesn't support the algebraic data types and pattern matching.

==Conclusion ==
The above aspects of functional and object oriented programming techniques discuss some if their merits and demerits. Mixing them produces a new programming paradigm which leads to a new dimension in programming. A few fundamental concepts are explored in Clojure and Scala here. The ability of Clojure and Scala to run in JVM platform makes them more preferable than others in the market. Some of the merits like closure, less verbosity, high order functions, currying along with interoperation with previously written libraries in these languages make them more efficient and useful. There are also other languages which support functional and object oriented techniques. Mixing the approaches, evolve a new dimension in programming which is practical and opens doors to more exploration.

== References ==

# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-09T22:24:18Z

Dmcarmon: /* Examples of Mixing */

= Introduction =

= Functional Programming =

Functional programming treats computation as the evaluation of mathematical functions. It is compute-centric rather than data-centric. Functional programming keeps no global state, does not use for or while loops, and data is immutable****. Instead, everything is done using functions, usually functions that evaluate mathematical expressions. Each of these functions maintain no internal state and will always produce the same output given the same input.

Let's look at an example. Suppose we have a list of numbers and we want to multiply each number in the list by 2. The first approach is the imperitive style:

array[] = {1,2,3,4,5}
for(i=0 ; i<array.length; i++){
array[i] = array[i] * 2;
}

In the above example, array[] is a global variable. If we fail to check the array length, then a runtime exception occurs which might result in the program being crashed. As far as functional style, there is a function called map(func,seq)(in python language) where the function 'func' is applied to each member of seq. The following code is written in a functional style.

numbers = [1,2,3,4,5]
/* define a method called compute on each number in the list */
def compute(var):
var = var * 2
return var
/* Now call the map function */
L = map(compute,numbers)
print L // L will print [1,4,6,8,10]

Notice that there is no global data nor any nested loops and the bound checking is handled internally within the map function. The programmer is relieved of of runtime errors and thus can debug the program easily.

Some advantages of this approach are:
* Easier debugging: Since every thing is broken down into small simple functions, the functions are often easy to debug.
* More compact code: Functional programming typically requires fewer lines of code. Since compution is done by function code reuse is prevelent.
* Nothing depends on state: Because functional programs keep no state information, the functions will always operate the same regardless of the past history of the program.

= Object-oriented Programming =
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] (OOP) is a programming paradigm organized around interacting "objects"(usually instances of a class) rather than "actions" and data rather than logic. A basic principle of OOP is that a program consists of a list of subroutines which can perform individually.

An object-oriented programming language provides support for the following object-oriented concepts--object, class, interface and inheritance. To illustrate this idea clearly and vividly let's review the following example-- your limbs. The "Limbs" is a class. Your body has two objects of type "limbs", named arms and legs. Their main functions are controlled/ managed by a set of biological signals sent from central nervous system( through an interface). So the nervous system is an interface which your body uses to interact with your limbs. The "limbs" is a well architected class. The "legs" has a subclass which contains "left leg" and "Right leg". The "legs" is being re-used to create the left leg and right leg by slightly changing the properties of it. If the "legs" owns attributes like length, color of skin etc, then the subclass, which contains "left leg" and "right leg" in this case, automatically inherit these attributes( that is called inheritance).

We could code in object-oriented paradigm as:

class Limbs /*define a class of limbs*/
def initialize(limbs,length,colorofskin)
@limbs=limbs
@length=length
@colorofskin=colorofskin
end
end
limbs=Limbs.new("legs","100cm","white") /*create a new object in class "Limbs"*/
class Legs<Limbs /*create a subclass "Legs",which belong to class"Limbs"*/
def initialize(legs,length,colorofskin)
super(length,colorofskin)
@legs=legs
end
end
legs=legs.new("left leg") /*create a new object in class of "Legs"*/

== Features of Object-oriented Programming ==
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]. A programmer can simply create a new object that inherits many of its features from super-class. And also, they can overwrite existing operations or add new ones.This makes object-oriented programs easier to modify.
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation].This refers to hiding the internal representation of the object from the outside view. You can hide unnecessary implementation details from the object user. One of the benefits of encapsulation is data protection.
* [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism].This allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects. Consider the operator '+', for numbers it will generate the sum, but for strings it will produce a third string which concatenates the input strings.

== Advantages of Object-oriented Programming ==
* Simplicity: we use software objects to simulate real world objects, so the complexity is reduced and the program structure is very clear.
* Modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system.
* Modifiability: programmers can easily make minor changes in the data representation or operations in an OOP. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods.
* Extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones.
* Maintainability: objects can be maintained separately, making locating and fixing problems easier.
* Re-usability: objects can be reused in different programs.

= Mixing Functional and Object-Oriented Programming =

Motivation for Mixing

== Functional Techniques useful for Object-Oriented Programming ==
In object-oriented world, data and operations are grouped together into modular units called objects and we combine objects into structured networks to form a program. The results are depend on arguments and objects' state at method invocation time. While in functional world, the basic elements are variables in the mathematical sense and functions in the mathematical sense. Functional programming can reduce side-effects. If there is no side-effects, it means your can apply the function at anywhere freely. No matter how you apply this function, the same input arguments produce the same results.

According to above-mentioned information, we can perform functional programming on an object-oriented programming language because:
1). object can have constant state
2). method can depend only on its arguments and context available at method definition time

Combining both these paradigms not only provide us a robust design structure, but also enable the programmers to develop solutions to complex problems quickly and effectively. One of the cornerstone of mixing functional and object-oriented code is treating functions as objects.It means that we can pass functions as arguments, store it and return them from other functions. This is highly useful in an user interface code where it can be used as call back functions which gets called when an event occurs(event driven programming).

Some of the basic features of Functional Programming which can be combined with Object Oriented paradigm are:

* Lambda Calculus
* Currying
* Powerful pattern matching

Let us now understand how each of the above feature of Functional language fits in the Object Oriented paradigm.

=== Lambda Calculus ===
Lambda calculus is the most critical basis of functional programming. A lambda expression is an anonymous expression that contain expressions and statements.Each expression stands for a function with one parameter.

Let consider the following function:

def f(x)
return x**2
print f(4)

We can use a lambda calculus to compute this expression without assigning it to a variable:

(lambda x:x**x)(4)

We can see that these two code snippets have the same results. It is more concise and flexible to define with lambda.
The above is a pure functional approach. In order to make code more state-less and concise, lambdas can be embedded inside the object-oriented language. The below code in Python demonstrates the use of lambda in a closure:

def fun(x):
return x%3==0
str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
filter(fun,str)

The above code works to find numbers which are divisible by 3.
We can simplify the code by the use of lambda as following:

str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print filter(lambda x: x%3==0, str)

=== Currying ===

=== Pattern Matching ===

== Examples of Mixing ==

A number of programming languages support mixing of both functional and object-oriented code. Three of these (Scala, Ruby, and Conjure), are described in more detail below.

=== Scala ===

[http://www.scala-lang.org/ Scala] is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. [http://www.scala-lang.org/ Scala] was conceived in 2001 and implemented by Martin Odersky. It has a number of features.

==== Statically Typed ====
[http://www.scala-lang.org/ Scala] belongs to the family of languages which encode the type information of each and every variable in the generated code. The compiler makes sure you are not doing something incorrectly. For example, lets consider the following example of code where the type is not encoded,

In [http://www.ruby-lang.org/en/ Ruby],
irb(main):001:0> str="Hello World"
=> "Hello World"
irb(main):002:0> puts str.class
String
irb(main):003:0> str=123
=> 123
irb(main):004:0> puts str.class
Fixnum

In the above example, first we define 'str' variable to be of type String and then as a number. So basically, no type information is associated with the variable at any point in the program. Hence we can easily reassociate that variable with an object/instance
of a different type. This is a feature of all dynamically typed languages(like Ruby, Python, Clojure). However most of the statically typed languages such as Scala, Java, C/C++ do not allow you do so. In [http://www.scala-lang.org/ Scala],

scala> var str="Hello World"
str: java.lang.String = Hello World
scala> str=123
<console>:6: error: type mismatch;
found : Int(123)
required: java.lang.String
str=123

==== Mixed paradigm ====
[http://www.scala-lang.org/ Scala] is a strange specimen. It is a complete blend of object oriented and functional programming. How can this happen? Functional world advocates immutability but object oriented world is all about state and how do you mutate it to fit your needs. [http://www.scala-lang.org/ Scala] allows you create both mutable and immutable objects. Consider the following example,
val str: String = "Hello World"
In the first line, an immutable version(a misnomer indeed) of <code>str</code> is being created . Roughly translating the above line to Java is below:

final String str = "Hello World"; //note the extra semi-colon
Consider the next example below,
val list: List[String] = List("Scala", "is", "the coolest", "language", "in the world!")

The same code can be written in Java as below

List<String> mutableList = new ArrayList<String>();
list.add("Scala");
list.add("is");
list.add("the coolest");
list.add("language");
list.add("in the world!");
List<String> immutableList = Collections.immutableList(mutableList);

Compared to Java, [http://www.scala-lang.org/ Scala] reduces the total number of lines you need to type and at the same time looks so much simpler and less verbose. Even though the above example shows immutable collection example, scala also provides mutable collection and object types under the package <code>scala.collection.mutable.*</code>

As it can be observed, even though [http://www.scala-lang.org/ Scala] advocates immutability, it does not restrict you from creating mutable objects. So its the best of both worlds. Another part of functional world is the concept of functions as ''''first class members'''' of the language. Some of the common languages like Ruby, Python and JavaScript all incorporate this feature. In the sense you can pass around functions to methods as a parameter. Enough talking;

Let us have a class say <code>'Person'</code> which has properties, <code>name</code> and another variable <code>age</code>.
In Java:

class Person{
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String s){
this.name = s;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}

In [http://www.scala-lang.org/ Scala]:
case class Person(name: String, age: Int)

This single line is equivalent to the above java code! Getters for <code>name</code> and <code>age</code>, <code>equals()</code>, and <code>hashCode()</code> method are automatically generated for you by the compiler. Isn't this an awesome feature?

Now assume we have a list of persons and we want to filter out all the persons who are of age 23. How would you do that in Java?

List<Person> persons; //has a bunch of person objects in it.
List<Person> twentyThree = new ArrayList<Person>();
for(Person p: persons){
if(p.getAge() == 23){
twentyThree.add(p);
}
}

In [http://www.scala-lang.org/ Scala]:

val twentyThree: List[Person] = persons.filter( _.age == 23)

That's it! In case you are wondering whats going on, filter is a method present on scala.List class and the code block <code>_.age == 23</code> is a function created on the fly and passed onto the filter method. More precisely its called a [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] - a functional concept which can be emulated in java only using anonymous inner classes. Scala's compiler transforms our one line function into some anonymous inner classes when generating java byte code, allowing developers to define functions in a simple manner.

In fact, every function is an object in [http://www.scala-lang.org/ Scala]. Scala's standard library has a number of functions which are objects themselves.

==== Sophisticated Syntax/Features ====
Sophisticated syntax and features are present in other functional languages like Haskell, (O)Caml and Erlang. Consider the following example,

val name = "Jackie Chan"
println(name.getClass) //prints out String.

Previously we saw that [http://www.scala-lang.org/ Scala] is a statically typed language and yet in the above example we don't specify what type <code>name</code> is. In Java, you would type in the following:

String name = "Jackie Chan"

In Java you specify what type the name variable is, but the [http://www.scala-lang.org/ scala] compiler can automatically detect the type of the variable even if you don't specify it. Consider the following example,

case class Person(name: String, age: Int)
val persons = List(
Person("Jackie Chan", 51), Person("Jet Li", 41),
Person("RajniKanth", 51), Person("Kamal Hasan", 44),
Person("Martin Odersky", 18), Person("Steve Yegge", 23))
//notice that you don't have to use 'new' keyword to create new instances. This is taken care of by the companion objects.

The above lines of code create a list with 6 different persons(An immutable list)

Now, just like ruby, scala supports the concepts of [http://en.wikipedia.org/wiki/Closure_(computer_science) closure]. Let's see what it is.

val twentyThree: List[Person] = persons.filter( { p: Person => p.age == 3})

In the above set of lines, the code within the '{ }' brackets is a function's body. The compiler created a function which takes a single argument and returns either true or false.

==== A Scalable Language ====
In almost all programming languages, there is a necessity to profile the running time of the procedures and tune its performance. The old way of doing things in Java would be:

public class Main{
public static int factorial(int x){
if(x == 0 || x == 1) return 1
else return x * factorial(x-1)
}
public static void main(String [] args){
long beforeTime = System.currentTimeMillis();
int result = factorial(5);
System.out.println("Total time taken to execute factorial(5) is " + (System.currentTimeMillis() - result)+"ms");
System.out.println("factorial(5) = " + result);
}
}

However, if you want to find out the execution time of some other method, you would have to type in all the above lines again. So much for code re-use or [http://en.wikipedia.org/wiki/DRY DRY (dont't repeat yourself)]! Lets see how its done in [http://www.scala-lang.org/ Scala].

object Main{
def main(args: Array[String]){
def factorial(x: Int):Int = x match{
case 0 | 1 => 1
case _ => x * factorial(x-1)
}
import System.currentTimeMillis
def timeIt(msg: String = "Time to execute is: ")(func: => Unit){
val before = currentTimeMillis
func
println(msg + (currentTimeMillis - before) + "ms")
}
timeIt("Total time taken to execute factorial(5) is "){
val result = factorial(5)
println("factorial(5) = " + result)
}
}
//would print: factorial(5) = 120
// Total time taken to execute factorial(5) is 1ms

That's not right! The function <code>timeIt</code> looks like a feature built into the language. Try saving the above code into a separate file and run it - It will still work. Using this feature, it is possible to build powerful DSL languages which can run at full speed on JVM.

Ruby allows you to add new methods to objects. This feature is often called as [http://en.wikipedia.org/wiki/Monkey_patch Monkey Patching] because you are splitting open the class and adding/overriding methods (in)|(to) the class. Often this leads to unexpected behavior at runtime because, other libraries including into build path may depend on some methods which you changed. Scala provides yet another feature called implicits.

In Java, <code>String</code> class is <code>final</code> so there is no way you can add new methods to it. But with implicits you can do more! Suppose you have some text in memory and you know it represents a number. But in Java the usual way to convert string to int is to do a <code>Integer.parseInt(string)</code> which seems so unnecessary. Let us make our lives easier...

implicit def strToInt(str: String) = new {
def asInt = Integer.parseInt(str)
}
val str = "1234"
println(str.asInt * 3) //prints out 3702

The above code gives us an impression as if String class has gained new <code>asInt</code> method. Can static object oriented languages do this? No! Infact scala cheats by calling our implicits to convert it into a different object as and when needed.

The above functionalities are purely object oriented, yet they are safe. They don't pollute the global namespace, unlike Ruby or Python.

=== Ruby ===

Ruby is another language that, like Scala, supports mixing functional and object-oriented code. It is a dynamically typed Object-Oriented Language which supports multiple programming paradigms, including functional, object-oriented, imperative and reflective. In Ruby, everything is an object, every bit of information and code can have its own properties and actions. However, Ruby’s blocks can be functional. A Ruby programmer can attach a closure to any method, which generates a functional block inside an object oriented code. A closure is a piece of code that can access the lexical environment of its definition [http://www.ruby-lang.org/en/ 11].

Consider the following code snippet in Ruby which uses Object Oriented concepts like Classes and functional programming concepts like lambda.

class Multiply
def initialize(n)
@block = lambda {|a| n * a}
end
def mul(a)
@block.call a
end
end
twoMultiplier = Multiply.new 2
puts twoMultiplier.mul(6)

Here,'''''@block''''' is a closure. When we call the class ''Multiply'' using '''''twoAdder = Multiply.new 2''''' ,the ''initialize'' method is called by passing the parameter 2. Here n=2 binds itself to the block. So @block will be 2*a, that is,the closure remembers the parameter with which the initialize method was called even after the initialize method exits.

This value is used when the block is called in the add method.
Thus,'''''twoMultiplier.mul(6)''''' will return 2*6 = 12

Blocks are basically nameless functions which can be passed to a function and then that function can invoke the passed in nameless function. This is a common style called [http://en.wikipedia.org/wiki/Higher-order_function higher order functions] among languages that handle functions as first class objects. Basically blocks can be designed for loop abstraction and lets the user to design their own way of iterating the values, thereby hiding the implementation details.
For example, if we want to iterate backwards from the end to the beginning without revealing its internal implementations, we could implement the loop logic inside the block and pass it to a method or function.

Here is a [http://www.ruby-lang.org/en/ Ruby] implementation of block:

def printlist(array,&reverse)
array.each do |element|
puts "array element: #{element}"
end
reverse.call(array) /* Here it prints the reverse implementation of list*/
end

printlist([1,2,3,4,5,6]) { |array|
array.reverse.each do |element|
puts "array element: #{element}"
end
}
The statements between { } is a block and it gets called by <code>reverse.call(array)</code>within the printlist method.

=== Clojure ===

= Conclusion =

= References =

= Mixing Functional & O-O code =

This chapter deals with the mixing of functional and object-oriented programming paradigms. We start with listing the different programming paradigms available today. We introduce functional and object-oriented approaches briefly and then discuss the advantages of one over the other. Following this, we discuss some aspects and features of mixing both the approaches. Finally, we talk about few languages that constitute such a mix.

== Programming Paradigms Today==

Several programmatic approaches to solve a particular task lead to distinct programming paradigms like, 
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
* Functional programming 
* Object Oriented programming 
* [http://en.wikipedia.org/wiki/Logic_programming Logical programming], etc. 
Lets focus on functional and object oriented programming approaches.

== Functional Programming ==

[http://en.wikipedia.org/wiki/Functional_programming Functional programming] is the task of decomposing a problem into a number of functions. Selectively executing these functions results in the solution to the problem. The functions mostly behave as mathematical. For given set of inputs the program should always return the same output. It usually concentrates on what type of problem we are dealing with rather than on the details of how to solve the problem. For example lets say there is a function which calculates area of a square. If we use it six times then we end up with area of a cube. Thus functional programming helps to build complex systems.

=== Approach ===

Expressions are the collection of variables and operations resulting in a single value this also deals with the way of solving the problem as expressions. Hence also called Expression related programming. It is structured as expression where each expression can be encapsulated in another yielding the result. Making the change in data structures as the program runs is called [http://en.wikipedia.org/wiki/Side_effect_(computer_science) side effects]. Purely functional language has no side effects. Language like Haskell is a pure functional language . Some languages need many approaches for achieving the desired result. Such languages are multi-paradigm. Examples for such languages are C++, Python,Lisp. Its like evaluating an expression and use the resulting value for something.

Structure of functional programming :

(fn2 ( fn1 ()[input list] ) []) => fn1 takes input list and the output of fn1 is used as input to fn2. Its a schematic representation of
how functional programming works.

Functional programming feature (Python) :

m = map(lambda i : i*i , numbers)
where ''numbers'' is an array of numbers and ''lambda'' is [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 closure].

Python has some functions like map, filter, reduce to support functional programming style. In the example above, the 'map' is a high-order function that takes a function and an array of numbers as input. The ''lambda'' takes i as input and returns i*i as output. Every result returned is appended to a list and produced as output. In functional programming, the programmer is given a natural framework for developing smaller, simpler, and more general modules, which are then glued together.

== Object Oriented Programming ==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] is a programming technique where everything is defined as an object. Objects are well-defined discrete bundles of data(attributes) and the associated functions(behavior). They are devised to resemble real-life objects and are uniquely identifiable by a name. The attributes could be of simple datatype(int, String, Boolean) or objects themselves. The behavior is defined by methods to use and manipulate the attributes. The values of attributes of an object at an instant is the state of the object. OO Programming allows objects to have their state retained throughout the code until manipulated otherwise. Objects are capable of housekeeping their own states, interacting and establishing relationships with other objects, inheriting, etc.

=== Fundamental concepts ===

A [http://en.wikipedia.org/wiki/Class_%28computer_science%29 class] is a user-defined datatype that provides implementation details to define the attributes and their properties. It is an abstract representation of an object(i.e.,) like a mold for objects.
An instance is an executable copy of a class. They are the actual objects created using the ‘class mold’ on run time.
Methods are a set of procedural statements or functions to define the behavior of an object, convey the current state, modify values of the attributes, etc.

Example :

An object in Java might look like this:

public class Person {
private String name;
public Person() {
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}

Here, OO Programming allows the programmer to set the ''name'' attribute of the class ''Person'' and get the name whenever needed in the code. An object of this class Person will remain in memory forever as long as there is a reference to it. As OO Programming allows objects to have their state retained, the value of the ''name'' attribute for a particular ''Person'' object remains the same across any part of the code until it is set differently.

=== Features ===

Three primary characteristics of object oriented programming are Encapsulation, Polymorphism, and Inheritance.
[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation] is the ability of objects to hide visibility of their attributes and behavior, thereby providing service independent of implementation.
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects.
[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance] is one where an existing type can be used to derive a new type. Derived types inherit the data and operations of the super-type. And also, they can overwrite existing operations or add new ones.

There are other important features of O-O programming like [http://en.wikipedia.org/wiki/Message_passing message passing], [http://en.wikipedia.org/wiki/Abstraction abstraction], delegation, etc.

Now, we have seen both the approaches and their features in brief. Lets discuss the advantages of one over the other.

== Advantages ==

=== Functional Approach over OO Approach[[http://www.jot.fm/issues/issue_2009_09/article5.pdf 8]]===
* Functional programming solves the problem with lesser number of lines of code than the OO programming style. 
* There is no side effect as they use immutable data structures also called [http://en.wikipedia.org/wiki/Persistent_data_structure Persistent Data Structure] which will have no change in the state of variables. Hence program dont have to depend on history. 
* There is no limit in the numeric types used as opposed to OO languages which mainly depend on primitive data types. 
* A programmer is given the freedom to think in terms of what to solve in the problem rather than concentrating on how to solve and the flow of the program. 
* Suitable for calculation intensive programs.

=== OO Approach over Functional Approach===
* Everything can be represented in an object and it has the attributes associated with it and hence the state of the object is known at any time. 
* A complex system can be subdivided into modules of objects where as in functional approach, many functions inter operate to form a complex system. 
* [http://en.wikipedia.org/wiki/Reusability Re-usability] (i.e.) OO approach enables programmers to create new objects that inherits many of its features from existing objects. This makes object-oriented programs easier to modify than functional. 
* [http://en.wikipedia.org/wiki/Debug Debugging] in Object Oriented environment is easy compared with functional approach where a small error in one function causes the whole system (i.e. all the functions) to fail. 
* Suitable for making application-oriented software. 

Both the approaches have their advantages and disadvantages. What if we could get the best of both the worlds? The next section deals with the aspects and features of how well both the approaches are mixed together in some languages.

== Mixing Functional & OO Code - Best of both the worlds ==

Languages that are a mix of functional and object oriented approaches(eg. Scala[[http://www.scala-lang.org/node/1305 1]], Clojure[[http://oreilly.com/catalog/9781934356333 10]], etc.) make use of best of both the worlds. They support various aspects of functional and object oriented approaches. They have a bunch of functional approach features[[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf 6]], which object oriented programming languages(like Java) lack which includes closures. Closures are first-class functions with free variables that are bound in the lexical environment. These languages also sport a very malleable syntax that makes them well suited for "domain specific languages" with the benefits of static typing. They are more expressive, extensible and allow reuse of programming abstractions.

Certain languages like Scala, Clojure, etc run on Java Virtual Machine(JVM) ensuring portability to all underlying platforms. They even support immutable objects. In Scala, new language constructs can be added in the form of libraries. They allow safe reuse[[http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf 9]] of programming abstractions and type-safe extension of software.

===Lambda===

A lambda[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] expression is an anonymous function that contain expressions and statements, and can be used to create delegates or expression types. Such kind of anonymous function can be defined and passed around as easily as other data types and can be used to contain functionality that need not be named. Some notable examples include closures[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] and currying. Lambda functions with no name can be called using the variable assigned to it.

g = lambda x: x*2
g(3)=6

We can have lambda function without assigning it to a variable which can be used as inline-function.

(lambda x: x*2)(3)

In [http://en.wikipedia.org/wiki/Clojure Clojure] as a functional language, the creation of a chunk of behavior that can be assigned to a variable (known as a lambda) is trivial. Below are two ways to create a lambda that returns the square of its argument.

(def square1 (fn [n] (* n n)))
(def square2 #(* % %))

===Currying ===

[http://en.wikipedia.org/wiki/Currying Currying] transforms a function that takes multiple parameters into a chain of functions, each taking a single parameter. It reuses a partially applied function where the function is originally defined as accepting n parameters.It can be interpreted as the technique to decompose a function that takes n parameters into n function each of them taking 1 parameter. For example to say in algebraic terms,consider the function f which takes 3 parameters x,y,z and Currying means that we can rewrite the function as a composition of 3 functions:

f(x,y,z) = 4*x+3*y+2*z
f(x)(y)(z) = 2*z+(3*y+(4*x))

In Scala, currying takes advantage of Scala’s syntactic sugar. Below is a currying example in Scala. This function creates a multiplier function which takes two arguments and partially defines it by assigning a constant to one argument and assigning it to a variable .Later the function is called by assigning the second argument.

def multiplier(i: Int)(factor: Int) = i * factor => method named multiplier which takes two parameters is defined
val byFive = multiplier(5) _ => The method is redefined with accepting one parameter and store it in a variable.
val byTen = multiplier(10) _

scala> byFive(2) => Method called by giving the second parameter.
res4: Int = 10

scala> byTen(2)
res5: Int = 20

===Less Verbosity===

In Java each variable should have its type defined beforehand. Whereas in languages like Scala, it is more concise and easier to read than the equivalent Java.

For example, a Map can be created with a simple syntax in Scala,Clojure than in Java:

<table>
<tr>
<td>
'''Java'''
Map<String, Integer> nMap = new HashMap<String, Integer>();
nMap.put("one", 1);
nMap.put("two", 2);
nMap.put("three", 3);
</td>
<td>
'''Scala'''

var nMap = Map("one" -> 1, "two" -> 2, "three" -> 3)

</td>
<td>
'''Clojure'''

(doto (new Java.util.HashMap)(.put “a” 1)(.put “b” 2))

</td>
</tr>
</table>

Here, Scala compiler knows that nMap uses Strings as keys, and Integers as values. Unlike Java, this need not be specified beforehand. Scala could figure it out itself. Moreover, Scala will give an error if a different key-value pair is tried to insert. This is called "type inference". This prevents a whole class of bugs at run time just like Java but with less verbosity.
In a similar way Clojure also involves only few lines of code compared with the object oriented Java language which takes many lines of code.A simple Clojure example and the associated Java code :
Example

(defn blank? [s] (every? #(Character/isWhitespace %) s))

The innermost function Character/isWhiteSpace checks the first argument % for any whitespace and returns true if it is. every? invoke the above inner function for all elements in the collection s.It has no variables, no branches etc.

Java code
isBlank() method checks to see whether a string is blank or contains only whitespace.

public class Stringcheck{
public static boolean isBlank(String str){
int len;
if(str==null || (strlen =str.length())==0)
return true;
for(int i=0; i<strlen;i++) {
if((Character.isWhitespace(str.charAt(i))==false)){
return false;
}
}
return true;
}
}

=== Pattern Matching ===

To say simply, a [http://en.wikipedia.org/wiki/Pattern_matching Pattern matching] is a technique to search string for the occurrence of any patterns or regularity. Pattern matching is an elegant way to decompose objects into their constituent parts for processing.Many languages support the concept of pattern matching. Perl supports pattern matching using the pattern definition mini language called regular expressions, also called regexes or REs, which is borrowed from the regular expressions used in many Unix tools, such as grep() and sed().The risk that the parts of an object might be changed outside of the control of the enclosing object is avoided. For example, if there is a Person class that contains a list of addresses, it will not be an issue to expose that list to clients if the list is immutable. The users will not be able to change the list unexpectedly.Given below is a simple example for pattern matching used in Perl:

$mystring = "Hello world!"; // Perls way of assigning string to a variable.
if($mystring =~ m/World/) { print "Yes"; } // Checks the string stored in variable mystring has the string "World".
$mystring =~ s/world/mom/; // Replaces the string "world" stored in mystring to mom.

Another sample of regular expression in java :

String mystring="Hello World" ;
Pattern str = Pattern.compile("\\w+"); => Pattern stored for matching.
Matcher fit = str.matcher(mystring); => Matcher class which perform matching of the string with the pattern defined.
if(fit.matches())

As languages like Scala and Clojure support procedural code, pattern matching is done as equal or with less difficulty compared with Java which needs to use regex. Scala can even be embedded into XML as its syntax is somewhat similar.Given below an overview of how regular expression is achieved in Clojure.
Data are manipulated in Clojure through the sequence called seq which is a logical list. Clojure can access java collections, its collections, Regular expression matches via the seq also called seq-able. Clojure's regular expression uses java.util.regex library at the lowest level. For achieving that the keyword re-seq is used.
Syntax:
(re-seq regexp string)
Example
(re-seq #"\w+" "Hello World") => ("Hello" "World") => #"\w+" represents the java.util.regex.Pattern

=== Java Interoperability ===
Considering Clojure, it gives clean, simple and direct access to java and can access Java API directly.Clojure doesnot wrap Java's string functions. We can call using Java interop forms. It provides syntax for accessing Java elements like classes, instances, constructors, methods and fields and can also wrap Java API. The “.” dot special form is used for accessing Java. Some Clojure syntax which can access Java API: 

{| class="wikitable" border="2"
|-
! Java
! Clojure
|-
| new Widget(“red”)
| (new Widget “red”)
|-
| Math.PI
| (.Math PI) or Math/PI
|-
| System.currentTimeMillis()
| (.System currentTimeMillis) or System/currentTimeMillis
|-
| rnd.nextInt()
| (.rnd nextInt) or (.nextInt rnd)
|-
|}

Clojure pass functions as arguments to other functions. But Java does not support this. So Clojure provides a member function memfn macro to wrap methods or can use anonymous function to wrap a method call.
(map (memfn toUpperCase) [“a” ,”short”,”message”])
or
(map #(.toUpperCase %)[“a”,”short”,”message”]) => #(body) represents the anonymous function in Clojure.

For example,
(def the-digits
(map #(Integer. (str %))(filter #(Character/isDigit %) (seq big-num-str))))

where (def big-num-str (str "123785334434se9088af8309304293872adbcdfd”))

The above code extracts the integers from string and discards the non-numeric characters. Lets look at the functions defined in the example. There are totally five functions defined.They are
(seq big-num-str) => get each character defined in big-num-str
(Character/isDigit %) => Checks whether the input is an integer
(filter #()) => Filter each string from str
(map #(Integer. (str %))) => Change the string to integer
(def the-digits) => Output the integers only in a string of characters.
Here,
#(Character/isDigit) represents the Java method Character.isDigit() and #(Integer.(str %)) represents the new java.lang.Integer(str(%))

Most of the Clojure library functions have defined semantics for objects of Java types. contains? and .get work on Java’s Maps, arrays, Strings, count works on Java Strings, Collections and arrays. Clojure is built around these aspects. It avails the performance of JVM and the richness of both the core APIs and the numerous third-party libraries written in the Java language and restrained from reinventing them.

=== Multiple Inheritance ===

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance][http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf 2] is the concept of using the methods and variables of more than one superclass to a sub class.Java was designed without multiple inheritance. But Java supports the solution of problems commonly solved with multiple inheritance in other ways with help of interfaces where the methods defined in it are not implemented.In Scala, classes are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance in Java.Lets see how multiple inheritance achieved in Scala:

As interfaces in Java, Scala allows traits but has some methods partially implemented. The only difference to classes is the traits may not have constructor parameters.

trait Similarity {
def isSimilar(x: Any): Boolean // not implemented
def isNotSimilar(x: Any): Boolean = !isSimilar(x) //implemented method
}

This trait defines two methods isSimilar and isNotSimilar where isSimilar does not provide a concrete method implementation (it is abstract in the terminology of Java), and the method isNotSimilar defines a concrete implementation. Consequently, classes that integrate this trait only have to provide a concrete implementation for isSimilar.

class Point(xc: Int, yc: Int) extends Similarity {
var x: Int = xc
var y: Int = yc
def isSimilar(obj: Any) = //need to implement the method here
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
}

object TraitsTest extends Application {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotSimilar(p2))
println(p1.isNotSimilar(p3)) //uses the already defined method
println(p1.isNotSimilar(2))
}

These are some of the aspects and traits of mixing functional and object-oriented approaches. As we discussed in the advantages section, both the approaches have their benefits and limitations. Mixing them aspect-wise enables the above features in such languages. Lets discuss those languages briefly in the next section.

== Languages Supporting Functional and OO code ==

OCaml and F#[[http://msdn.microsoft.com/en-us/library/dd233154.aspx 7]] are some of the languages which support both functional and object oriented programming. OCaml is as fast as C and its featured as [http://www.haskell.org/ Haskell] which is a pure functional language. F#[[http://oreilly.com/catalog/9780596153656 3]] is a dynamically typed language which can run on .NET framework and has supported immutable types i.e. tuples, records, discriminated unions and lists to work in Functional programming. It has functions that can either be in curried or in uncurried form. As in functional language it can pass functions as arguments to other functions, resulting in higher order functions. It also supports lambda functions and closures. F#,behaves like other .NET languages as both in imperative and object oriented style. 

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language and it is a dialect of Lisp. It is not a pure functional language and it is a dynamically typed language. Just like Java it runs on JVM platform. But its syntax differs from Java. It is represented as :

(functions arguments...)

The function followed by its arguments is enclosed in paranthesis. It has features like immutable data structures, high-order functions and recursion, easy and fast java interoperability. 

Python and Ruby are also the programming languages which offer the mix of functional and OO languages. But these languages doesn't support the algebraic data types and pattern matching.

==Conclusion ==
The above aspects of functional and object oriented programming techniques discuss some if their merits and demerits. Mixing them produces a new programming paradigm which leads to a new dimension in programming. A few fundamental concepts are explored in Clojure and Scala here. The ability of Clojure and Scala to run in JVM platform makes them more preferable than others in the market. Some of the merits like closure, less verbosity, high order functions, currying along with interoperation with previously written libraries in these languages make them more efficient and useful. There are also other languages which support functional and object oriented techniques. Mixing the approaches, evolve a new dimension in programming which is practical and opens doors to more exploration.

== References ==

# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-09T22:20:18Z

Dmcarmon: /* Scala */

= Introduction =

= Functional Programming =

Functional programming treats computation as the evaluation of mathematical functions. It is compute-centric rather than data-centric. Functional programming keeps no global state, does not use for or while loops, and data is immutable****. Instead, everything is done using functions, usually functions that evaluate mathematical expressions. Each of these functions maintain no internal state and will always produce the same output given the same input.

Let's look at an example. Suppose we have a list of numbers and we want to multiply each number in the list by 2. The first approach is the imperitive style:

array[] = {1,2,3,4,5}
for(i=0 ; i<array.length; i++){
array[i] = array[i] * 2;
}

In the above example, array[] is a global variable. If we fail to check the array length, then a runtime exception occurs which might result in the program being crashed. As far as functional style, there is a function called map(func,seq)(in python language) where the function 'func' is applied to each member of seq. The following code is written in a functional style.

numbers = [1,2,3,4,5]
/* define a method called compute on each number in the list */
def compute(var):
var = var * 2
return var
/* Now call the map function */
L = map(compute,numbers)
print L // L will print [1,4,6,8,10]

Notice that there is no global data nor any nested loops and the bound checking is handled internally within the map function. The programmer is relieved of of runtime errors and thus can debug the program easily.

Some advantages of this approach are:
* Easier debugging: Since every thing is broken down into small simple functions, the functions are often easy to debug.
* More compact code: Functional programming typically requires fewer lines of code. Since compution is done by function code reuse is prevelent.
* Nothing depends on state: Because functional programs keep no state information, the functions will always operate the same regardless of the past history of the program.

= Object-oriented Programming =
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] (OOP) is a programming paradigm organized around interacting "objects"(usually instances of a class) rather than "actions" and data rather than logic. A basic principle of OOP is that a program consists of a list of subroutines which can perform individually.

An object-oriented programming language provides support for the following object-oriented concepts--object, class, interface and inheritance. To illustrate this idea clearly and vividly let's review the following example-- your limbs. The "Limbs" is a class. Your body has two objects of type "limbs", named arms and legs. Their main functions are controlled/ managed by a set of biological signals sent from central nervous system( through an interface). So the nervous system is an interface which your body uses to interact with your limbs. The "limbs" is a well architected class. The "legs" has a subclass which contains "left leg" and "Right leg". The "legs" is being re-used to create the left leg and right leg by slightly changing the properties of it. If the "legs" owns attributes like length, color of skin etc, then the subclass, which contains "left leg" and "right leg" in this case, automatically inherit these attributes( that is called inheritance).

We could code in object-oriented paradigm as:

class Limbs /*define a class of limbs*/
def initialize(limbs,length,colorofskin)
@limbs=limbs
@length=length
@colorofskin=colorofskin
end
end
limbs=Limbs.new("legs","100cm","white") /*create a new object in class "Limbs"*/
class Legs<Limbs /*create a subclass "Legs",which belong to class"Limbs"*/
def initialize(legs,length,colorofskin)
super(length,colorofskin)
@legs=legs
end
end
legs=legs.new("left leg") /*create a new object in class of "Legs"*/

== Features of Object-oriented Programming ==
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]. A programmer can simply create a new object that inherits many of its features from super-class. And also, they can overwrite existing operations or add new ones.This makes object-oriented programs easier to modify.
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation].This refers to hiding the internal representation of the object from the outside view. You can hide unnecessary implementation details from the object user. One of the benefits of encapsulation is data protection.
* [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism].This allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects. Consider the operator '+', for numbers it will generate the sum, but for strings it will produce a third string which concatenates the input strings.

== Advantages of Object-oriented Programming ==
* Simplicity: we use software objects to simulate real world objects, so the complexity is reduced and the program structure is very clear.
* Modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system.
* Modifiability: programmers can easily make minor changes in the data representation or operations in an OOP. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods.
* Extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones.
* Maintainability: objects can be maintained separately, making locating and fixing problems easier.
* Re-usability: objects can be reused in different programs.

= Mixing Functional and Object-Oriented Programming =

Motivation for Mixing

== Functional Techniques useful for Object-Oriented Programming ==
In object-oriented world, data and operations are grouped together into modular units called objects and we combine objects into structured networks to form a program. The results are depend on arguments and objects' state at method invocation time. While in functional world, the basic elements are variables in the mathematical sense and functions in the mathematical sense. Functional programming can reduce side-effects. If there is no side-effects, it means your can apply the function at anywhere freely. No matter how you apply this function, the same input arguments produce the same results.

According to above-mentioned information, we can perform functional programming on an object-oriented programming language because:
1). object can have constant state
2). method can depend only on its arguments and context available at method definition time

Combining both these paradigms not only provide us a robust design structure, but also enable the programmers to develop solutions to complex problems quickly and effectively. One of the cornerstone of mixing functional and object-oriented code is treating functions as objects.It means that we can pass functions as arguments, store it and return them from other functions. This is highly useful in an user interface code where it can be used as call back functions which gets called when an event occurs(event driven programming).

Some of the basic features of Functional Programming which can be combined with Object Oriented paradigm are:

* Lambda Calculus
* Currying
* Powerful pattern matching

Let us now understand how each of the above feature of Functional language fits in the Object Oriented paradigm.

=== Lambda Calculus ===
Lambda calculus is the most critical basis of functional programming. A lambda expression is an anonymous expression that contain expressions and statements.Each expression stands for a function with one parameter.

Let consider the following function:

def f(x)
return x**2
print f(4)

We can use a lambda calculus to compute this expression without assigning it to a variable:

(lambda x:x**x)(4)

We can see that these two code snippets have the same results. It is more concise and flexible to define with lambda.
The above is a pure functional approach. In order to make code more state-less and concise, lambdas can be embedded inside the object-oriented language. The below code in Python demonstrates the use of lambda in a closure:

def fun(x):
return x%3==0
str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
filter(fun,str)

The above code works to find numbers which are divisible by 3.
We can simplify the code by the use of lambda as following:

str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print filter(lambda x: x%3==0, str)

=== Currying ===

=== Pattern Matching ===

== Examples of Mixing ==

=== Scala ===

[http://www.scala-lang.org/ Scala] is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. [http://www.scala-lang.org/ Scala] was conceived in 2001 and implemented by Martin Odersky. It has a number of features.

==== Statically Typed ====
[http://www.scala-lang.org/ Scala] belongs to the family of languages which encode the type information of each and every variable in the generated code. The compiler makes sure you are not doing something incorrectly. For example, lets consider the following example of code where the type is not encoded,

In [http://www.ruby-lang.org/en/ Ruby],
irb(main):001:0> str="Hello World"
=> "Hello World"
irb(main):002:0> puts str.class
String
irb(main):003:0> str=123
=> 123
irb(main):004:0> puts str.class
Fixnum

In the above example, first we define 'str' variable to be of type String and then as a number. So basically, no type information is associated with the variable at any point in the program. Hence we can easily reassociate that variable with an object/instance
of a different type. This is a feature of all dynamically typed languages(like Ruby, Python, Clojure). However most of the statically typed languages such as Scala, Java, C/C++ do not allow you do so. In [http://www.scala-lang.org/ Scala],

scala> var str="Hello World"
str: java.lang.String = Hello World
scala> str=123
<console>:6: error: type mismatch;
found : Int(123)
required: java.lang.String
str=123

==== Mixed paradigm ====
[http://www.scala-lang.org/ Scala] is a strange specimen. It is a complete blend of object oriented and functional programming. How can this happen? Functional world advocates immutability but object oriented world is all about state and how do you mutate it to fit your needs. [http://www.scala-lang.org/ Scala] allows you create both mutable and immutable objects. Consider the following example,
val str: String = "Hello World"
In the first line, an immutable version(a misnomer indeed) of <code>str</code> is being created . Roughly translating the above line to Java is below:

final String str = "Hello World"; //note the extra semi-colon
Consider the next example below,
val list: List[String] = List("Scala", "is", "the coolest", "language", "in the world!")

The same code can be written in Java as below

List<String> mutableList = new ArrayList<String>();
list.add("Scala");
list.add("is");
list.add("the coolest");
list.add("language");
list.add("in the world!");
List<String> immutableList = Collections.immutableList(mutableList);

Compared to Java, [http://www.scala-lang.org/ Scala] reduces the total number of lines you need to type and at the same time looks so much simpler and less verbose. Even though the above example shows immutable collection example, scala also provides mutable collection and object types under the package <code>scala.collection.mutable.*</code>

As it can be observed, even though [http://www.scala-lang.org/ Scala] advocates immutability, it does not restrict you from creating mutable objects. So its the best of both worlds. Another part of functional world is the concept of functions as ''''first class members'''' of the language. Some of the common languages like Ruby, Python and JavaScript all incorporate this feature. In the sense you can pass around functions to methods as a parameter. Enough talking;

Let us have a class say <code>'Person'</code> which has properties, <code>name</code> and another variable <code>age</code>.
In Java:

class Person{
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String s){
this.name = s;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}

In [http://www.scala-lang.org/ Scala]:
case class Person(name: String, age: Int)

This single line is equivalent to the above java code! Getters for <code>name</code> and <code>age</code>, <code>equals()</code>, and <code>hashCode()</code> method are automatically generated for you by the compiler. Isn't this an awesome feature?

Now assume we have a list of persons and we want to filter out all the persons who are of age 23. How would you do that in Java?

List<Person> persons; //has a bunch of person objects in it.
List<Person> twentyThree = new ArrayList<Person>();
for(Person p: persons){
if(p.getAge() == 23){
twentyThree.add(p);
}
}

In [http://www.scala-lang.org/ Scala]:

val twentyThree: List[Person] = persons.filter( _.age == 23)

That's it! In case you are wondering whats going on, filter is a method present on scala.List class and the code block <code>_.age == 23</code> is a function created on the fly and passed onto the filter method. More precisely its called a [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] - a functional concept which can be emulated in java only using anonymous inner classes. Scala's compiler transforms our one line function into some anonymous inner classes when generating java byte code, allowing developers to define functions in a simple manner.

In fact, every function is an object in [http://www.scala-lang.org/ Scala]. Scala's standard library has a number of functions which are objects themselves.

==== Sophisticated Syntax/Features ====
Sophisticated syntax and features are present in other functional languages like Haskell, (O)Caml and Erlang. Consider the following example,

val name = "Jackie Chan"
println(name.getClass) //prints out String.

Previously we saw that [http://www.scala-lang.org/ Scala] is a statically typed language and yet in the above example we don't specify what type <code>name</code> is. In Java, you would type in the following:

String name = "Jackie Chan"

In Java you specify what type the name variable is, but the [http://www.scala-lang.org/ scala] compiler can automatically detect the type of the variable even if you don't specify it. Consider the following example,

case class Person(name: String, age: Int)
val persons = List(
Person("Jackie Chan", 51), Person("Jet Li", 41),
Person("RajniKanth", 51), Person("Kamal Hasan", 44),
Person("Martin Odersky", 18), Person("Steve Yegge", 23))
//notice that you don't have to use 'new' keyword to create new instances. This is taken care of by the companion objects.

The above lines of code create a list with 6 different persons(An immutable list)

Now, just like ruby, scala supports the concepts of [http://en.wikipedia.org/wiki/Closure_(computer_science) closure]. Let's see what it is.

val twentyThree: List[Person] = persons.filter( { p: Person => p.age == 3})

In the above set of lines, the code within the '{ }' brackets is a function's body. The compiler created a function which takes a single argument and returns either true or false.

==== A Scalable Language ====
In almost all programming languages, there is a necessity to profile the running time of the procedures and tune its performance. The old way of doing things in Java would be:

public class Main{
public static int factorial(int x){
if(x == 0 || x == 1) return 1
else return x * factorial(x-1)
}
public static void main(String [] args){
long beforeTime = System.currentTimeMillis();
int result = factorial(5);
System.out.println("Total time taken to execute factorial(5) is " + (System.currentTimeMillis() - result)+"ms");
System.out.println("factorial(5) = " + result);
}
}

However, if you want to find out the execution time of some other method, you would have to type in all the above lines again. So much for code re-use or [http://en.wikipedia.org/wiki/DRY DRY (dont't repeat yourself)]! Lets see how its done in [http://www.scala-lang.org/ Scala].

object Main{
def main(args: Array[String]){
def factorial(x: Int):Int = x match{
case 0 | 1 => 1
case _ => x * factorial(x-1)
}
import System.currentTimeMillis
def timeIt(msg: String = "Time to execute is: ")(func: => Unit){
val before = currentTimeMillis
func
println(msg + (currentTimeMillis - before) + "ms")
}
timeIt("Total time taken to execute factorial(5) is "){
val result = factorial(5)
println("factorial(5) = " + result)
}
}
//would print: factorial(5) = 120
// Total time taken to execute factorial(5) is 1ms

That's not right! The function <code>timeIt</code> looks like a feature built into the language. Try saving the above code into a separate file and run it - It will still work. Using this feature, it is possible to build powerful DSL languages which can run at full speed on JVM.

Ruby allows you to add new methods to objects. This feature is often called as [http://en.wikipedia.org/wiki/Monkey_patch Monkey Patching] because you are splitting open the class and adding/overriding methods (in)|(to) the class. Often this leads to unexpected behavior at runtime because, other libraries including into build path may depend on some methods which you changed. Scala provides yet another feature called implicits.

In Java, <code>String</code> class is <code>final</code> so there is no way you can add new methods to it. But with implicits you can do more! Suppose you have some text in memory and you know it represents a number. But in Java the usual way to convert string to int is to do a <code>Integer.parseInt(string)</code> which seems so unnecessary. Let us make our lives easier...

implicit def strToInt(str: String) = new {
def asInt = Integer.parseInt(str)
}
val str = "1234"
println(str.asInt * 3) //prints out 3702

The above code gives us an impression as if String class has gained new <code>asInt</code> method. Can static object oriented languages do this? No! Infact scala cheats by calling our implicits to convert it into a different object as and when needed.

The above functionalities are purely object oriented, yet they are safe. They don't pollute the global namespace, unlike Ruby or Python.

=== Ruby ===

Ruby is a dynamically typed Object Oriented Language which supports multiple programming paradigms, including functional, object-oriented, imperative and reflective. In Ruby, everything is an object, every bit of information and code can have its own properties and actions. However, Ruby’s blocks can be functional. A Ruby programmer can attach a closure to any method, which generates a functional block inside an object oriented code. A closure is a piece of code that can access the lexical environment of its definition [http://www.ruby-lang.org/en/ 11].

Consider the following code snippet in Ruby which uses Object Oriented concepts like Classes and functional programming concepts like lambda.

class Multiply
def initialize(n)
@block = lambda {|a| n * a}
end
def mul(a)
@block.call a
end
end
twoMultiplier = Multiply.new 2
puts twoMultiplier.mul(6)

Here,'''''@block''''' is a closure. When we call the class ''Multiply'' using '''''twoAdder = Multiply.new 2''''' ,the ''initialize'' method is called by passing the parameter 2. Here n=2 binds itself to the block. So @block will be 2*a, that is,the closure remembers the parameter with which the initialize method was called even after the initialize method exits.

This value is used when the block is called in the add method.
Thus,'''''twoMultiplier.mul(6)''''' will return 2*6 = 12

Blocks are basically nameless functions which can be passed to a function and then that function can invoke the passed in nameless function. This is a common style called [http://en.wikipedia.org/wiki/Higher-order_function higher order functions] among languages that handle functions as first class objects. Basically blocks can be designed for loop abstraction and lets the user to design their own way of iterating the values, thereby hiding the implementation details.
For example, if we want to iterate backwards from the end to the beginning without revealing its internal implementations, we could implement the loop logic inside the block and pass it to a method or function.

Here is a [http://www.ruby-lang.org/en/ Ruby] implementation of block:

def printlist(array,&reverse)
array.each do |element|
puts "array element: #{element}"
end
reverse.call(array) /* Here it prints the reverse implementation of list*/
end

printlist([1,2,3,4,5,6]) { |array|
array.reverse.each do |element|
puts "array element: #{element}"
end
}
The statements between { } is a block and it gets called by <code>reverse.call(array)</code>within the printlist method.

=== Clojure ===

= Conclusion =

= References =

= Mixing Functional & O-O code =

This chapter deals with the mixing of functional and object-oriented programming paradigms. We start with listing the different programming paradigms available today. We introduce functional and object-oriented approaches briefly and then discuss the advantages of one over the other. Following this, we discuss some aspects and features of mixing both the approaches. Finally, we talk about few languages that constitute such a mix.

== Programming Paradigms Today==

Several programmatic approaches to solve a particular task lead to distinct programming paradigms like, 
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
* Functional programming 
* Object Oriented programming 
* [http://en.wikipedia.org/wiki/Logic_programming Logical programming], etc. 
Lets focus on functional and object oriented programming approaches.

== Functional Programming ==

[http://en.wikipedia.org/wiki/Functional_programming Functional programming] is the task of decomposing a problem into a number of functions. Selectively executing these functions results in the solution to the problem. The functions mostly behave as mathematical. For given set of inputs the program should always return the same output. It usually concentrates on what type of problem we are dealing with rather than on the details of how to solve the problem. For example lets say there is a function which calculates area of a square. If we use it six times then we end up with area of a cube. Thus functional programming helps to build complex systems.

=== Approach ===

Expressions are the collection of variables and operations resulting in a single value this also deals with the way of solving the problem as expressions. Hence also called Expression related programming. It is structured as expression where each expression can be encapsulated in another yielding the result. Making the change in data structures as the program runs is called [http://en.wikipedia.org/wiki/Side_effect_(computer_science) side effects]. Purely functional language has no side effects. Language like Haskell is a pure functional language . Some languages need many approaches for achieving the desired result. Such languages are multi-paradigm. Examples for such languages are C++, Python,Lisp. Its like evaluating an expression and use the resulting value for something.

Structure of functional programming :

(fn2 ( fn1 ()[input list] ) []) => fn1 takes input list and the output of fn1 is used as input to fn2. Its a schematic representation of
how functional programming works.

Functional programming feature (Python) :

m = map(lambda i : i*i , numbers)
where ''numbers'' is an array of numbers and ''lambda'' is [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 closure].

Python has some functions like map, filter, reduce to support functional programming style. In the example above, the 'map' is a high-order function that takes a function and an array of numbers as input. The ''lambda'' takes i as input and returns i*i as output. Every result returned is appended to a list and produced as output. In functional programming, the programmer is given a natural framework for developing smaller, simpler, and more general modules, which are then glued together.

== Object Oriented Programming ==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] is a programming technique where everything is defined as an object. Objects are well-defined discrete bundles of data(attributes) and the associated functions(behavior). They are devised to resemble real-life objects and are uniquely identifiable by a name. The attributes could be of simple datatype(int, String, Boolean) or objects themselves. The behavior is defined by methods to use and manipulate the attributes. The values of attributes of an object at an instant is the state of the object. OO Programming allows objects to have their state retained throughout the code until manipulated otherwise. Objects are capable of housekeeping their own states, interacting and establishing relationships with other objects, inheriting, etc.

=== Fundamental concepts ===

A [http://en.wikipedia.org/wiki/Class_%28computer_science%29 class] is a user-defined datatype that provides implementation details to define the attributes and their properties. It is an abstract representation of an object(i.e.,) like a mold for objects.
An instance is an executable copy of a class. They are the actual objects created using the ‘class mold’ on run time.
Methods are a set of procedural statements or functions to define the behavior of an object, convey the current state, modify values of the attributes, etc.

Example :

An object in Java might look like this:

public class Person {
private String name;
public Person() {
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}

Here, OO Programming allows the programmer to set the ''name'' attribute of the class ''Person'' and get the name whenever needed in the code. An object of this class Person will remain in memory forever as long as there is a reference to it. As OO Programming allows objects to have their state retained, the value of the ''name'' attribute for a particular ''Person'' object remains the same across any part of the code until it is set differently.

=== Features ===

Three primary characteristics of object oriented programming are Encapsulation, Polymorphism, and Inheritance.
[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation] is the ability of objects to hide visibility of their attributes and behavior, thereby providing service independent of implementation.
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects.
[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance] is one where an existing type can be used to derive a new type. Derived types inherit the data and operations of the super-type. And also, they can overwrite existing operations or add new ones.

There are other important features of O-O programming like [http://en.wikipedia.org/wiki/Message_passing message passing], [http://en.wikipedia.org/wiki/Abstraction abstraction], delegation, etc.

Now, we have seen both the approaches and their features in brief. Lets discuss the advantages of one over the other.

== Advantages ==

=== Functional Approach over OO Approach[[http://www.jot.fm/issues/issue_2009_09/article5.pdf 8]]===
* Functional programming solves the problem with lesser number of lines of code than the OO programming style. 
* There is no side effect as they use immutable data structures also called [http://en.wikipedia.org/wiki/Persistent_data_structure Persistent Data Structure] which will have no change in the state of variables. Hence program dont have to depend on history. 
* There is no limit in the numeric types used as opposed to OO languages which mainly depend on primitive data types. 
* A programmer is given the freedom to think in terms of what to solve in the problem rather than concentrating on how to solve and the flow of the program. 
* Suitable for calculation intensive programs.

=== OO Approach over Functional Approach===
* Everything can be represented in an object and it has the attributes associated with it and hence the state of the object is known at any time. 
* A complex system can be subdivided into modules of objects where as in functional approach, many functions inter operate to form a complex system. 
* [http://en.wikipedia.org/wiki/Reusability Re-usability] (i.e.) OO approach enables programmers to create new objects that inherits many of its features from existing objects. This makes object-oriented programs easier to modify than functional. 
* [http://en.wikipedia.org/wiki/Debug Debugging] in Object Oriented environment is easy compared with functional approach where a small error in one function causes the whole system (i.e. all the functions) to fail. 
* Suitable for making application-oriented software. 

Both the approaches have their advantages and disadvantages. What if we could get the best of both the worlds? The next section deals with the aspects and features of how well both the approaches are mixed together in some languages.

== Mixing Functional & OO Code - Best of both the worlds ==

Languages that are a mix of functional and object oriented approaches(eg. Scala[[http://www.scala-lang.org/node/1305 1]], Clojure[[http://oreilly.com/catalog/9781934356333 10]], etc.) make use of best of both the worlds. They support various aspects of functional and object oriented approaches. They have a bunch of functional approach features[[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf 6]], which object oriented programming languages(like Java) lack which includes closures. Closures are first-class functions with free variables that are bound in the lexical environment. These languages also sport a very malleable syntax that makes them well suited for "domain specific languages" with the benefits of static typing. They are more expressive, extensible and allow reuse of programming abstractions.

Certain languages like Scala, Clojure, etc run on Java Virtual Machine(JVM) ensuring portability to all underlying platforms. They even support immutable objects. In Scala, new language constructs can be added in the form of libraries. They allow safe reuse[[http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf 9]] of programming abstractions and type-safe extension of software.

===Lambda===

A lambda[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] expression is an anonymous function that contain expressions and statements, and can be used to create delegates or expression types. Such kind of anonymous function can be defined and passed around as easily as other data types and can be used to contain functionality that need not be named. Some notable examples include closures[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] and currying. Lambda functions with no name can be called using the variable assigned to it.

g = lambda x: x*2
g(3)=6

We can have lambda function without assigning it to a variable which can be used as inline-function.

(lambda x: x*2)(3)

In [http://en.wikipedia.org/wiki/Clojure Clojure] as a functional language, the creation of a chunk of behavior that can be assigned to a variable (known as a lambda) is trivial. Below are two ways to create a lambda that returns the square of its argument.

(def square1 (fn [n] (* n n)))
(def square2 #(* % %))

===Currying ===

[http://en.wikipedia.org/wiki/Currying Currying] transforms a function that takes multiple parameters into a chain of functions, each taking a single parameter. It reuses a partially applied function where the function is originally defined as accepting n parameters.It can be interpreted as the technique to decompose a function that takes n parameters into n function each of them taking 1 parameter. For example to say in algebraic terms,consider the function f which takes 3 parameters x,y,z and Currying means that we can rewrite the function as a composition of 3 functions:

f(x,y,z) = 4*x+3*y+2*z
f(x)(y)(z) = 2*z+(3*y+(4*x))

In Scala, currying takes advantage of Scala’s syntactic sugar. Below is a currying example in Scala. This function creates a multiplier function which takes two arguments and partially defines it by assigning a constant to one argument and assigning it to a variable .Later the function is called by assigning the second argument.

def multiplier(i: Int)(factor: Int) = i * factor => method named multiplier which takes two parameters is defined
val byFive = multiplier(5) _ => The method is redefined with accepting one parameter and store it in a variable.
val byTen = multiplier(10) _

scala> byFive(2) => Method called by giving the second parameter.
res4: Int = 10

scala> byTen(2)
res5: Int = 20

===Less Verbosity===

In Java each variable should have its type defined beforehand. Whereas in languages like Scala, it is more concise and easier to read than the equivalent Java.

For example, a Map can be created with a simple syntax in Scala,Clojure than in Java:

<table>
<tr>
<td>
'''Java'''
Map<String, Integer> nMap = new HashMap<String, Integer>();
nMap.put("one", 1);
nMap.put("two", 2);
nMap.put("three", 3);
</td>
<td>
'''Scala'''

var nMap = Map("one" -> 1, "two" -> 2, "three" -> 3)

</td>
<td>
'''Clojure'''

(doto (new Java.util.HashMap)(.put “a” 1)(.put “b” 2))

</td>
</tr>
</table>

Here, Scala compiler knows that nMap uses Strings as keys, and Integers as values. Unlike Java, this need not be specified beforehand. Scala could figure it out itself. Moreover, Scala will give an error if a different key-value pair is tried to insert. This is called "type inference". This prevents a whole class of bugs at run time just like Java but with less verbosity.
In a similar way Clojure also involves only few lines of code compared with the object oriented Java language which takes many lines of code.A simple Clojure example and the associated Java code :
Example

(defn blank? [s] (every? #(Character/isWhitespace %) s))

The innermost function Character/isWhiteSpace checks the first argument % for any whitespace and returns true if it is. every? invoke the above inner function for all elements in the collection s.It has no variables, no branches etc.

Java code
isBlank() method checks to see whether a string is blank or contains only whitespace.

public class Stringcheck{
public static boolean isBlank(String str){
int len;
if(str==null || (strlen =str.length())==0)
return true;
for(int i=0; i<strlen;i++) {
if((Character.isWhitespace(str.charAt(i))==false)){
return false;
}
}
return true;
}
}

=== Pattern Matching ===

To say simply, a [http://en.wikipedia.org/wiki/Pattern_matching Pattern matching] is a technique to search string for the occurrence of any patterns or regularity. Pattern matching is an elegant way to decompose objects into their constituent parts for processing.Many languages support the concept of pattern matching. Perl supports pattern matching using the pattern definition mini language called regular expressions, also called regexes or REs, which is borrowed from the regular expressions used in many Unix tools, such as grep() and sed().The risk that the parts of an object might be changed outside of the control of the enclosing object is avoided. For example, if there is a Person class that contains a list of addresses, it will not be an issue to expose that list to clients if the list is immutable. The users will not be able to change the list unexpectedly.Given below is a simple example for pattern matching used in Perl:

$mystring = "Hello world!"; // Perls way of assigning string to a variable.
if($mystring =~ m/World/) { print "Yes"; } // Checks the string stored in variable mystring has the string "World".
$mystring =~ s/world/mom/; // Replaces the string "world" stored in mystring to mom.

Another sample of regular expression in java :

String mystring="Hello World" ;
Pattern str = Pattern.compile("\\w+"); => Pattern stored for matching.
Matcher fit = str.matcher(mystring); => Matcher class which perform matching of the string with the pattern defined.
if(fit.matches())

As languages like Scala and Clojure support procedural code, pattern matching is done as equal or with less difficulty compared with Java which needs to use regex. Scala can even be embedded into XML as its syntax is somewhat similar.Given below an overview of how regular expression is achieved in Clojure.
Data are manipulated in Clojure through the sequence called seq which is a logical list. Clojure can access java collections, its collections, Regular expression matches via the seq also called seq-able. Clojure's regular expression uses java.util.regex library at the lowest level. For achieving that the keyword re-seq is used.
Syntax:
(re-seq regexp string)
Example
(re-seq #"\w+" "Hello World") => ("Hello" "World") => #"\w+" represents the java.util.regex.Pattern

=== Java Interoperability ===
Considering Clojure, it gives clean, simple and direct access to java and can access Java API directly.Clojure doesnot wrap Java's string functions. We can call using Java interop forms. It provides syntax for accessing Java elements like classes, instances, constructors, methods and fields and can also wrap Java API. The “.” dot special form is used for accessing Java. Some Clojure syntax which can access Java API: 

{| class="wikitable" border="2"
|-
! Java
! Clojure
|-
| new Widget(“red”)
| (new Widget “red”)
|-
| Math.PI
| (.Math PI) or Math/PI
|-
| System.currentTimeMillis()
| (.System currentTimeMillis) or System/currentTimeMillis
|-
| rnd.nextInt()
| (.rnd nextInt) or (.nextInt rnd)
|-
|}

Clojure pass functions as arguments to other functions. But Java does not support this. So Clojure provides a member function memfn macro to wrap methods or can use anonymous function to wrap a method call.
(map (memfn toUpperCase) [“a” ,”short”,”message”])
or
(map #(.toUpperCase %)[“a”,”short”,”message”]) => #(body) represents the anonymous function in Clojure.

For example,
(def the-digits
(map #(Integer. (str %))(filter #(Character/isDigit %) (seq big-num-str))))

where (def big-num-str (str "123785334434se9088af8309304293872adbcdfd”))

The above code extracts the integers from string and discards the non-numeric characters. Lets look at the functions defined in the example. There are totally five functions defined.They are
(seq big-num-str) => get each character defined in big-num-str
(Character/isDigit %) => Checks whether the input is an integer
(filter #()) => Filter each string from str
(map #(Integer. (str %))) => Change the string to integer
(def the-digits) => Output the integers only in a string of characters.
Here,
#(Character/isDigit) represents the Java method Character.isDigit() and #(Integer.(str %)) represents the new java.lang.Integer(str(%))

Most of the Clojure library functions have defined semantics for objects of Java types. contains? and .get work on Java’s Maps, arrays, Strings, count works on Java Strings, Collections and arrays. Clojure is built around these aspects. It avails the performance of JVM and the richness of both the core APIs and the numerous third-party libraries written in the Java language and restrained from reinventing them.

=== Multiple Inheritance ===

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance][http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf 2] is the concept of using the methods and variables of more than one superclass to a sub class.Java was designed without multiple inheritance. But Java supports the solution of problems commonly solved with multiple inheritance in other ways with help of interfaces where the methods defined in it are not implemented.In Scala, classes are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance in Java.Lets see how multiple inheritance achieved in Scala:

As interfaces in Java, Scala allows traits but has some methods partially implemented. The only difference to classes is the traits may not have constructor parameters.

trait Similarity {
def isSimilar(x: Any): Boolean // not implemented
def isNotSimilar(x: Any): Boolean = !isSimilar(x) //implemented method
}

This trait defines two methods isSimilar and isNotSimilar where isSimilar does not provide a concrete method implementation (it is abstract in the terminology of Java), and the method isNotSimilar defines a concrete implementation. Consequently, classes that integrate this trait only have to provide a concrete implementation for isSimilar.

class Point(xc: Int, yc: Int) extends Similarity {
var x: Int = xc
var y: Int = yc
def isSimilar(obj: Any) = //need to implement the method here
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
}

object TraitsTest extends Application {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotSimilar(p2))
println(p1.isNotSimilar(p3)) //uses the already defined method
println(p1.isNotSimilar(2))
}

These are some of the aspects and traits of mixing functional and object-oriented approaches. As we discussed in the advantages section, both the approaches have their benefits and limitations. Mixing them aspect-wise enables the above features in such languages. Lets discuss those languages briefly in the next section.

== Languages Supporting Functional and OO code ==

OCaml and F#[[http://msdn.microsoft.com/en-us/library/dd233154.aspx 7]] are some of the languages which support both functional and object oriented programming. OCaml is as fast as C and its featured as [http://www.haskell.org/ Haskell] which is a pure functional language. F#[[http://oreilly.com/catalog/9780596153656 3]] is a dynamically typed language which can run on .NET framework and has supported immutable types i.e. tuples, records, discriminated unions and lists to work in Functional programming. It has functions that can either be in curried or in uncurried form. As in functional language it can pass functions as arguments to other functions, resulting in higher order functions. It also supports lambda functions and closures. F#,behaves like other .NET languages as both in imperative and object oriented style. 

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language and it is a dialect of Lisp. It is not a pure functional language and it is a dynamically typed language. Just like Java it runs on JVM platform. But its syntax differs from Java. It is represented as :

(functions arguments...)

The function followed by its arguments is enclosed in paranthesis. It has features like immutable data structures, high-order functions and recursion, easy and fast java interoperability. 

Python and Ruby are also the programming languages which offer the mix of functional and OO languages. But these languages doesn't support the algebraic data types and pattern matching.

==Conclusion ==
The above aspects of functional and object oriented programming techniques discuss some if their merits and demerits. Mixing them produces a new programming paradigm which leads to a new dimension in programming. A few fundamental concepts are explored in Clojure and Scala here. The ability of Clojure and Scala to run in JVM platform makes them more preferable than others in the market. Some of the merits like closure, less verbosity, high order functions, currying along with interoperation with previously written libraries in these languages make them more efficient and useful. There are also other languages which support functional and object oriented techniques. Mixing the approaches, evolve a new dimension in programming which is practical and opens doors to more exploration.

== References ==

# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-09T22:18:12Z

Dmcarmon: Added Ruby section and modified Scala section

= Introduction =

= Functional Programming =

Functional programming treats computation as the evaluation of mathematical functions. It is compute-centric rather than data-centric. Functional programming keeps no global state, does not use for or while loops, and data is immutable****. Instead, everything is done using functions, usually functions that evaluate mathematical expressions. Each of these functions maintain no internal state and will always produce the same output given the same input.

Let's look at an example. Suppose we have a list of numbers and we want to multiply each number in the list by 2. The first approach is the imperitive style:

array[] = {1,2,3,4,5}
for(i=0 ; i<array.length; i++){
array[i] = array[i] * 2;
}

In the above example, array[] is a global variable. If we fail to check the array length, then a runtime exception occurs which might result in the program being crashed. As far as functional style, there is a function called map(func,seq)(in python language) where the function 'func' is applied to each member of seq. The following code is written in a functional style.

numbers = [1,2,3,4,5]
/* define a method called compute on each number in the list */
def compute(var):
var = var * 2
return var
/* Now call the map function */
L = map(compute,numbers)
print L // L will print [1,4,6,8,10]

Notice that there is no global data nor any nested loops and the bound checking is handled internally within the map function. The programmer is relieved of of runtime errors and thus can debug the program easily.

Some advantages of this approach are:
* Easier debugging: Since every thing is broken down into small simple functions, the functions are often easy to debug.
* More compact code: Functional programming typically requires fewer lines of code. Since compution is done by function code reuse is prevelent.
* Nothing depends on state: Because functional programs keep no state information, the functions will always operate the same regardless of the past history of the program.

= Object-oriented Programming =
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] (OOP) is a programming paradigm organized around interacting "objects"(usually instances of a class) rather than "actions" and data rather than logic. A basic principle of OOP is that a program consists of a list of subroutines which can perform individually.

An object-oriented programming language provides support for the following object-oriented concepts--object, class, interface and inheritance. To illustrate this idea clearly and vividly let's review the following example-- your limbs. The "Limbs" is a class. Your body has two objects of type "limbs", named arms and legs. Their main functions are controlled/ managed by a set of biological signals sent from central nervous system( through an interface). So the nervous system is an interface which your body uses to interact with your limbs. The "limbs" is a well architected class. The "legs" has a subclass which contains "left leg" and "Right leg". The "legs" is being re-used to create the left leg and right leg by slightly changing the properties of it. If the "legs" owns attributes like length, color of skin etc, then the subclass, which contains "left leg" and "right leg" in this case, automatically inherit these attributes( that is called inheritance).

We could code in object-oriented paradigm as:

class Limbs /*define a class of limbs*/
def initialize(limbs,length,colorofskin)
@limbs=limbs
@length=length
@colorofskin=colorofskin
end
end
limbs=Limbs.new("legs","100cm","white") /*create a new object in class "Limbs"*/
class Legs<Limbs /*create a subclass "Legs",which belong to class"Limbs"*/
def initialize(legs,length,colorofskin)
super(length,colorofskin)
@legs=legs
end
end
legs=legs.new("left leg") /*create a new object in class of "Legs"*/

== Features of Object-oriented Programming ==
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]. A programmer can simply create a new object that inherits many of its features from super-class. And also, they can overwrite existing operations or add new ones.This makes object-oriented programs easier to modify.
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation].This refers to hiding the internal representation of the object from the outside view. You can hide unnecessary implementation details from the object user. One of the benefits of encapsulation is data protection.
* [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism].This allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects. Consider the operator '+', for numbers it will generate the sum, but for strings it will produce a third string which concatenates the input strings.

== Advantages of Object-oriented Programming ==
* Simplicity: we use software objects to simulate real world objects, so the complexity is reduced and the program structure is very clear.
* Modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system.
* Modifiability: programmers can easily make minor changes in the data representation or operations in an OOP. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods.
* Extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones.
* Maintainability: objects can be maintained separately, making locating and fixing problems easier.
* Re-usability: objects can be reused in different programs.

= Mixing Functional and Object-Oriented Programming =

Motivation for Mixing

== Functional Techniques useful for Object-Oriented Programming ==
In object-oriented world, data and operations are grouped together into modular units called objects and we combine objects into structured networks to form a program. The results are depend on arguments and objects' state at method invocation time. While in functional world, the basic elements are variables in the mathematical sense and functions in the mathematical sense. Functional programming can reduce side-effects. If there is no side-effects, it means your can apply the function at anywhere freely. No matter how you apply this function, the same input arguments produce the same results.

According to above-mentioned information, we can perform functional programming on an object-oriented programming language because:
1). object can have constant state
2). method can depend only on its arguments and context available at method definition time

Combining both these paradigms not only provide us a robust design structure, but also enable the programmers to develop solutions to complex problems quickly and effectively. One of the cornerstone of mixing functional and object-oriented code is treating functions as objects.It means that we can pass functions as arguments, store it and return them from other functions. This is highly useful in an user interface code where it can be used as call back functions which gets called when an event occurs(event driven programming).

Some of the basic features of Functional Programming which can be combined with Object Oriented paradigm are:

* Lambda Calculus
* Currying
* Powerful pattern matching

Let us now understand how each of the above feature of Functional language fits in the Object Oriented paradigm.

=== Lambda Calculus ===
Lambda calculus is the most critical basis of functional programming. A lambda expression is an anonymous expression that contain expressions and statements.Each expression stands for a function with one parameter.

Let consider the following function:

def f(x)
return x**2
print f(4)

We can use a lambda calculus to compute this expression without assigning it to a variable:

(lambda x:x**x)(4)

We can see that these two code snippets have the same results. It is more concise and flexible to define with lambda.
The above is a pure functional approach. In order to make code more state-less and concise, lambdas can be embedded inside the object-oriented language. The below code in Python demonstrates the use of lambda in a closure:

def fun(x):
return x%3==0
str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
filter(fun,str)

The above code works to find numbers which are divisible by 3.
We can simplify the code by the use of lambda as following:

str=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print filter(lambda x: x%3==0, str)

=== Currying ===

=== Pattern Matching ===

== Examples of Mixing ==

=== Scala ===

[http://www.scala-lang.org/ Scala] is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. [http://www.scala-lang.org/ Scala] was conceived in 2001 and implemented by Martin Odersky.

==== Features ====
===== Statically Typed =====
[http://www.scala-lang.org/ Scala] belongs to the family of languages which encode the type information of each and every variable in the generated code. The compiler makes sure you are not doing something incorrectly. For example, lets consider the following example of code where the type is not encoded,

In [http://www.ruby-lang.org/en/ Ruby],
irb(main):001:0> str="Hello World"
=> "Hello World"
irb(main):002:0> puts str.class
String
irb(main):003:0> str=123
=> 123
irb(main):004:0> puts str.class
Fixnum

In the above example, first we define 'str' variable to be of type String and then as a number. So basically, no type information is associated with the variable at any point in the program. Hence we can easily reassociate that variable with an object/instance
of a different type. This is a feature of all dynamically typed languages(like Ruby, Python, Clojure). However most of the statically typed languages such as Scala, Java, C/C++ do not allow you do so. In [http://www.scala-lang.org/ Scala],

scala> var str="Hello World"
str: java.lang.String = Hello World
scala> str=123
<console>:6: error: type mismatch;
found : Int(123)
required: java.lang.String
str=123

===== Mixed paradigm =====
[http://www.scala-lang.org/ Scala] is a strange specimen. It is a complete blend of object oriented and functional programming. How can this happen? Functional world advocates immutability but object oriented world is all about state and how do you mutate it to fit your needs. [http://www.scala-lang.org/ Scala] allows you create both mutable and immutable objects. Consider the following example,
val str: String = "Hello World"
In the first line, an immutable version(a misnomer indeed) of <code>str</code> is being created . Roughly translating the above line to Java is below:

final String str = "Hello World"; //note the extra semi-colon
Consider the next example below,
val list: List[String] = List("Scala", "is", "the coolest", "language", "in the world!")

The same code can be written in Java as below

List<String> mutableList = new ArrayList<String>();
list.add("Scala");
list.add("is");
list.add("the coolest");
list.add("language");
list.add("in the world!");
List<String> immutableList = Collections.immutableList(mutableList);

Compared to Java, [http://www.scala-lang.org/ Scala] reduces the total number of lines you need to type and at the same time looks so much simpler and less verbose. Even though the above example shows immutable collection example, scala also provides mutable collection and object types under the package <code>scala.collection.mutable.*</code>

As it can be observed, even though [http://www.scala-lang.org/ Scala] advocates immutability, it does not restrict you from creating mutable objects. So its the best of both worlds. Another part of functional world is the concept of functions as ''''first class members'''' of the language. Some of the common languages like Ruby, Python and JavaScript all incorporate this feature. In the sense you can pass around functions to methods as a parameter. Enough talking;

Let us have a class say <code>'Person'</code> which has properties, <code>name</code> and another variable <code>age</code>.
In Java:

class Person{
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String s){
this.name = s;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}

In [http://www.scala-lang.org/ Scala]:
case class Person(name: String, age: Int)

This single line is equivalent to the above java code! Getters for <code>name</code> and <code>age</code>, <code>equals()</code>, and <code>hashCode()</code> method are automatically generated for you by the compiler. Isn't this an awesome feature?

Now assume we have a list of persons and we want to filter out all the persons who are of age 23. How would you do that in Java?

List<Person> persons; //has a bunch of person objects in it.
List<Person> twentyThree = new ArrayList<Person>();
for(Person p: persons){
if(p.getAge() == 23){
twentyThree.add(p);
}
}

In [http://www.scala-lang.org/ Scala]:

val twentyThree: List[Person] = persons.filter( _.age == 23)

That's it! In case you are wondering whats going on, filter is a method present on scala.List class and the code block <code>_.age == 23</code> is a function created on the fly and passed onto the filter method. More precisely its called a [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] - a functional concept which can be emulated in java only using anonymous inner classes. Scala's compiler transforms our one line function into some anonymous inner classes when generating java byte code, allowing developers to define functions in a simple manner.

In fact, every function is an object in [http://www.scala-lang.org/ Scala]. Scala's standard library has a number of functions which are objects themselves.

===== Sophisticated Syntax/Features =====
Sophisticated syntax and features are present in other functional languages like Haskell, (O)Caml and Erlang. Consider the following example,

val name = "Jackie Chan"
println(name.getClass) //prints out String.

Previously we saw that [http://www.scala-lang.org/ Scala] is a statically typed language and yet in the above example we don't specify what type <code>name</code> is. In Java, you would type in the following:

String name = "Jackie Chan"

In Java you specify what type the name variable is, but the [http://www.scala-lang.org/ scala] compiler can automatically detect the type of the variable even if you don't specify it. Consider the following example,

case class Person(name: String, age: Int)
val persons = List(
Person("Jackie Chan", 51), Person("Jet Li", 41),
Person("RajniKanth", 51), Person("Kamal Hasan", 44),
Person("Martin Odersky", 18), Person("Steve Yegge", 23))
//notice that you don't have to use 'new' keyword to create new instances. This is taken care of by the companion objects.

The above lines of code create a list with 6 different persons(An immutable list)

Now, just like ruby, scala supports the concepts of [http://en.wikipedia.org/wiki/Closure_(computer_science) closure]. Let's see what it is.

val twentyThree: List[Person] = persons.filter( { p: Person => p.age == 3})

In the above set of lines, the code within the '{ }' brackets is a function's body. The compiler created a function which takes a single argument and returns either true or false.

===== A Scalable Language =====
In almost all programming languages, there is a necessity to profile the running time of the procedures and tune its performance. The old way of doing things in Java would be:

public class Main{
public static int factorial(int x){
if(x == 0 || x == 1) return 1
else return x * factorial(x-1)
}
public static void main(String [] args){
long beforeTime = System.currentTimeMillis();
int result = factorial(5);
System.out.println("Total time taken to execute factorial(5) is " + (System.currentTimeMillis() - result)+"ms");
System.out.println("factorial(5) = " + result);
}
}

However, if you want to find out the execution time of some other method, you would have to type in all the above lines again. So much for code re-use or [http://en.wikipedia.org/wiki/DRY DRY (dont't repeat yourself)]! Lets see how its done in [http://www.scala-lang.org/ Scala].

object Main{
def main(args: Array[String]){
def factorial(x: Int):Int = x match{
case 0 | 1 => 1
case _ => x * factorial(x-1)
}
import System.currentTimeMillis
def timeIt(msg: String = "Time to execute is: ")(func: => Unit){
val before = currentTimeMillis
func
println(msg + (currentTimeMillis - before) + "ms")
}
timeIt("Total time taken to execute factorial(5) is "){
val result = factorial(5)
println("factorial(5) = " + result)
}
}
//would print: factorial(5) = 120
// Total time taken to execute factorial(5) is 1ms

That's not right! The function <code>timeIt</code> looks like a feature built into the language. Try saving the above code into a separate file and run it - It will still work. Using this feature, it is possible to build powerful DSL languages which can run at full speed on JVM.

Ruby allows you to add new methods to objects. This feature is often called as [http://en.wikipedia.org/wiki/Monkey_patch Monkey Patching] because you are splitting open the class and adding/overriding methods (in)|(to) the class. Often this leads to unexpected behavior at runtime because, other libraries including into build path may depend on some methods which you changed. Scala provides yet another feature called implicits.

In Java, <code>String</code> class is <code>final</code> so there is no way you can add new methods to it. But with implicits you can do more! Suppose you have some text in memory and you know it represents a number. But in Java the usual way to convert string to int is to do a <code>Integer.parseInt(string)</code> which seems so unnecessary. Let us make our lives easier...

implicit def strToInt(str: String) = new {
def asInt = Integer.parseInt(str)
}
val str = "1234"
println(str.asInt * 3) //prints out 3702

The above code gives us an impression as if String class has gained new <code>asInt</code> method. Can static object oriented languages do this? No! Infact scala cheats by calling our implicits to convert it into a different object as and when needed.

The above functionalities are purely object oriented, yet they are safe. They don't pollute the global namespace, unlike Ruby or Python.

=== Ruby ===

Ruby is a dynamically typed Object Oriented Language which supports multiple programming paradigms, including functional, object-oriented, imperative and reflective. In Ruby, everything is an object, every bit of information and code can have its own properties and actions. However, Ruby’s blocks can be functional. A Ruby programmer can attach a closure to any method, which generates a functional block inside an object oriented code. A closure is a piece of code that can access the lexical environment of its definition [http://www.ruby-lang.org/en/ 11].

Consider the following code snippet in Ruby which uses Object Oriented concepts like Classes and functional programming concepts like lambda.

class Multiply
def initialize(n)
@block = lambda {|a| n * a}
end
def mul(a)
@block.call a
end
end
twoMultiplier = Multiply.new 2
puts twoMultiplier.mul(6)

Here,'''''@block''''' is a closure. When we call the class ''Multiply'' using '''''twoAdder = Multiply.new 2''''' ,the ''initialize'' method is called by passing the parameter 2. Here n=2 binds itself to the block. So @block will be 2*a, that is,the closure remembers the parameter with which the initialize method was called even after the initialize method exits.

This value is used when the block is called in the add method.
Thus,'''''twoMultiplier.mul(6)''''' will return 2*6 = 12

Blocks are basically nameless functions which can be passed to a function and then that function can invoke the passed in nameless function. This is a common style called [http://en.wikipedia.org/wiki/Higher-order_function higher order functions] among languages that handle functions as first class objects. Basically blocks can be designed for loop abstraction and lets the user to design their own way of iterating the values, thereby hiding the implementation details.
For example, if we want to iterate backwards from the end to the beginning without revealing its internal implementations, we could implement the loop logic inside the block and pass it to a method or function.

Here is a [http://www.ruby-lang.org/en/ Ruby] implementation of block:

def printlist(array,&reverse)
array.each do |element|
puts "array element: #{element}"
end
reverse.call(array) /* Here it prints the reverse implementation of list*/
end

printlist([1,2,3,4,5,6]) { |array|
array.reverse.each do |element|
puts "array element: #{element}"
end
}
The statements between { } is a block and it gets called by <code>reverse.call(array)</code>within the printlist method.

=== Clojure ===

= Conclusion =

= References =

= Mixing Functional & O-O code =

This chapter deals with the mixing of functional and object-oriented programming paradigms. We start with listing the different programming paradigms available today. We introduce functional and object-oriented approaches briefly and then discuss the advantages of one over the other. Following this, we discuss some aspects and features of mixing both the approaches. Finally, we talk about few languages that constitute such a mix.

== Programming Paradigms Today==

Several programmatic approaches to solve a particular task lead to distinct programming paradigms like, 
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
* Functional programming 
* Object Oriented programming 
* [http://en.wikipedia.org/wiki/Logic_programming Logical programming], etc. 
Lets focus on functional and object oriented programming approaches.

== Functional Programming ==

[http://en.wikipedia.org/wiki/Functional_programming Functional programming] is the task of decomposing a problem into a number of functions. Selectively executing these functions results in the solution to the problem. The functions mostly behave as mathematical. For given set of inputs the program should always return the same output. It usually concentrates on what type of problem we are dealing with rather than on the details of how to solve the problem. For example lets say there is a function which calculates area of a square. If we use it six times then we end up with area of a cube. Thus functional programming helps to build complex systems.

=== Approach ===

Expressions are the collection of variables and operations resulting in a single value this also deals with the way of solving the problem as expressions. Hence also called Expression related programming. It is structured as expression where each expression can be encapsulated in another yielding the result. Making the change in data structures as the program runs is called [http://en.wikipedia.org/wiki/Side_effect_(computer_science) side effects]. Purely functional language has no side effects. Language like Haskell is a pure functional language . Some languages need many approaches for achieving the desired result. Such languages are multi-paradigm. Examples for such languages are C++, Python,Lisp. Its like evaluating an expression and use the resulting value for something.

Structure of functional programming :

(fn2 ( fn1 ()[input list] ) []) => fn1 takes input list and the output of fn1 is used as input to fn2. Its a schematic representation of
how functional programming works.

Functional programming feature (Python) :

m = map(lambda i : i*i , numbers)
where ''numbers'' is an array of numbers and ''lambda'' is [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 closure].

Python has some functions like map, filter, reduce to support functional programming style. In the example above, the 'map' is a high-order function that takes a function and an array of numbers as input. The ''lambda'' takes i as input and returns i*i as output. Every result returned is appended to a list and produced as output. In functional programming, the programmer is given a natural framework for developing smaller, simpler, and more general modules, which are then glued together.

== Object Oriented Programming ==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] is a programming technique where everything is defined as an object. Objects are well-defined discrete bundles of data(attributes) and the associated functions(behavior). They are devised to resemble real-life objects and are uniquely identifiable by a name. The attributes could be of simple datatype(int, String, Boolean) or objects themselves. The behavior is defined by methods to use and manipulate the attributes. The values of attributes of an object at an instant is the state of the object. OO Programming allows objects to have their state retained throughout the code until manipulated otherwise. Objects are capable of housekeeping their own states, interacting and establishing relationships with other objects, inheriting, etc.

=== Fundamental concepts ===

A [http://en.wikipedia.org/wiki/Class_%28computer_science%29 class] is a user-defined datatype that provides implementation details to define the attributes and their properties. It is an abstract representation of an object(i.e.,) like a mold for objects.
An instance is an executable copy of a class. They are the actual objects created using the ‘class mold’ on run time.
Methods are a set of procedural statements or functions to define the behavior of an object, convey the current state, modify values of the attributes, etc.

Example :

An object in Java might look like this:

public class Person {
private String name;
public Person() {
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}

Here, OO Programming allows the programmer to set the ''name'' attribute of the class ''Person'' and get the name whenever needed in the code. An object of this class Person will remain in memory forever as long as there is a reference to it. As OO Programming allows objects to have their state retained, the value of the ''name'' attribute for a particular ''Person'' object remains the same across any part of the code until it is set differently.

=== Features ===

Three primary characteristics of object oriented programming are Encapsulation, Polymorphism, and Inheritance.
[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation] is the ability of objects to hide visibility of their attributes and behavior, thereby providing service independent of implementation.
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects.
[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance] is one where an existing type can be used to derive a new type. Derived types inherit the data and operations of the super-type. And also, they can overwrite existing operations or add new ones.

There are other important features of O-O programming like [http://en.wikipedia.org/wiki/Message_passing message passing], [http://en.wikipedia.org/wiki/Abstraction abstraction], delegation, etc.

Now, we have seen both the approaches and their features in brief. Lets discuss the advantages of one over the other.

== Advantages ==

=== Functional Approach over OO Approach[[http://www.jot.fm/issues/issue_2009_09/article5.pdf 8]]===
* Functional programming solves the problem with lesser number of lines of code than the OO programming style. 
* There is no side effect as they use immutable data structures also called [http://en.wikipedia.org/wiki/Persistent_data_structure Persistent Data Structure] which will have no change in the state of variables. Hence program dont have to depend on history. 
* There is no limit in the numeric types used as opposed to OO languages which mainly depend on primitive data types. 
* A programmer is given the freedom to think in terms of what to solve in the problem rather than concentrating on how to solve and the flow of the program. 
* Suitable for calculation intensive programs.

=== OO Approach over Functional Approach===
* Everything can be represented in an object and it has the attributes associated with it and hence the state of the object is known at any time. 
* A complex system can be subdivided into modules of objects where as in functional approach, many functions inter operate to form a complex system. 
* [http://en.wikipedia.org/wiki/Reusability Re-usability] (i.e.) OO approach enables programmers to create new objects that inherits many of its features from existing objects. This makes object-oriented programs easier to modify than functional. 
* [http://en.wikipedia.org/wiki/Debug Debugging] in Object Oriented environment is easy compared with functional approach where a small error in one function causes the whole system (i.e. all the functions) to fail. 
* Suitable for making application-oriented software. 

Both the approaches have their advantages and disadvantages. What if we could get the best of both the worlds? The next section deals with the aspects and features of how well both the approaches are mixed together in some languages.

== Mixing Functional & OO Code - Best of both the worlds ==

Languages that are a mix of functional and object oriented approaches(eg. Scala[[http://www.scala-lang.org/node/1305 1]], Clojure[[http://oreilly.com/catalog/9781934356333 10]], etc.) make use of best of both the worlds. They support various aspects of functional and object oriented approaches. They have a bunch of functional approach features[[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf 6]], which object oriented programming languages(like Java) lack which includes closures. Closures are first-class functions with free variables that are bound in the lexical environment. These languages also sport a very malleable syntax that makes them well suited for "domain specific languages" with the benefits of static typing. They are more expressive, extensible and allow reuse of programming abstractions.

Certain languages like Scala, Clojure, etc run on Java Virtual Machine(JVM) ensuring portability to all underlying platforms. They even support immutable objects. In Scala, new language constructs can be added in the form of libraries. They allow safe reuse[[http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf 9]] of programming abstractions and type-safe extension of software.

===Lambda===

A lambda[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] expression is an anonymous function that contain expressions and statements, and can be used to create delegates or expression types. Such kind of anonymous function can be defined and passed around as easily as other data types and can be used to contain functionality that need not be named. Some notable examples include closures[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] and currying. Lambda functions with no name can be called using the variable assigned to it.

g = lambda x: x*2
g(3)=6

We can have lambda function without assigning it to a variable which can be used as inline-function.

(lambda x: x*2)(3)

In [http://en.wikipedia.org/wiki/Clojure Clojure] as a functional language, the creation of a chunk of behavior that can be assigned to a variable (known as a lambda) is trivial. Below are two ways to create a lambda that returns the square of its argument.

(def square1 (fn [n] (* n n)))
(def square2 #(* % %))

===Currying ===

[http://en.wikipedia.org/wiki/Currying Currying] transforms a function that takes multiple parameters into a chain of functions, each taking a single parameter. It reuses a partially applied function where the function is originally defined as accepting n parameters.It can be interpreted as the technique to decompose a function that takes n parameters into n function each of them taking 1 parameter. For example to say in algebraic terms,consider the function f which takes 3 parameters x,y,z and Currying means that we can rewrite the function as a composition of 3 functions:

f(x,y,z) = 4*x+3*y+2*z
f(x)(y)(z) = 2*z+(3*y+(4*x))

In Scala, currying takes advantage of Scala’s syntactic sugar. Below is a currying example in Scala. This function creates a multiplier function which takes two arguments and partially defines it by assigning a constant to one argument and assigning it to a variable .Later the function is called by assigning the second argument.

def multiplier(i: Int)(factor: Int) = i * factor => method named multiplier which takes two parameters is defined
val byFive = multiplier(5) _ => The method is redefined with accepting one parameter and store it in a variable.
val byTen = multiplier(10) _

scala> byFive(2) => Method called by giving the second parameter.
res4: Int = 10

scala> byTen(2)
res5: Int = 20

===Less Verbosity===

In Java each variable should have its type defined beforehand. Whereas in languages like Scala, it is more concise and easier to read than the equivalent Java.

For example, a Map can be created with a simple syntax in Scala,Clojure than in Java:

<table>
<tr>
<td>
'''Java'''
Map<String, Integer> nMap = new HashMap<String, Integer>();
nMap.put("one", 1);
nMap.put("two", 2);
nMap.put("three", 3);
</td>
<td>
'''Scala'''

var nMap = Map("one" -> 1, "two" -> 2, "three" -> 3)

</td>
<td>
'''Clojure'''

(doto (new Java.util.HashMap)(.put “a” 1)(.put “b” 2))

</td>
</tr>
</table>

Here, Scala compiler knows that nMap uses Strings as keys, and Integers as values. Unlike Java, this need not be specified beforehand. Scala could figure it out itself. Moreover, Scala will give an error if a different key-value pair is tried to insert. This is called "type inference". This prevents a whole class of bugs at run time just like Java but with less verbosity.
In a similar way Clojure also involves only few lines of code compared with the object oriented Java language which takes many lines of code.A simple Clojure example and the associated Java code :
Example

(defn blank? [s] (every? #(Character/isWhitespace %) s))

The innermost function Character/isWhiteSpace checks the first argument % for any whitespace and returns true if it is. every? invoke the above inner function for all elements in the collection s.It has no variables, no branches etc.

Java code
isBlank() method checks to see whether a string is blank or contains only whitespace.

public class Stringcheck{
public static boolean isBlank(String str){
int len;
if(str==null || (strlen =str.length())==0)
return true;
for(int i=0; i<strlen;i++) {
if((Character.isWhitespace(str.charAt(i))==false)){
return false;
}
}
return true;
}
}

=== Pattern Matching ===

To say simply, a [http://en.wikipedia.org/wiki/Pattern_matching Pattern matching] is a technique to search string for the occurrence of any patterns or regularity. Pattern matching is an elegant way to decompose objects into their constituent parts for processing.Many languages support the concept of pattern matching. Perl supports pattern matching using the pattern definition mini language called regular expressions, also called regexes or REs, which is borrowed from the regular expressions used in many Unix tools, such as grep() and sed().The risk that the parts of an object might be changed outside of the control of the enclosing object is avoided. For example, if there is a Person class that contains a list of addresses, it will not be an issue to expose that list to clients if the list is immutable. The users will not be able to change the list unexpectedly.Given below is a simple example for pattern matching used in Perl:

$mystring = "Hello world!"; // Perls way of assigning string to a variable.
if($mystring =~ m/World/) { print "Yes"; } // Checks the string stored in variable mystring has the string "World".
$mystring =~ s/world/mom/; // Replaces the string "world" stored in mystring to mom.

Another sample of regular expression in java :

String mystring="Hello World" ;
Pattern str = Pattern.compile("\\w+"); => Pattern stored for matching.
Matcher fit = str.matcher(mystring); => Matcher class which perform matching of the string with the pattern defined.
if(fit.matches())

As languages like Scala and Clojure support procedural code, pattern matching is done as equal or with less difficulty compared with Java which needs to use regex. Scala can even be embedded into XML as its syntax is somewhat similar.Given below an overview of how regular expression is achieved in Clojure.
Data are manipulated in Clojure through the sequence called seq which is a logical list. Clojure can access java collections, its collections, Regular expression matches via the seq also called seq-able. Clojure's regular expression uses java.util.regex library at the lowest level. For achieving that the keyword re-seq is used.
Syntax:
(re-seq regexp string)
Example
(re-seq #"\w+" "Hello World") => ("Hello" "World") => #"\w+" represents the java.util.regex.Pattern

=== Java Interoperability ===
Considering Clojure, it gives clean, simple and direct access to java and can access Java API directly.Clojure doesnot wrap Java's string functions. We can call using Java interop forms. It provides syntax for accessing Java elements like classes, instances, constructors, methods and fields and can also wrap Java API. The “.” dot special form is used for accessing Java. Some Clojure syntax which can access Java API: 

{| class="wikitable" border="2"
|-
! Java
! Clojure
|-
| new Widget(“red”)
| (new Widget “red”)
|-
| Math.PI
| (.Math PI) or Math/PI
|-
| System.currentTimeMillis()
| (.System currentTimeMillis) or System/currentTimeMillis
|-
| rnd.nextInt()
| (.rnd nextInt) or (.nextInt rnd)
|-
|}

Clojure pass functions as arguments to other functions. But Java does not support this. So Clojure provides a member function memfn macro to wrap methods or can use anonymous function to wrap a method call.
(map (memfn toUpperCase) [“a” ,”short”,”message”])
or
(map #(.toUpperCase %)[“a”,”short”,”message”]) => #(body) represents the anonymous function in Clojure.

For example,
(def the-digits
(map #(Integer. (str %))(filter #(Character/isDigit %) (seq big-num-str))))

where (def big-num-str (str "123785334434se9088af8309304293872adbcdfd”))

The above code extracts the integers from string and discards the non-numeric characters. Lets look at the functions defined in the example. There are totally five functions defined.They are
(seq big-num-str) => get each character defined in big-num-str
(Character/isDigit %) => Checks whether the input is an integer
(filter #()) => Filter each string from str
(map #(Integer. (str %))) => Change the string to integer
(def the-digits) => Output the integers only in a string of characters.
Here,
#(Character/isDigit) represents the Java method Character.isDigit() and #(Integer.(str %)) represents the new java.lang.Integer(str(%))

Most of the Clojure library functions have defined semantics for objects of Java types. contains? and .get work on Java’s Maps, arrays, Strings, count works on Java Strings, Collections and arrays. Clojure is built around these aspects. It avails the performance of JVM and the richness of both the core APIs and the numerous third-party libraries written in the Java language and restrained from reinventing them.

=== Multiple Inheritance ===

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance][http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf 2] is the concept of using the methods and variables of more than one superclass to a sub class.Java was designed without multiple inheritance. But Java supports the solution of problems commonly solved with multiple inheritance in other ways with help of interfaces where the methods defined in it are not implemented.In Scala, classes are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance in Java.Lets see how multiple inheritance achieved in Scala:

As interfaces in Java, Scala allows traits but has some methods partially implemented. The only difference to classes is the traits may not have constructor parameters.

trait Similarity {
def isSimilar(x: Any): Boolean // not implemented
def isNotSimilar(x: Any): Boolean = !isSimilar(x) //implemented method
}

This trait defines two methods isSimilar and isNotSimilar where isSimilar does not provide a concrete method implementation (it is abstract in the terminology of Java), and the method isNotSimilar defines a concrete implementation. Consequently, classes that integrate this trait only have to provide a concrete implementation for isSimilar.

class Point(xc: Int, yc: Int) extends Similarity {
var x: Int = xc
var y: Int = yc
def isSimilar(obj: Any) = //need to implement the method here
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
}

object TraitsTest extends Application {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotSimilar(p2))
println(p1.isNotSimilar(p3)) //uses the already defined method
println(p1.isNotSimilar(2))
}

These are some of the aspects and traits of mixing functional and object-oriented approaches. As we discussed in the advantages section, both the approaches have their benefits and limitations. Mixing them aspect-wise enables the above features in such languages. Lets discuss those languages briefly in the next section.

== Languages Supporting Functional and OO code ==

OCaml and F#[[http://msdn.microsoft.com/en-us/library/dd233154.aspx 7]] are some of the languages which support both functional and object oriented programming. OCaml is as fast as C and its featured as [http://www.haskell.org/ Haskell] which is a pure functional language. F#[[http://oreilly.com/catalog/9780596153656 3]] is a dynamically typed language which can run on .NET framework and has supported immutable types i.e. tuples, records, discriminated unions and lists to work in Functional programming. It has functions that can either be in curried or in uncurried form. As in functional language it can pass functions as arguments to other functions, resulting in higher order functions. It also supports lambda functions and closures. F#,behaves like other .NET languages as both in imperative and object oriented style. 

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language and it is a dialect of Lisp. It is not a pure functional language and it is a dynamically typed language. Just like Java it runs on JVM platform. But its syntax differs from Java. It is represented as :

(functions arguments...)

The function followed by its arguments is enclosed in paranthesis. It has features like immutable data structures, high-order functions and recursion, easy and fast java interoperability. 

Python and Ruby are also the programming languages which offer the mix of functional and OO languages. But these languages doesn't support the algebraic data types and pattern matching.

==Conclusion ==
The above aspects of functional and object oriented programming techniques discuss some if their merits and demerits. Mixing them produces a new programming paradigm which leads to a new dimension in programming. A few fundamental concepts are explored in Clojure and Scala here. The ability of Clojure and Scala to run in JVM platform makes them more preferable than others in the market. Some of the merits like closure, less verbosity, high order functions, currying along with interoperation with previously written libraries in these languages make them more efficient and useful. There are also other languages which support functional and object oriented techniques. Mixing the approaches, evolve a new dimension in programming which is practical and opens doors to more exploration.

== References ==

# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-09T01:22:07Z

Dmcarmon: /* Scala */

= Introduction =

= Functional Programming =

Functional programming treats computation as the evaluation of mathematical functions. It is compute-centric rather than data-centric. Functional programming keeps no global state, does not use for or while loops, and data is immutable****. Instead, everything is done using functions, usually functions that evaluate mathematical expressions. Each of these functions maintain no internal state and will always produce the same output given the same input.

Let's look at an example. Suppose we have a list of numbers and we want to multiply each number in the list by 2. The first approach is the imperitive style:

array[] = {1,2,3,4,5}
for(i=0 ; i<array.length; i++){
array[i] = array[i] * 2;
}

In the above example, array[] is a global variable. If we fail to check the array length, then a runtime exception occurs which might result in the program being crashed. As far as functional style, there is a function called map(func,seq)(in python language) where the function 'func' is applied to each member of seq. The following code is written in a functional style.

numbers = [1,2,3,4,5]
/* define a method called compute on each number in the list */
def compute(var):
var = var * 2
return var
/* Now call the map function */
L = map(compute,numbers)
print L // L will print [1,4,6,8,10]

Notice that there is no global data nor any nested loops and the bound checking is handled internally within the map function. The programmer is relieved of of runtime errors and thus can debug the program easily.

Some advantages of this approach are:
* Easier debugging: Since every thing is broken down into small simple functions, the functions are often easy to debug.
* More compact code: Functional programming typically requires fewer lines of code. Since compution is done by function code reuse is prevelent.
* Nothing depends on state: Because functional programs keep no state information, the functions will always operate the same regardless of the past history of the program.

= Object-Oriented Programming =

= Mixing Functional and Object-Oriented Programming =

Motivation for Mixing

== Functional Techniques useful for Object-Oriented Programming ==

=== Lambda ===

=== Currying ===

=== Pattern Matching ===

== Examples of Mixing ==

=== Scala ===

= Scala =
[http://www.scala-lang.org/ Scala] is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. [http://www.scala-lang.org/ Scala] was conceived in 2001 and implemented by Martin Odersky.

=== Features ===
==== Statically Typed ====
[http://www.scala-lang.org/ Scala] belongs to the family of languages which encode the type information of each and every variable in the generated code. The compiler makes sure you are not doing something incorrectly. For example, lets consider the following example of code where the type is not encoded,

In [http://www.ruby-lang.org/en/ Ruby],
irb(main):001:0> str="Hello World"
=> "Hello World"
irb(main):002:0> puts str.class
String
irb(main):003:0> str=123
=> 123
irb(main):004:0> puts str.class
Fixnum

In the above example, first we define 'str' variable to be of type String and then as a number. So basically, no type information is associated with the variable at any point in the program. Hence we can easily reassociate that variable with an object/instance
of a different type. This is a feature of all dynamically typed languages(like Ruby, Python, Clojure). However most of the statically typed languages such as Scala, Java, C/C++ do not allow you do so. In [http://www.scala-lang.org/ Scala],

scala> var str="Hello World"
str: java.lang.String = Hello World
scala> str=123
<console>:6: error: type mismatch;
found : Int(123)
required: java.lang.String
str=123

==== Mixed paradigm ====
[http://www.scala-lang.org/ Scala] is a strange specimen. It is a complete blend of object oriented and functional programming. How can this happen? Functional world advocates immutability but object oriented world is all about state and how do you mutate it to fit your needs. [http://www.scala-lang.org/ Scala] allows you create both mutable and immutable objects. Consider the following example,
val str: String = "Hello World"
In the first line, an immutable version(a misnomer indeed) of <code>str</code> is being created . Roughly translating the above line to Java is below:

final String str = "Hello World"; //note the extra semi-colon
Consider the next example below,
val list: List[String] = List("Scala", "is", "the coolest", "language", "in the world!")

The same code can be written in Java as below

List<String> mutableList = new ArrayList<String>();
list.add("Scala");
list.add("is");
list.add("the coolest");
list.add("language");
list.add("in the world!");
List<String> immutableList = Collections.immutableList(mutableList);

Compared to Java, [http://www.scala-lang.org/ Scala] reduces the total number of lines you need to type and at the same time looks so much simpler and less verbose. Even though the above example shows immutable collection example, scala also provides mutable collection and object types under the package <code>scala.collection.mutable.*</code>

As it can be observed, even though [http://www.scala-lang.org/ Scala] advocates immutability, it does not restrict you from creating mutable objects. So its the best of both worlds. Another part of functional world is the concept of functions as ''''first class members'''' of the language. Some of the common languages like Ruby, Python and JavaScript all incorporate this feature. In the sense you can pass around functions to methods as a parameter. Enough talking;

Let us have a class say <code>'Person'</code> which has properties, <code>name</code> and another variable <code>age</code>.
In Java:

class Person{
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String s){
this.name = s;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}

In [http://www.scala-lang.org/ Scala]:
case class Person(name: String, age: Int)

This single line is equivalent to the above java code! Getters for <code>name</code> and <code>age</code>, <code>equals()</code>, and <code>hashCode()</code> method are automatically generated for you by the compiler. Isn't this an awesome feature?

Now assume we have a list of persons and we want to filter out all the persons who are of age 23. How would you do that in Java?

List<Person> persons; //has a bunch of person objects in it.
List<Person> twentyThree = new ArrayList<Person>();
for(Person p: persons){
if(p.getAge() == 23){
twentyThree.add(p);
}
}

In [http://www.scala-lang.org/ Scala]:

val twentyThree: List[Person] = persons.filter( _.age == 23)

That's it! In case you are wondering whats going on, filter is a method present on scala.List class and the code block <code>_.age == 23</code> is a function created on the fly and passed onto the filter method. More precisely its called a [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] - a functional concept which can be emulated in java only using anonymous inner classes. Scala's compiler transforms our one line function into some anonymous inner classes when generating java byte code, allowing developers to define functions in a simple manner.

In fact, every function is an object in [http://www.scala-lang.org/ Scala]. Scala's standard library has a number of functions which are objects themselves.

==== Sophisticated Syntax/Features ====
Sophisticated syntax and features are present in other functional languages like Haskell, (O)Caml and Erlang. Consider the following example,

val name = "Jackie Chan"
println(name.getClass) //prints out String.

Previously we saw that [http://www.scala-lang.org/ Scala] is a statically typed language and yet in the above example we don't specify what type <code>name</code> is. In Java, you would type in the following:

String name = "Jackie Chan"

In Java you specify what type the name variable is, but the [http://www.scala-lang.org/ scala] compiler can automatically detect the type of the variable even if you don't specify it. Consider the following example,

case class Person(name: String, age: Int)
val persons = List(
Person("Jackie Chan", 51), Person("Jet Li", 41),
Person("RajniKanth", 51), Person("Kamal Hasan", 44),
Person("Martin Odersky", 18), Person("Steve Yegge", 23))
//notice that you don't have to use 'new' keyword to create new instances. This is taken care of by the companion objects.

The above lines of code create a list with 6 different persons(An immutable list)

Now, just like ruby, scala supports the concepts of [http://en.wikipedia.org/wiki/Closure_(computer_science) closure]. Let's see what it is.

val twentyThree: List[Person] = persons.filter( { p: Person => p.age == 3})

In the above set of lines, the code within the '{ }' brackets is a function's body. The compiler created a function which takes a single argument and returns either true or false.

==== A Scalable Language ====
In almost all programming languages, there is a necessity to profile the running time of the procedures and tune its performance. The old way of doing things in Java would be:

public class Main{
public static int factorial(int x){
if(x == 0 || x == 1) return 1
else return x * factorial(x-1)
}
public static void main(String [] args){
long beforeTime = System.currentTimeMillis();
int result = factorial(5);
System.out.println("Total time taken to execute factorial(5) is " + (System.currentTimeMillis() - result)+"ms");
System.out.println("factorial(5) = " + result);
}
}

However, if you want to find out the execution time of some other method, you would have to type in all the above lines again. So much for code re-use or [http://en.wikipedia.org/wiki/DRY DRY (dont't repeat yourself)]! Lets see how its done in [http://www.scala-lang.org/ Scala].

object Main{
def main(args: Array[String]){
def factorial(x: Int):Int = x match{
case 0 | 1 => 1
case _ => x * factorial(x-1)
}
import System.currentTimeMillis
def timeIt(msg: String = "Time to execute is: ")(func: => Unit){
val before = currentTimeMillis
func
println(msg + (currentTimeMillis - before) + "ms")
}
timeIt("Total time taken to execute factorial(5) is "){
val result = factorial(5)
println("factorial(5) = " + result)
}
}
//would print: factorial(5) = 120
// Total time taken to execute factorial(5) is 1ms

That's not right! The function <code>timeIt</code> looks like a feature built into the language. Try saving the above code into a separate file and run it - It will still work. Using this feature, it is possible to build powerful DSL languages which can run at full speed on JVM.

Ruby allows you to add new methods to objects. This feature is often called as [http://en.wikipedia.org/wiki/Monkey_patch Monkey Patching] because you are splitting open the class and adding/overriding methods (in)|(to) the class. Often this leads to unexpected behavior at runtime because, other libraries including into build path may depend on some methods which you changed. Scala provides yet another feature called implicits.

In Java, <code>String</code> class is <code>final</code> so there is no way you can add new methods to it. But with implicits you can do more! Suppose you have some text in memory and you know it represents a number. But in Java the usual way to convert string to int is to do a <code>Integer.parseInt(string)</code> which seems so unnecessary. Let us make our lives easier...

implicit def strToInt(str: String) = new {
def asInt = Integer.parseInt(str)
}
val str = "1234"
println(str.asInt * 3) //prints out 3702

The above code gives us an impression as if String class has gained new <code>asInt</code> method. Can static object oriented languages do this? No! Infact scala cheats by calling our implicits to convert it into a different object as and when needed.

The above functionalities are purely object oriented, yet they are safe. They don't pollute the global namespace, unlike Ruby or Python.

=== Ruby ===

=== Clojure ===

= Conclusion =

= References =

= Mixing Functional & O-O code =

This chapter deals with the mixing of functional and object-oriented programming paradigms. We start with listing the different programming paradigms available today. We introduce functional and object-oriented approaches briefly and then discuss the advantages of one over the other. Following this, we discuss some aspects and features of mixing both the approaches. Finally, we talk about few languages that constitute such a mix.

== Programming Paradigms Today==

Several programmatic approaches to solve a particular task lead to distinct programming paradigms like, 
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
* Functional programming 
* Object Oriented programming 
* [http://en.wikipedia.org/wiki/Logic_programming Logical programming], etc. 
Lets focus on functional and object oriented programming approaches.

== Functional Programming ==

[http://en.wikipedia.org/wiki/Functional_programming Functional programming] is the task of decomposing a problem into a number of functions. Selectively executing these functions results in the solution to the problem. The functions mostly behave as mathematical. For given set of inputs the program should always return the same output. It usually concentrates on what type of problem we are dealing with rather than on the details of how to solve the problem. For example lets say there is a function which calculates area of a square. If we use it six times then we end up with area of a cube. Thus functional programming helps to build complex systems.

=== Approach ===

Expressions are the collection of variables and operations resulting in a single value this also deals with the way of solving the problem as expressions. Hence also called Expression related programming. It is structured as expression where each expression can be encapsulated in another yielding the result. Making the change in data structures as the program runs is called [http://en.wikipedia.org/wiki/Side_effect_(computer_science) side effects]. Purely functional language has no side effects. Language like Haskell is a pure functional language . Some languages need many approaches for achieving the desired result. Such languages are multi-paradigm. Examples for such languages are C++, Python,Lisp. Its like evaluating an expression and use the resulting value for something.

Structure of functional programming :

(fn2 ( fn1 ()[input list] ) []) => fn1 takes input list and the output of fn1 is used as input to fn2. Its a schematic representation of
how functional programming works.

Functional programming feature (Python) :

m = map(lambda i : i*i , numbers)
where ''numbers'' is an array of numbers and ''lambda'' is [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 closure].

Python has some functions like map, filter, reduce to support functional programming style. In the example above, the 'map' is a high-order function that takes a function and an array of numbers as input. The ''lambda'' takes i as input and returns i*i as output. Every result returned is appended to a list and produced as output. In functional programming, the programmer is given a natural framework for developing smaller, simpler, and more general modules, which are then glued together.

== Object Oriented Programming ==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] is a programming technique where everything is defined as an object. Objects are well-defined discrete bundles of data(attributes) and the associated functions(behavior). They are devised to resemble real-life objects and are uniquely identifiable by a name. The attributes could be of simple datatype(int, String, Boolean) or objects themselves. The behavior is defined by methods to use and manipulate the attributes. The values of attributes of an object at an instant is the state of the object. OO Programming allows objects to have their state retained throughout the code until manipulated otherwise. Objects are capable of housekeeping their own states, interacting and establishing relationships with other objects, inheriting, etc.

=== Fundamental concepts ===

A [http://en.wikipedia.org/wiki/Class_%28computer_science%29 class] is a user-defined datatype that provides implementation details to define the attributes and their properties. It is an abstract representation of an object(i.e.,) like a mold for objects.
An instance is an executable copy of a class. They are the actual objects created using the ‘class mold’ on run time.
Methods are a set of procedural statements or functions to define the behavior of an object, convey the current state, modify values of the attributes, etc.

Example :

An object in Java might look like this:

public class Person {
private String name;
public Person() {
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}

Here, OO Programming allows the programmer to set the ''name'' attribute of the class ''Person'' and get the name whenever needed in the code. An object of this class Person will remain in memory forever as long as there is a reference to it. As OO Programming allows objects to have their state retained, the value of the ''name'' attribute for a particular ''Person'' object remains the same across any part of the code until it is set differently.

=== Features ===

Three primary characteristics of object oriented programming are Encapsulation, Polymorphism, and Inheritance.
[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation] is the ability of objects to hide visibility of their attributes and behavior, thereby providing service independent of implementation.
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects.
[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance] is one where an existing type can be used to derive a new type. Derived types inherit the data and operations of the super-type. And also, they can overwrite existing operations or add new ones.

There are other important features of O-O programming like [http://en.wikipedia.org/wiki/Message_passing message passing], [http://en.wikipedia.org/wiki/Abstraction abstraction], delegation, etc.

Now, we have seen both the approaches and their features in brief. Lets discuss the advantages of one over the other.

== Advantages ==

=== Functional Approach over OO Approach[[http://www.jot.fm/issues/issue_2009_09/article5.pdf 8]]===
* Functional programming solves the problem with lesser number of lines of code than the OO programming style. 
* There is no side effect as they use immutable data structures also called [http://en.wikipedia.org/wiki/Persistent_data_structure Persistent Data Structure] which will have no change in the state of variables. Hence program dont have to depend on history. 
* There is no limit in the numeric types used as opposed to OO languages which mainly depend on primitive data types. 
* A programmer is given the freedom to think in terms of what to solve in the problem rather than concentrating on how to solve and the flow of the program. 
* Suitable for calculation intensive programs.

=== OO Approach over Functional Approach===
* Everything can be represented in an object and it has the attributes associated with it and hence the state of the object is known at any time. 
* A complex system can be subdivided into modules of objects where as in functional approach, many functions inter operate to form a complex system. 
* [http://en.wikipedia.org/wiki/Reusability Re-usability] (i.e.) OO approach enables programmers to create new objects that inherits many of its features from existing objects. This makes object-oriented programs easier to modify than functional. 
* [http://en.wikipedia.org/wiki/Debug Debugging] in Object Oriented environment is easy compared with functional approach where a small error in one function causes the whole system (i.e. all the functions) to fail. 
* Suitable for making application-oriented software. 

Both the approaches have their advantages and disadvantages. What if we could get the best of both the worlds? The next section deals with the aspects and features of how well both the approaches are mixed together in some languages.

== Mixing Functional & OO Code - Best of both the worlds ==

Languages that are a mix of functional and object oriented approaches(eg. Scala[[http://www.scala-lang.org/node/1305 1]], Clojure[[http://oreilly.com/catalog/9781934356333 10]], etc.) make use of best of both the worlds. They support various aspects of functional and object oriented approaches. They have a bunch of functional approach features[[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf 6]], which object oriented programming languages(like Java) lack which includes closures. Closures are first-class functions with free variables that are bound in the lexical environment. These languages also sport a very malleable syntax that makes them well suited for "domain specific languages" with the benefits of static typing. They are more expressive, extensible and allow reuse of programming abstractions.

Certain languages like Scala, Clojure, etc run on Java Virtual Machine(JVM) ensuring portability to all underlying platforms. They even support immutable objects. In Scala, new language constructs can be added in the form of libraries. They allow safe reuse[[http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf 9]] of programming abstractions and type-safe extension of software.

===Lambda===

A lambda[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] expression is an anonymous function that contain expressions and statements, and can be used to create delegates or expression types. Such kind of anonymous function can be defined and passed around as easily as other data types and can be used to contain functionality that need not be named. Some notable examples include closures[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] and currying. Lambda functions with no name can be called using the variable assigned to it.

g = lambda x: x*2
g(3)=6

We can have lambda function without assigning it to a variable which can be used as inline-function.

(lambda x: x*2)(3)

In [http://en.wikipedia.org/wiki/Clojure Clojure] as a functional language, the creation of a chunk of behavior that can be assigned to a variable (known as a lambda) is trivial. Below are two ways to create a lambda that returns the square of its argument.

(def square1 (fn [n] (* n n)))
(def square2 #(* % %))

===Currying ===

[http://en.wikipedia.org/wiki/Currying Currying] transforms a function that takes multiple parameters into a chain of functions, each taking a single parameter. It reuses a partially applied function where the function is originally defined as accepting n parameters.It can be interpreted as the technique to decompose a function that takes n parameters into n function each of them taking 1 parameter. For example to say in algebraic terms,consider the function f which takes 3 parameters x,y,z and Currying means that we can rewrite the function as a composition of 3 functions:

f(x,y,z) = 4*x+3*y+2*z
f(x)(y)(z) = 2*z+(3*y+(4*x))

In Scala, currying takes advantage of Scala’s syntactic sugar. Below is a currying example in Scala. This function creates a multiplier function which takes two arguments and partially defines it by assigning a constant to one argument and assigning it to a variable .Later the function is called by assigning the second argument.

def multiplier(i: Int)(factor: Int) = i * factor => method named multiplier which takes two parameters is defined
val byFive = multiplier(5) _ => The method is redefined with accepting one parameter and store it in a variable.
val byTen = multiplier(10) _

scala> byFive(2) => Method called by giving the second parameter.
res4: Int = 10

scala> byTen(2)
res5: Int = 20

===Less Verbosity===

In Java each variable should have its type defined beforehand. Whereas in languages like Scala, it is more concise and easier to read than the equivalent Java.

For example, a Map can be created with a simple syntax in Scala,Clojure than in Java:

<table>
<tr>
<td>
'''Java'''
Map<String, Integer> nMap = new HashMap<String, Integer>();
nMap.put("one", 1);
nMap.put("two", 2);
nMap.put("three", 3);
</td>
<td>
'''Scala'''

var nMap = Map("one" -> 1, "two" -> 2, "three" -> 3)

</td>
<td>
'''Clojure'''

(doto (new Java.util.HashMap)(.put “a” 1)(.put “b” 2))

</td>
</tr>
</table>

Here, Scala compiler knows that nMap uses Strings as keys, and Integers as values. Unlike Java, this need not be specified beforehand. Scala could figure it out itself. Moreover, Scala will give an error if a different key-value pair is tried to insert. This is called "type inference". This prevents a whole class of bugs at run time just like Java but with less verbosity.
In a similar way Clojure also involves only few lines of code compared with the object oriented Java language which takes many lines of code.A simple Clojure example and the associated Java code :
Example

(defn blank? [s] (every? #(Character/isWhitespace %) s))

The innermost function Character/isWhiteSpace checks the first argument % for any whitespace and returns true if it is. every? invoke the above inner function for all elements in the collection s.It has no variables, no branches etc.

Java code
isBlank() method checks to see whether a string is blank or contains only whitespace.

public class Stringcheck{
public static boolean isBlank(String str){
int len;
if(str==null || (strlen =str.length())==0)
return true;
for(int i=0; i<strlen;i++) {
if((Character.isWhitespace(str.charAt(i))==false)){
return false;
}
}
return true;
}
}

=== Pattern Matching ===

To say simply, a [http://en.wikipedia.org/wiki/Pattern_matching Pattern matching] is a technique to search string for the occurrence of any patterns or regularity. Pattern matching is an elegant way to decompose objects into their constituent parts for processing.Many languages support the concept of pattern matching. Perl supports pattern matching using the pattern definition mini language called regular expressions, also called regexes or REs, which is borrowed from the regular expressions used in many Unix tools, such as grep() and sed().The risk that the parts of an object might be changed outside of the control of the enclosing object is avoided. For example, if there is a Person class that contains a list of addresses, it will not be an issue to expose that list to clients if the list is immutable. The users will not be able to change the list unexpectedly.Given below is a simple example for pattern matching used in Perl:

$mystring = "Hello world!"; // Perls way of assigning string to a variable.
if($mystring =~ m/World/) { print "Yes"; } // Checks the string stored in variable mystring has the string "World".
$mystring =~ s/world/mom/; // Replaces the string "world" stored in mystring to mom.

Another sample of regular expression in java :

String mystring="Hello World" ;
Pattern str = Pattern.compile("\\w+"); => Pattern stored for matching.
Matcher fit = str.matcher(mystring); => Matcher class which perform matching of the string with the pattern defined.
if(fit.matches())

As languages like Scala and Clojure support procedural code, pattern matching is done as equal or with less difficulty compared with Java which needs to use regex. Scala can even be embedded into XML as its syntax is somewhat similar.Given below an overview of how regular expression is achieved in Clojure.
Data are manipulated in Clojure through the sequence called seq which is a logical list. Clojure can access java collections, its collections, Regular expression matches via the seq also called seq-able. Clojure's regular expression uses java.util.regex library at the lowest level. For achieving that the keyword re-seq is used.
Syntax:
(re-seq regexp string)
Example
(re-seq #"\w+" "Hello World") => ("Hello" "World") => #"\w+" represents the java.util.regex.Pattern

=== Java Interoperability ===
Considering Clojure, it gives clean, simple and direct access to java and can access Java API directly.Clojure doesnot wrap Java's string functions. We can call using Java interop forms. It provides syntax for accessing Java elements like classes, instances, constructors, methods and fields and can also wrap Java API. The “.” dot special form is used for accessing Java. Some Clojure syntax which can access Java API: 

{| class="wikitable" border="2"
|-
! Java
! Clojure
|-
| new Widget(“red”)
| (new Widget “red”)
|-
| Math.PI
| (.Math PI) or Math/PI
|-
| System.currentTimeMillis()
| (.System currentTimeMillis) or System/currentTimeMillis
|-
| rnd.nextInt()
| (.rnd nextInt) or (.nextInt rnd)
|-
|}

Clojure pass functions as arguments to other functions. But Java does not support this. So Clojure provides a member function memfn macro to wrap methods or can use anonymous function to wrap a method call.
(map (memfn toUpperCase) [“a” ,”short”,”message”])
or
(map #(.toUpperCase %)[“a”,”short”,”message”]) => #(body) represents the anonymous function in Clojure.

For example,
(def the-digits
(map #(Integer. (str %))(filter #(Character/isDigit %) (seq big-num-str))))

where (def big-num-str (str "123785334434se9088af8309304293872adbcdfd”))

The above code extracts the integers from string and discards the non-numeric characters. Lets look at the functions defined in the example. There are totally five functions defined.They are
(seq big-num-str) => get each character defined in big-num-str
(Character/isDigit %) => Checks whether the input is an integer
(filter #()) => Filter each string from str
(map #(Integer. (str %))) => Change the string to integer
(def the-digits) => Output the integers only in a string of characters.
Here,
#(Character/isDigit) represents the Java method Character.isDigit() and #(Integer.(str %)) represents the new java.lang.Integer(str(%))

Most of the Clojure library functions have defined semantics for objects of Java types. contains? and .get work on Java’s Maps, arrays, Strings, count works on Java Strings, Collections and arrays. Clojure is built around these aspects. It avails the performance of JVM and the richness of both the core APIs and the numerous third-party libraries written in the Java language and restrained from reinventing them.

=== Multiple Inheritance ===

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance][http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf 2] is the concept of using the methods and variables of more than one superclass to a sub class.Java was designed without multiple inheritance. But Java supports the solution of problems commonly solved with multiple inheritance in other ways with help of interfaces where the methods defined in it are not implemented.In Scala, classes are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance in Java.Lets see how multiple inheritance achieved in Scala:

As interfaces in Java, Scala allows traits but has some methods partially implemented. The only difference to classes is the traits may not have constructor parameters.

trait Similarity {
def isSimilar(x: Any): Boolean // not implemented
def isNotSimilar(x: Any): Boolean = !isSimilar(x) //implemented method
}

This trait defines two methods isSimilar and isNotSimilar where isSimilar does not provide a concrete method implementation (it is abstract in the terminology of Java), and the method isNotSimilar defines a concrete implementation. Consequently, classes that integrate this trait only have to provide a concrete implementation for isSimilar.

class Point(xc: Int, yc: Int) extends Similarity {
var x: Int = xc
var y: Int = yc
def isSimilar(obj: Any) = //need to implement the method here
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
}

object TraitsTest extends Application {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotSimilar(p2))
println(p1.isNotSimilar(p3)) //uses the already defined method
println(p1.isNotSimilar(2))
}

These are some of the aspects and traits of mixing functional and object-oriented approaches. As we discussed in the advantages section, both the approaches have their benefits and limitations. Mixing them aspect-wise enables the above features in such languages. Lets discuss those languages briefly in the next section.

== Languages Supporting Functional and OO code ==

OCaml and F#[[http://msdn.microsoft.com/en-us/library/dd233154.aspx 7]] are some of the languages which support both functional and object oriented programming. OCaml is as fast as C and its featured as [http://www.haskell.org/ Haskell] which is a pure functional language. F#[[http://oreilly.com/catalog/9780596153656 3]] is a dynamically typed language which can run on .NET framework and has supported immutable types i.e. tuples, records, discriminated unions and lists to work in Functional programming. It has functions that can either be in curried or in uncurried form. As in functional language it can pass functions as arguments to other functions, resulting in higher order functions. It also supports lambda functions and closures. F#,behaves like other .NET languages as both in imperative and object oriented style. 

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language and it is a dialect of Lisp. It is not a pure functional language and it is a dynamically typed language. Just like Java it runs on JVM platform. But its syntax differs from Java. It is represented as :

(functions arguments...)

The function followed by its arguments is enclosed in paranthesis. It has features like immutable data structures, high-order functions and recursion, easy and fast java interoperability. 

Python and Ruby are also the programming languages which offer the mix of functional and OO languages. But these languages doesn't support the algebraic data types and pattern matching.

==Conclusion ==
The above aspects of functional and object oriented programming techniques discuss some if their merits and demerits. Mixing them produces a new programming paradigm which leads to a new dimension in programming. A few fundamental concepts are explored in Clojure and Scala here. The ability of Clojure and Scala to run in JVM platform makes them more preferable than others in the market. Some of the merits like closure, less verbosity, high order functions, currying along with interoperation with previously written libraries in these languages make them more efficient and useful. There are also other languages which support functional and object oriented techniques. Mixing the approaches, evolve a new dimension in programming which is practical and opens doors to more exploration.

== References ==

# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-08T21:46:09Z

Dmcarmon:

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-08T18:24:36Z

Dmcarmon: /* Functional Programming */

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-08T18:23:55Z

Dmcarmon: /* Functional Programming */

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-08T17:50:23Z

Dmcarmon: Added Functional Programming Section

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-07T20:15:33Z

Dmcarmon:

= Introduction =

= Functional Programming =

= Object-Oriented Programming =

= Mixing Functional and Object-Oriented Programming =

Motivation for Mixing

== Functional Techniques useful for Object-Oriented Programming ==

=== Lambda ===

=== Currying ===

=== Pattern Matching ===

== Examples of Mixing ==

=== Scala ===

=== Ruby ===

=== Clojure ===

= Conclusion =

= References =

= Mixing Functional & O-O code =

This chapter deals with the mixing of functional and object-oriented programming paradigms. We start with listing the different programming paradigms available today. We introduce functional and object-oriented approaches briefly and then discuss the advantages of one over the other. Following this, we discuss some aspects and features of mixing both the approaches. Finally, we talk about few languages that constitute such a mix.

== Programming Paradigms Today==

Several programmatic approaches to solve a particular task lead to distinct programming paradigms like, 
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
* Functional programming 
* Object Oriented programming 
* [http://en.wikipedia.org/wiki/Logic_programming Logical programming], etc. 
Lets focus on functional and object oriented programming approaches.

== Functional Programming ==

[http://en.wikipedia.org/wiki/Functional_programming Functional programming] is the task of decomposing a problem into a number of functions. Selectively executing these functions results in the solution to the problem. The functions mostly behave as mathematical. For given set of inputs the program should always return the same output. It usually concentrates on what type of problem we are dealing with rather than on the details of how to solve the problem. For example lets say there is a function which calculates area of a square. If we use it six times then we end up with area of a cube. Thus functional programming helps to build complex systems.

=== Approach ===

Expressions are the collection of variables and operations resulting in a single value this also deals with the way of solving the problem as expressions. Hence also called Expression related programming. It is structured as expression where each expression can be encapsulated in another yielding the result. Making the change in data structures as the program runs is called [http://en.wikipedia.org/wiki/Side_effect_(computer_science) side effects]. Purely functional language has no side effects. Language like Haskell is a pure functional language . Some languages need many approaches for achieving the desired result. Such languages are multi-paradigm. Examples for such languages are C++, Python,Lisp. Its like evaluating an expression and use the resulting value for something.

Structure of functional programming :

(fn2 ( fn1 ()[input list] ) []) => fn1 takes input list and the output of fn1 is used as input to fn2. Its a schematic representation of
how functional programming works.

Functional programming feature (Python) :

m = map(lambda i : i*i , numbers)
where ''numbers'' is an array of numbers and ''lambda'' is [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 closure].

Python has some functions like map, filter, reduce to support functional programming style. In the example above, the 'map' is a high-order function that takes a function and an array of numbers as input. The ''lambda'' takes i as input and returns i*i as output. Every result returned is appended to a list and produced as output. In functional programming, the programmer is given a natural framework for developing smaller, simpler, and more general modules, which are then glued together.

== Object Oriented Programming ==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] is a programming technique where everything is defined as an object. Objects are well-defined discrete bundles of data(attributes) and the associated functions(behavior). They are devised to resemble real-life objects and are uniquely identifiable by a name. The attributes could be of simple datatype(int, String, Boolean) or objects themselves. The behavior is defined by methods to use and manipulate the attributes. The values of attributes of an object at an instant is the state of the object. OO Programming allows objects to have their state retained throughout the code until manipulated otherwise. Objects are capable of housekeeping their own states, interacting and establishing relationships with other objects, inheriting, etc.

=== Fundamental concepts ===

A [http://en.wikipedia.org/wiki/Class_%28computer_science%29 class] is a user-defined datatype that provides implementation details to define the attributes and their properties. It is an abstract representation of an object(i.e.,) like a mold for objects.
An instance is an executable copy of a class. They are the actual objects created using the ‘class mold’ on run time.
Methods are a set of procedural statements or functions to define the behavior of an object, convey the current state, modify values of the attributes, etc.

Example :

An object in Java might look like this:

public class Person {
private String name;
public Person() {
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}

Here, OO Programming allows the programmer to set the ''name'' attribute of the class ''Person'' and get the name whenever needed in the code. An object of this class Person will remain in memory forever as long as there is a reference to it. As OO Programming allows objects to have their state retained, the value of the ''name'' attribute for a particular ''Person'' object remains the same across any part of the code until it is set differently.

=== Features ===

Three primary characteristics of object oriented programming are Encapsulation, Polymorphism, and Inheritance.
[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation] is the ability of objects to hide visibility of their attributes and behavior, thereby providing service independent of implementation.
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects.
[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance] is one where an existing type can be used to derive a new type. Derived types inherit the data and operations of the super-type. And also, they can overwrite existing operations or add new ones.

There are other important features of O-O programming like [http://en.wikipedia.org/wiki/Message_passing message passing], [http://en.wikipedia.org/wiki/Abstraction abstraction], delegation, etc.

Now, we have seen both the approaches and their features in brief. Lets discuss the advantages of one over the other.

== Advantages ==

=== Functional Approach over OO Approach[[http://www.jot.fm/issues/issue_2009_09/article5.pdf 8]]===
* Functional programming solves the problem with lesser number of lines of code than the OO programming style. 
* There is no side effect as they use immutable data structures also called [http://en.wikipedia.org/wiki/Persistent_data_structure Persistent Data Structure] which will have no change in the state of variables. Hence program dont have to depend on history. 
* There is no limit in the numeric types used as opposed to OO languages which mainly depend on primitive data types. 
* A programmer is given the freedom to think in terms of what to solve in the problem rather than concentrating on how to solve and the flow of the program. 
* Suitable for calculation intensive programs.

=== OO Approach over Functional Approach===
* Everything can be represented in an object and it has the attributes associated with it and hence the state of the object is known at any time. 
* A complex system can be subdivided into modules of objects where as in functional approach, many functions inter operate to form a complex system. 
* [http://en.wikipedia.org/wiki/Reusability Re-usability] (i.e.) OO approach enables programmers to create new objects that inherits many of its features from existing objects. This makes object-oriented programs easier to modify than functional. 
* [http://en.wikipedia.org/wiki/Debug Debugging] in Object Oriented environment is easy compared with functional approach where a small error in one function causes the whole system (i.e. all the functions) to fail. 
* Suitable for making application-oriented software. 

Both the approaches have their advantages and disadvantages. What if we could get the best of both the worlds? The next section deals with the aspects and features of how well both the approaches are mixed together in some languages.

== Mixing Functional & OO Code - Best of both the worlds ==

Languages that are a mix of functional and object oriented approaches(eg. Scala[[http://www.scala-lang.org/node/1305 1]], Clojure[[http://oreilly.com/catalog/9781934356333 10]], etc.) make use of best of both the worlds. They support various aspects of functional and object oriented approaches. They have a bunch of functional approach features[[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf 6]], which object oriented programming languages(like Java) lack which includes closures. Closures are first-class functions with free variables that are bound in the lexical environment. These languages also sport a very malleable syntax that makes them well suited for "domain specific languages" with the benefits of static typing. They are more expressive, extensible and allow reuse of programming abstractions.

Certain languages like Scala, Clojure, etc run on Java Virtual Machine(JVM) ensuring portability to all underlying platforms. They even support immutable objects. In Scala, new language constructs can be added in the form of libraries. They allow safe reuse[[http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf 9]] of programming abstractions and type-safe extension of software.

===Lambda===

A lambda[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] expression is an anonymous function that contain expressions and statements, and can be used to create delegates or expression types. Such kind of anonymous function can be defined and passed around as easily as other data types and can be used to contain functionality that need not be named. Some notable examples include closures[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] and currying. Lambda functions with no name can be called using the variable assigned to it.

g = lambda x: x*2
g(3)=6

We can have lambda function without assigning it to a variable which can be used as inline-function.

(lambda x: x*2)(3)

In [http://en.wikipedia.org/wiki/Clojure Clojure] as a functional language, the creation of a chunk of behavior that can be assigned to a variable (known as a lambda) is trivial. Below are two ways to create a lambda that returns the square of its argument.

(def square1 (fn [n] (* n n)))
(def square2 #(* % %))

===Currying ===

[http://en.wikipedia.org/wiki/Currying Currying] transforms a function that takes multiple parameters into a chain of functions, each taking a single parameter. It reuses a partially applied function where the function is originally defined as accepting n parameters.It can be interpreted as the technique to decompose a function that takes n parameters into n function each of them taking 1 parameter. For example to say in algebraic terms,consider the function f which takes 3 parameters x,y,z and Currying means that we can rewrite the function as a composition of 3 functions:

f(x,y,z) = 4*x+3*y+2*z
f(x)(y)(z) = 2*z+(3*y+(4*x))

In Scala, currying takes advantage of Scala’s syntactic sugar. Below is a currying example in Scala. This function creates a multiplier function which takes two arguments and partially defines it by assigning a constant to one argument and assigning it to a variable .Later the function is called by assigning the second argument.

def multiplier(i: Int)(factor: Int) = i * factor => method named multiplier which takes two parameters is defined
val byFive = multiplier(5) _ => The method is redefined with accepting one parameter and store it in a variable.
val byTen = multiplier(10) _

scala> byFive(2) => Method called by giving the second parameter.
res4: Int = 10

scala> byTen(2)
res5: Int = 20

===Less Verbosity===

In Java each variable should have its type defined beforehand. Whereas in languages like Scala, it is more concise and easier to read than the equivalent Java.

For example, a Map can be created with a simple syntax in Scala,Clojure than in Java:

<table>
<tr>
<td>
'''Java'''
Map<String, Integer> nMap = new HashMap<String, Integer>();
nMap.put("one", 1);
nMap.put("two", 2);
nMap.put("three", 3);
</td>
<td>
'''Scala'''

var nMap = Map("one" -> 1, "two" -> 2, "three" -> 3)

</td>
<td>
'''Clojure'''

(doto (new Java.util.HashMap)(.put “a” 1)(.put “b” 2))

</td>
</tr>
</table>

Here, Scala compiler knows that nMap uses Strings as keys, and Integers as values. Unlike Java, this need not be specified beforehand. Scala could figure it out itself. Moreover, Scala will give an error if a different key-value pair is tried to insert. This is called "type inference". This prevents a whole class of bugs at run time just like Java but with less verbosity.
In a similar way Clojure also involves only few lines of code compared with the object oriented Java language which takes many lines of code.A simple Clojure example and the associated Java code :
Example

(defn blank? [s] (every? #(Character/isWhitespace %) s))

The innermost function Character/isWhiteSpace checks the first argument % for any whitespace and returns true if it is. every? invoke the above inner function for all elements in the collection s.It has no variables, no branches etc.

Java code
isBlank() method checks to see whether a string is blank or contains only whitespace.

public class Stringcheck{
public static boolean isBlank(String str){
int len;
if(str==null || (strlen =str.length())==0)
return true;
for(int i=0; i<strlen;i++) {
if((Character.isWhitespace(str.charAt(i))==false)){
return false;
}
}
return true;
}
}

=== Pattern Matching ===

To say simply, a [http://en.wikipedia.org/wiki/Pattern_matching Pattern matching] is a technique to search string for the occurrence of any patterns or regularity. Pattern matching is an elegant way to decompose objects into their constituent parts for processing.Many languages support the concept of pattern matching. Perl supports pattern matching using the pattern definition mini language called regular expressions, also called regexes or REs, which is borrowed from the regular expressions used in many Unix tools, such as grep() and sed().The risk that the parts of an object might be changed outside of the control of the enclosing object is avoided. For example, if there is a Person class that contains a list of addresses, it will not be an issue to expose that list to clients if the list is immutable. The users will not be able to change the list unexpectedly.Given below is a simple example for pattern matching used in Perl:

$mystring = "Hello world!"; // Perls way of assigning string to a variable.
if($mystring =~ m/World/) { print "Yes"; } // Checks the string stored in variable mystring has the string "World".
$mystring =~ s/world/mom/; // Replaces the string "world" stored in mystring to mom.

Another sample of regular expression in java :

String mystring="Hello World" ;
Pattern str = Pattern.compile("\\w+"); => Pattern stored for matching.
Matcher fit = str.matcher(mystring); => Matcher class which perform matching of the string with the pattern defined.
if(fit.matches())

As languages like Scala and Clojure support procedural code, pattern matching is done as equal or with less difficulty compared with Java which needs to use regex. Scala can even be embedded into XML as its syntax is somewhat similar.Given below an overview of how regular expression is achieved in Clojure.
Data are manipulated in Clojure through the sequence called seq which is a logical list. Clojure can access java collections, its collections, Regular expression matches via the seq also called seq-able. Clojure's regular expression uses java.util.regex library at the lowest level. For achieving that the keyword re-seq is used.
Syntax:
(re-seq regexp string)
Example
(re-seq #"\w+" "Hello World") => ("Hello" "World") => #"\w+" represents the java.util.regex.Pattern

=== Java Interoperability ===
Considering Clojure, it gives clean, simple and direct access to java and can access Java API directly.Clojure doesnot wrap Java's string functions. We can call using Java interop forms. It provides syntax for accessing Java elements like classes, instances, constructors, methods and fields and can also wrap Java API. The “.” dot special form is used for accessing Java. Some Clojure syntax which can access Java API: 

{| class="wikitable" border="2"
|-
! Java
! Clojure
|-
| new Widget(“red”)
| (new Widget “red”)
|-
| Math.PI
| (.Math PI) or Math/PI
|-
| System.currentTimeMillis()
| (.System currentTimeMillis) or System/currentTimeMillis
|-
| rnd.nextInt()
| (.rnd nextInt) or (.nextInt rnd)
|-
|}

Clojure pass functions as arguments to other functions. But Java does not support this. So Clojure provides a member function memfn macro to wrap methods or can use anonymous function to wrap a method call.
(map (memfn toUpperCase) [“a” ,”short”,”message”])
or
(map #(.toUpperCase %)[“a”,”short”,”message”]) => #(body) represents the anonymous function in Clojure.

For example,
(def the-digits
(map #(Integer. (str %))(filter #(Character/isDigit %) (seq big-num-str))))

where (def big-num-str (str "123785334434se9088af8309304293872adbcdfd”))

The above code extracts the integers from string and discards the non-numeric characters. Lets look at the functions defined in the example. There are totally five functions defined.They are
(seq big-num-str) => get each character defined in big-num-str
(Character/isDigit %) => Checks whether the input is an integer
(filter #()) => Filter each string from str
(map #(Integer. (str %))) => Change the string to integer
(def the-digits) => Output the integers only in a string of characters.
Here,
#(Character/isDigit) represents the Java method Character.isDigit() and #(Integer.(str %)) represents the new java.lang.Integer(str(%))

Most of the Clojure library functions have defined semantics for objects of Java types. contains? and .get work on Java’s Maps, arrays, Strings, count works on Java Strings, Collections and arrays. Clojure is built around these aspects. It avails the performance of JVM and the richness of both the core APIs and the numerous third-party libraries written in the Java language and restrained from reinventing them.

=== Multiple Inheritance ===

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance][http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf 2] is the concept of using the methods and variables of more than one superclass to a sub class.Java was designed without multiple inheritance. But Java supports the solution of problems commonly solved with multiple inheritance in other ways with help of interfaces where the methods defined in it are not implemented.In Scala, classes are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance in Java.Lets see how multiple inheritance achieved in Scala:

As interfaces in Java, Scala allows traits but has some methods partially implemented. The only difference to classes is the traits may not have constructor parameters.

trait Similarity {
def isSimilar(x: Any): Boolean // not implemented
def isNotSimilar(x: Any): Boolean = !isSimilar(x) //implemented method
}

This trait defines two methods isSimilar and isNotSimilar where isSimilar does not provide a concrete method implementation (it is abstract in the terminology of Java), and the method isNotSimilar defines a concrete implementation. Consequently, classes that integrate this trait only have to provide a concrete implementation for isSimilar.

class Point(xc: Int, yc: Int) extends Similarity {
var x: Int = xc
var y: Int = yc
def isSimilar(obj: Any) = //need to implement the method here
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
}

object TraitsTest extends Application {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotSimilar(p2))
println(p1.isNotSimilar(p3)) //uses the already defined method
println(p1.isNotSimilar(2))
}

These are some of the aspects and traits of mixing functional and object-oriented approaches. As we discussed in the advantages section, both the approaches have their benefits and limitations. Mixing them aspect-wise enables the above features in such languages. Lets discuss those languages briefly in the next section.

== Languages Supporting Functional and OO code ==

OCaml and F#[[http://msdn.microsoft.com/en-us/library/dd233154.aspx 7]] are some of the languages which support both functional and object oriented programming. OCaml is as fast as C and its featured as [http://www.haskell.org/ Haskell] which is a pure functional language. F#[[http://oreilly.com/catalog/9780596153656 3]] is a dynamically typed language which can run on .NET framework and has supported immutable types i.e. tuples, records, discriminated unions and lists to work in Functional programming. It has functions that can either be in curried or in uncurried form. As in functional language it can pass functions as arguments to other functions, resulting in higher order functions. It also supports lambda functions and closures. F#,behaves like other .NET languages as both in imperative and object oriented style. 

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language and it is a dialect of Lisp. It is not a pure functional language and it is a dynamically typed language. Just like Java it runs on JVM platform. But its syntax differs from Java. It is represented as :

(functions arguments...)

The function followed by its arguments is enclosed in paranthesis. It has features like immutable data structures, high-order functions and recursion, easy and fast java interoperability. 

Python and Ruby are also the programming languages which offer the mix of functional and OO languages. But these languages doesn't support the algebraic data types and pattern matching.

==Conclusion ==
The above aspects of functional and object oriented programming techniques discuss some if their merits and demerits. Mixing them produces a new programming paradigm which leads to a new dimension in programming. A few fundamental concepts are explored in Clojure and Scala here. The ability of Clojure and Scala to run in JVM platform makes them more preferable than others in the market. Some of the merits like closure, less verbosity, high order functions, currying along with interoperation with previously written libraries in these languages make them more efficient and useful. There are also other languages which support functional and object oriented techniques. Mixing the approaches, evolve a new dimension in programming which is practical and opens doors to more exploration.

== References ==

# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-07T19:55:19Z

Dmcarmon: Added organization to top of page

= Introduction =

= Functional Programming =

= Object-Oriented Programming =

= Mixing Functional and Object-Oriented Programming =

== Motivation for Mixing ==

== Functional Techniques useful for Object-Oriented Programming ==

=== Lambda ===

=== Currying ===

=== Pattern Matching ===

== Examples of Mixing ==

=== Scala ===

=== Ruby ===

=== Clojure ===

= Conclusion =

= References =

= Mixing Functional & O-O code =

This chapter deals with the mixing of functional and object-oriented programming paradigms. We start with listing the different programming paradigms available today. We introduce functional and object-oriented approaches briefly and then discuss the advantages of one over the other. Following this, we discuss some aspects and features of mixing both the approaches. Finally, we talk about few languages that constitute such a mix.

== Programming Paradigms Today==

Several programmatic approaches to solve a particular task lead to distinct programming paradigms like, 
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
* Functional programming 
* Object Oriented programming 
* [http://en.wikipedia.org/wiki/Logic_programming Logical programming], etc. 
Lets focus on functional and object oriented programming approaches.

== Functional Programming ==

[http://en.wikipedia.org/wiki/Functional_programming Functional programming] is the task of decomposing a problem into a number of functions. Selectively executing these functions results in the solution to the problem. The functions mostly behave as mathematical. For given set of inputs the program should always return the same output. It usually concentrates on what type of problem we are dealing with rather than on the details of how to solve the problem. For example lets say there is a function which calculates area of a square. If we use it six times then we end up with area of a cube. Thus functional programming helps to build complex systems.

=== Approach ===

Expressions are the collection of variables and operations resulting in a single value this also deals with the way of solving the problem as expressions. Hence also called Expression related programming. It is structured as expression where each expression can be encapsulated in another yielding the result. Making the change in data structures as the program runs is called [http://en.wikipedia.org/wiki/Side_effect_(computer_science) side effects]. Purely functional language has no side effects. Language like Haskell is a pure functional language . Some languages need many approaches for achieving the desired result. Such languages are multi-paradigm. Examples for such languages are C++, Python,Lisp. Its like evaluating an expression and use the resulting value for something.

Structure of functional programming :

(fn2 ( fn1 ()[input list] ) []) => fn1 takes input list and the output of fn1 is used as input to fn2. Its a schematic representation of
how functional programming works.

Functional programming feature (Python) :

m = map(lambda i : i*i , numbers)
where ''numbers'' is an array of numbers and ''lambda'' is [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 closure].

Python has some functions like map, filter, reduce to support functional programming style. In the example above, the 'map' is a high-order function that takes a function and an array of numbers as input. The ''lambda'' takes i as input and returns i*i as output. Every result returned is appended to a list and produced as output. In functional programming, the programmer is given a natural framework for developing smaller, simpler, and more general modules, which are then glued together.

== Object Oriented Programming ==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] is a programming technique where everything is defined as an object. Objects are well-defined discrete bundles of data(attributes) and the associated functions(behavior). They are devised to resemble real-life objects and are uniquely identifiable by a name. The attributes could be of simple datatype(int, String, Boolean) or objects themselves. The behavior is defined by methods to use and manipulate the attributes. The values of attributes of an object at an instant is the state of the object. OO Programming allows objects to have their state retained throughout the code until manipulated otherwise. Objects are capable of housekeeping their own states, interacting and establishing relationships with other objects, inheriting, etc.

=== Fundamental concepts ===

A [http://en.wikipedia.org/wiki/Class_%28computer_science%29 class] is a user-defined datatype that provides implementation details to define the attributes and their properties. It is an abstract representation of an object(i.e.,) like a mold for objects.
An instance is an executable copy of a class. They are the actual objects created using the ‘class mold’ on run time.
Methods are a set of procedural statements or functions to define the behavior of an object, convey the current state, modify values of the attributes, etc.

Example :

An object in Java might look like this:

public class Person {
private String name;
public Person() {
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}

Here, OO Programming allows the programmer to set the ''name'' attribute of the class ''Person'' and get the name whenever needed in the code. An object of this class Person will remain in memory forever as long as there is a reference to it. As OO Programming allows objects to have their state retained, the value of the ''name'' attribute for a particular ''Person'' object remains the same across any part of the code until it is set differently.

=== Features ===

Three primary characteristics of object oriented programming are Encapsulation, Polymorphism, and Inheritance.
[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation] is the ability of objects to hide visibility of their attributes and behavior, thereby providing service independent of implementation.
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] allows identical operations to behave differently in different contexts. The operations that can be performed on an object make up its interface. They enable addressing of operations with the same name in different objects.
[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance] is one where an existing type can be used to derive a new type. Derived types inherit the data and operations of the super-type. And also, they can overwrite existing operations or add new ones.

There are other important features of O-O programming like [http://en.wikipedia.org/wiki/Message_passing message passing], [http://en.wikipedia.org/wiki/Abstraction abstraction], delegation, etc.

Now, we have seen both the approaches and their features in brief. Lets discuss the advantages of one over the other.

== Advantages ==

=== Functional Approach over OO Approach[[http://www.jot.fm/issues/issue_2009_09/article5.pdf 8]]===
* Functional programming solves the problem with lesser number of lines of code than the OO programming style. 
* There is no side effect as they use immutable data structures also called [http://en.wikipedia.org/wiki/Persistent_data_structure Persistent Data Structure] which will have no change in the state of variables. Hence program dont have to depend on history. 
* There is no limit in the numeric types used as opposed to OO languages which mainly depend on primitive data types. 
* A programmer is given the freedom to think in terms of what to solve in the problem rather than concentrating on how to solve and the flow of the program. 
* Suitable for calculation intensive programs.

=== OO Approach over Functional Approach===
* Everything can be represented in an object and it has the attributes associated with it and hence the state of the object is known at any time. 
* A complex system can be subdivided into modules of objects where as in functional approach, many functions inter operate to form a complex system. 
* [http://en.wikipedia.org/wiki/Reusability Re-usability] (i.e.) OO approach enables programmers to create new objects that inherits many of its features from existing objects. This makes object-oriented programs easier to modify than functional. 
* [http://en.wikipedia.org/wiki/Debug Debugging] in Object Oriented environment is easy compared with functional approach where a small error in one function causes the whole system (i.e. all the functions) to fail. 
* Suitable for making application-oriented software. 

Both the approaches have their advantages and disadvantages. What if we could get the best of both the worlds? The next section deals with the aspects and features of how well both the approaches are mixed together in some languages.

== Mixing Functional & OO Code - Best of both the worlds ==

Languages that are a mix of functional and object oriented approaches(eg. Scala[[http://www.scala-lang.org/node/1305 1]], Clojure[[http://oreilly.com/catalog/9781934356333 10]], etc.) make use of best of both the worlds. They support various aspects of functional and object oriented approaches. They have a bunch of functional approach features[[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf 6]], which object oriented programming languages(like Java) lack which includes closures. Closures are first-class functions with free variables that are bound in the lexical environment. These languages also sport a very malleable syntax that makes them well suited for "domain specific languages" with the benefits of static typing. They are more expressive, extensible and allow reuse of programming abstractions.

Certain languages like Scala, Clojure, etc run on Java Virtual Machine(JVM) ensuring portability to all underlying platforms. They even support immutable objects. In Scala, new language constructs can be added in the form of libraries. They allow safe reuse[[http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf 9]] of programming abstractions and type-safe extension of software.

===Lambda===

A lambda[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] expression is an anonymous function that contain expressions and statements, and can be used to create delegates or expression types. Such kind of anonymous function can be defined and passed around as easily as other data types and can be used to contain functionality that need not be named. Some notable examples include closures[[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5]] and currying. Lambda functions with no name can be called using the variable assigned to it.

g = lambda x: x*2
g(3)=6

We can have lambda function without assigning it to a variable which can be used as inline-function.

(lambda x: x*2)(3)

In [http://en.wikipedia.org/wiki/Clojure Clojure] as a functional language, the creation of a chunk of behavior that can be assigned to a variable (known as a lambda) is trivial. Below are two ways to create a lambda that returns the square of its argument.

(def square1 (fn [n] (* n n)))
(def square2 #(* % %))

===Currying ===

[http://en.wikipedia.org/wiki/Currying Currying] transforms a function that takes multiple parameters into a chain of functions, each taking a single parameter. It reuses a partially applied function where the function is originally defined as accepting n parameters.It can be interpreted as the technique to decompose a function that takes n parameters into n function each of them taking 1 parameter. For example to say in algebraic terms,consider the function f which takes 3 parameters x,y,z and Currying means that we can rewrite the function as a composition of 3 functions:

f(x,y,z) = 4*x+3*y+2*z
f(x)(y)(z) = 2*z+(3*y+(4*x))

In Scala, currying takes advantage of Scala’s syntactic sugar. Below is a currying example in Scala. This function creates a multiplier function which takes two arguments and partially defines it by assigning a constant to one argument and assigning it to a variable .Later the function is called by assigning the second argument.

def multiplier(i: Int)(factor: Int) = i * factor => method named multiplier which takes two parameters is defined
val byFive = multiplier(5) _ => The method is redefined with accepting one parameter and store it in a variable.
val byTen = multiplier(10) _

scala> byFive(2) => Method called by giving the second parameter.
res4: Int = 10

scala> byTen(2)
res5: Int = 20

===Less Verbosity===

In Java each variable should have its type defined beforehand. Whereas in languages like Scala, it is more concise and easier to read than the equivalent Java.

For example, a Map can be created with a simple syntax in Scala,Clojure than in Java:

<table>
<tr>
<td>
'''Java'''
Map<String, Integer> nMap = new HashMap<String, Integer>();
nMap.put("one", 1);
nMap.put("two", 2);
nMap.put("three", 3);
</td>
<td>
'''Scala'''

var nMap = Map("one" -> 1, "two" -> 2, "three" -> 3)

</td>
<td>
'''Clojure'''

(doto (new Java.util.HashMap)(.put “a” 1)(.put “b” 2))

</td>
</tr>
</table>

Here, Scala compiler knows that nMap uses Strings as keys, and Integers as values. Unlike Java, this need not be specified beforehand. Scala could figure it out itself. Moreover, Scala will give an error if a different key-value pair is tried to insert. This is called "type inference". This prevents a whole class of bugs at run time just like Java but with less verbosity.
In a similar way Clojure also involves only few lines of code compared with the object oriented Java language which takes many lines of code.A simple Clojure example and the associated Java code :
Example

(defn blank? [s] (every? #(Character/isWhitespace %) s))

The innermost function Character/isWhiteSpace checks the first argument % for any whitespace and returns true if it is. every? invoke the above inner function for all elements in the collection s.It has no variables, no branches etc.

Java code
isBlank() method checks to see whether a string is blank or contains only whitespace.

public class Stringcheck{
public static boolean isBlank(String str){
int len;
if(str==null || (strlen =str.length())==0)
return true;
for(int i=0; i<strlen;i++) {
if((Character.isWhitespace(str.charAt(i))==false)){
return false;
}
}
return true;
}
}

=== Pattern Matching ===

To say simply, a [http://en.wikipedia.org/wiki/Pattern_matching Pattern matching] is a technique to search string for the occurrence of any patterns or regularity. Pattern matching is an elegant way to decompose objects into their constituent parts for processing.Many languages support the concept of pattern matching. Perl supports pattern matching using the pattern definition mini language called regular expressions, also called regexes or REs, which is borrowed from the regular expressions used in many Unix tools, such as grep() and sed().The risk that the parts of an object might be changed outside of the control of the enclosing object is avoided. For example, if there is a Person class that contains a list of addresses, it will not be an issue to expose that list to clients if the list is immutable. The users will not be able to change the list unexpectedly.Given below is a simple example for pattern matching used in Perl:

$mystring = "Hello world!"; // Perls way of assigning string to a variable.
if($mystring =~ m/World/) { print "Yes"; } // Checks the string stored in variable mystring has the string "World".
$mystring =~ s/world/mom/; // Replaces the string "world" stored in mystring to mom.

Another sample of regular expression in java :

String mystring="Hello World" ;
Pattern str = Pattern.compile("\\w+"); => Pattern stored for matching.
Matcher fit = str.matcher(mystring); => Matcher class which perform matching of the string with the pattern defined.
if(fit.matches())

As languages like Scala and Clojure support procedural code, pattern matching is done as equal or with less difficulty compared with Java which needs to use regex. Scala can even be embedded into XML as its syntax is somewhat similar.Given below an overview of how regular expression is achieved in Clojure.
Data are manipulated in Clojure through the sequence called seq which is a logical list. Clojure can access java collections, its collections, Regular expression matches via the seq also called seq-able. Clojure's regular expression uses java.util.regex library at the lowest level. For achieving that the keyword re-seq is used.
Syntax:
(re-seq regexp string)
Example
(re-seq #"\w+" "Hello World") => ("Hello" "World") => #"\w+" represents the java.util.regex.Pattern

=== Java Interoperability ===
Considering Clojure, it gives clean, simple and direct access to java and can access Java API directly.Clojure doesnot wrap Java's string functions. We can call using Java interop forms. It provides syntax for accessing Java elements like classes, instances, constructors, methods and fields and can also wrap Java API. The “.” dot special form is used for accessing Java. Some Clojure syntax which can access Java API: 

{| class="wikitable" border="2"
|-
! Java
! Clojure
|-
| new Widget(“red”)
| (new Widget “red”)
|-
| Math.PI
| (.Math PI) or Math/PI
|-
| System.currentTimeMillis()
| (.System currentTimeMillis) or System/currentTimeMillis
|-
| rnd.nextInt()
| (.rnd nextInt) or (.nextInt rnd)
|-
|}

Clojure pass functions as arguments to other functions. But Java does not support this. So Clojure provides a member function memfn macro to wrap methods or can use anonymous function to wrap a method call.
(map (memfn toUpperCase) [“a” ,”short”,”message”])
or
(map #(.toUpperCase %)[“a”,”short”,”message”]) => #(body) represents the anonymous function in Clojure.

For example,
(def the-digits
(map #(Integer. (str %))(filter #(Character/isDigit %) (seq big-num-str))))

where (def big-num-str (str "123785334434se9088af8309304293872adbcdfd”))

The above code extracts the integers from string and discards the non-numeric characters. Lets look at the functions defined in the example. There are totally five functions defined.They are
(seq big-num-str) => get each character defined in big-num-str
(Character/isDigit %) => Checks whether the input is an integer
(filter #()) => Filter each string from str
(map #(Integer. (str %))) => Change the string to integer
(def the-digits) => Output the integers only in a string of characters.
Here,
#(Character/isDigit) represents the Java method Character.isDigit() and #(Integer.(str %)) represents the new java.lang.Integer(str(%))

Most of the Clojure library functions have defined semantics for objects of Java types. contains? and .get work on Java’s Maps, arrays, Strings, count works on Java Strings, Collections and arrays. Clojure is built around these aspects. It avails the performance of JVM and the richness of both the core APIs and the numerous third-party libraries written in the Java language and restrained from reinventing them.

=== Multiple Inheritance ===

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance][http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf 2] is the concept of using the methods and variables of more than one superclass to a sub class.Java was designed without multiple inheritance. But Java supports the solution of problems commonly solved with multiple inheritance in other ways with help of interfaces where the methods defined in it are not implemented.In Scala, classes are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance in Java.Lets see how multiple inheritance achieved in Scala:

As interfaces in Java, Scala allows traits but has some methods partially implemented. The only difference to classes is the traits may not have constructor parameters.

trait Similarity {
def isSimilar(x: Any): Boolean // not implemented
def isNotSimilar(x: Any): Boolean = !isSimilar(x) //implemented method
}

This trait defines two methods isSimilar and isNotSimilar where isSimilar does not provide a concrete method implementation (it is abstract in the terminology of Java), and the method isNotSimilar defines a concrete implementation. Consequently, classes that integrate this trait only have to provide a concrete implementation for isSimilar.

class Point(xc: Int, yc: Int) extends Similarity {
var x: Int = xc
var y: Int = yc
def isSimilar(obj: Any) = //need to implement the method here
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
}

object TraitsTest extends Application {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotSimilar(p2))
println(p1.isNotSimilar(p3)) //uses the already defined method
println(p1.isNotSimilar(2))
}

These are some of the aspects and traits of mixing functional and object-oriented approaches. As we discussed in the advantages section, both the approaches have their benefits and limitations. Mixing them aspect-wise enables the above features in such languages. Lets discuss those languages briefly in the next section.

== Languages Supporting Functional and OO code ==

OCaml and F#[[http://msdn.microsoft.com/en-us/library/dd233154.aspx 7]] are some of the languages which support both functional and object oriented programming. OCaml is as fast as C and its featured as [http://www.haskell.org/ Haskell] which is a pure functional language. F#[[http://oreilly.com/catalog/9780596153656 3]] is a dynamically typed language which can run on .NET framework and has supported immutable types i.e. tuples, records, discriminated unions and lists to work in Functional programming. It has functions that can either be in curried or in uncurried form. As in functional language it can pass functions as arguments to other functions, resulting in higher order functions. It also supports lambda functions and closures. F#,behaves like other .NET languages as both in imperative and object oriented style. 

Clojure[[http://oreilly.com/catalog/9781934356333 10]] is also a functional programming language and it is a dialect of Lisp. It is not a pure functional language and it is a dynamically typed language. Just like Java it runs on JVM platform. But its syntax differs from Java. It is represented as :

(functions arguments...)

The function followed by its arguments is enclosed in paranthesis. It has features like immutable data structures, high-order functions and recursion, easy and fast java interoperability. 

Python and Ruby are also the programming languages which offer the mix of functional and OO languages. But these languages doesn't support the algebraic data types and pattern matching.

==Conclusion ==
The above aspects of functional and object oriented programming techniques discuss some if their merits and demerits. Mixing them produces a new programming paradigm which leads to a new dimension in programming. A few fundamental concepts are explored in Clojure and Scala here. The ability of Clojure and Scala to run in JVM platform makes them more preferable than others in the market. Some of the merits like closure, less verbosity, high order functions, currying along with interoperation with previously written libraries in these languages make them more efficient and useful. There are also other languages which support functional and object oriented techniques. Mixing the approaches, evolve a new dimension in programming which is practical and opens doors to more exploration.

== References ==

# [http://www.scala-lang.org/node/1305 Bagwell. Learning Scala. Available from http://www.scala-lang.org/node/1305 (2009); Accessed 24 April 2010.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.23.4735&rep=rep1&type=pdf Bjarne Stroustrup. Multiple Inheritance for C++. 1999.]
# [http://oreilly.com/catalog/9780596153656 Chris Smith. Programming F#. O'Reilly Media, Sebastopol, CA, 2009.]
# [http://portal.acm.org/citation.cfm?id=1074217 Jean E. Sammet, David Hemmendinger. Encyclopedia of Computer Science. John Wiley and Sons Ltd., Chicester, UK, 2003.]
# [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf Jeremiah Willcock, Jaakko Jarvi, Doug Gregor, Bjarne Stroustrup, Andrew Lumsdaine. Lambda expressions and closures for C++. 2006.]
# [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.1464&rep=rep1&type=pdf Lee Braine. An Object-Oriented Functional Approach to Information Systems Engineering, Department of Computer Science, University College London.]
# [http://msdn.microsoft.com/en-us/library/dd233154.aspx Microsoft Corporation. Visual F#. Available from http://msdn.microsoft.com/en-us/library/dd233154.aspx (2010)]
# [http://www.jot.fm/issues/issue_2009_09/article5.pdf Ph. Narbel. Functional Programming at Work in Object-Oriented Programming. ETH Zurich, Chair of Software Engineering, Journal of Object Technology, 2009. Vol. 8, No. 6.]
# [http://www.cs.purdue.edu/homes/jv/510s05/papers/shriram-ecoop98.pdf Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman. Synthesizing Object-Oriented and Functional Design to Promote Re-use. European Conference on Object-Oriented Programming, 1998.]
# [http://oreilly.com/catalog/9781934356333 Stuart Hallway. Programming Clojure. Pragmatic Bookshelf, USA, 2009.]

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-07T18:54:49Z

Dmcarmon:

Under construction :)

= Level 1 =
asdf
== Level 2 ==
asfd
=== Level 3 ===
asdf

= Another Level 1 =

= For good measure =

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-07T18:54:18Z

Dmcarmon:

Under construction :)

= Level 1 =
asdf
== Level 2 ==
asfd
=== Level 3 ===
asdf

CSC/ECE 517 Fall 2012

2012-09-07T18:49:06Z

Dmcarmon:

*[[CSC/ECE 517 Fall 2012/ch1 n xx]]
*[[CSC/ECE 517 Fall 2012/ch1 1w1 rk]]
*[[CSC/ECE 517 Fall 2012/ch1 1w20 pp]]
*[[CSC/ECE 517 Fall 2012/ch1 1w6 pp]]
*[[CSC/ECE 517 Fall 2012/ch1 1w8 aa]]

CSC/ECE 517 Fall 2012/ch1 1w8 aa

2012-09-07T18:48:19Z

Dmcarmon: Created page

Under construction :)

CSC/ECE 506 Spring 2011/ch10a dc

2011-04-14T18:25:18Z

Dmcarmon: /* References */

Chapter 10a Supplement - Java Memory Model

=Introduction=

This chapter supplement discusses the [http://rsim.cs.illinois.edu/Pubs/popl05.pdf Java Memory Model] (JMM). First of all, we will cover the motivation for a memory model for Java. Secondly, the main aspects of JMM including happens-before relationships and final and volatile variables. And lastly, we'll mention double-checking.

=Motivation=

With [http://en.wikipedia.org/wiki/Parallel_computing parallel computing] becoming more popular, programming languages face many challenges including:

* multiple layers of cache across different processors (this introduces problems with [http://en.wikipedia.org/wiki/Cache_consistency cache consistancy])

* [http://en.wikipedia.org/wiki/Data_race data races] (that is, when two threads try to access the data at the same time when it is being altered by another thread)

* [http://en.wikipedia.org/wiki/Synchronization_(computer_science) synchronization] directives. Note: these may be different depending on whether you have a "strong" or "weak" memory model (see pages 290-313 in chapter 10 of Solihin's textbook, "Fundamentals of Parallel Computer Architecture)"

* compiler reordering of instructions (part of [http://en.wikipedia.org/wiki/Compiler_optimization compiler optimization])

Programmers need to know how these issues effect program execution so that they can write good software for parallel systems. For example, C/C++ has the [https://computing.llnl.gov/tutorials/pthreads/ pthreads] add-on to handle parallel programing. However, Java supports parallel programing by default. The JMM describes what is legal behavior for variables and memory accesses in programs with multiple threads.

=Main Aspects=

One of the most important parts of the Java Memory Model is the concept of [http://en.wikipedia.org/wiki/Happened-before "happens-before."] Two statements have a happens-before relationship if one must come before the other.

==Happens-before Illustration==
For example:

<pre>
// Thread 1
int xIsWritten = 0;
x = 1;
xIsWritten = 1;

// Thread 2
while(xIsWritten) {
};
</pre>

In this example it is important that the statement <tt>x = 1</tt> is completed before <tt>xIsWritten = 1</tt>, and that this order is seen by both threads. In other words, <tt>x = 1</tt> and <tt>xIsWritten</tt> need to have a happens-before relationship.

==Happens-before Rules==
Brian Goetz in [http://www2.lib.ncsu.edu/catalog/record/NCSU2282669 Java Concurrency in Practice] explains that happens-before relationships require the following rules:

* Program order rule - the order that statements are written in should be the order that every processor sees them executed in.

* Monitor lock rule - only one thread at a time is allowed to work on a synchronized method or block of code (synchronized means that it is protected by a monitor). Whenever a thread wants to enter a synchronized block of code it must acquire a lock (the monitor). The monitor lock rule insures that ever lock and unlock on the monitor is done in order. A monitor is like a key that a thread must get before it can access a synchronized method or block of code, and only one thread can have the key at any one time. Example code:

<pre>
// synchronized method
public synchronized insertLinkedList(int * element)
{ // each thread must acquire the monitor associated with the method
// here before executing the rest of the code

// ... code to insert element into linked list
}

// synchronized block
String myObj;
synchronized(myObj)
{ // each thread must acquire the monitor associated with the object
// before executing the rest of the code.

// ... critical code here
}
</pre>

Note: any java object regardless of type has a monitor associated with it which can be used to synchronize a block of code via <tt>synchronized(myObj)</tt>.

* Volatile variable rule - volatile variable rule says that a volatile variable is synchronized like a synchronized block of code or method is. In other words, only one thread at a time can write or read a volatile variable.

* Thread start rule - this ensures that insures that a thread can't start executing code before it has been properly set up (i.e. the call to Thread.start() has finished).

* Thread termination rule - this ensures that before a thread is terminated every other thread sees the result of the terminating thread's instructions.

* Interruption rule - one thread must complete the process of calling an interrupt on the other thread before the other thread starts servicing the interrupt.

* Finalizer rule - this ensures that the constructor finishes constructing the thread before the finalizer starts.

* Transitivity - ensures that [http://en.wikipedia.org/wiki/Transitive_relation transitive relationships] are kept. For example, if A follows B and C follows B then C *must* follow A.

These rules are the main framework for the Java programming model.
==Volatile and Final Variables==

[http://en.wikipedia.org/wiki/Volatile_variable#In_Java Volatile] and [http://en.wikipedia.org/wiki/Final_(Java) final] variables are also important to the JMM. As mentioned above in the happens-before rules, volatile variables may only be written or read by one thread at a time. Reads and writes to them have a global order. This is critical for global variables that may be written by more than one thread. On the other hand, a final variable can only be written once. This means that they are written once in the constructor of a object. Note that this does not imply that the variables are immutable (see reference for more information).

=Secondary Aspects=

Beyond the main principles of the Java Memory Model there are many details.

==Double-checked Locking==

One of the controversial issues that came up with parallel computing and the JMM was double-checked locking. People wanted to avoid time consuming synchronization so they implemented double-checked locking. Here is an example of double-checked locking from [http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html Jeremy Manson and Brien Goetz (2004)]

<pre>
// From Manson and Goetz (2004) JSR 133 (Java Memory Model) FAQ
// double-checked-locking - don't do this!

private static Something instance = null;

public Something getInstance() {
if (instance == null) {
synchronized (this) {
if (instance == null)
instance = new Something();
}
}
return instance;
}
</pre>

The problem with this code is that the reads may be reordered by the compiler (they are not happens-after statements). This means the code produces indeterminate results which could lead you to attempt to read from a null pointer while thinking that it had been initialized to new Something(). This can be avoided in the new version of the JMM by declaring the instance volatile due to the volatile rule.

A better alternative to this code is the [http://en.wikipedia.org/wiki/Initialization_on_demand_holder_idiom Initialization on Demand Holder Idiom]:

<pre>
// From Manson and Goetz (2004) JSR 133 (Java Memory Model) FAQ
private static class LazySomethingHolder {
public static Something something = new Something();
}

public static Something getInstance() {
return LazySomethingHolder.something;
}

</pre>

=Summary=

In summary the JMM is a useful and necessary tool. It's useful for programmers trying to deal with multiple threads; because, it lets them know what (and what not) to expect. The happens-after relationship allows the programmers to restrict certain instructions that must be done in order. And, the JMM is necessary because without the tools it provides for synchronization programs may have indeterminate results.

=References=

# Barney, Blaise [https://computing.llnl.gov/tutorials/pthreads/ POSIX Threads Programming]
# Goetz, Brian, [http://www2.lib.ncsu.edu/catalog/record/NCSU2282669 Java Concurrency in Practice]
# Manson and Goetz, [http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html JSR 133 (Java Memory Model) FAQ]
# Manson, Pugh and Adve, [http://rsim.cs.illinois.edu/Pubs/popl05.pdf The Java Memory Model]
# Solihin, Yan, Fundamentals of Parallel Computer Architencture
# Wikipedia, [http://en.wikipedia.org/wiki/Cache_consistency Cache Consistancy]
# Wikipedia, [http://en.wikipedia.org/wiki/Compiler_optimization Compiler Optimization]
# Wikipedia, [http://en.wikipedia.org/wiki/Data_race Data Race]
# Wikipedia, [http://en.wikipedia.org/wiki/Happened-before "Happened-before."]
# Wikipeida, [http://en.wikipedia.org/wiki/Initialization_on_demand_holder_idiom Initialization on Demand Holder Idiom]
# Wikipedia, [http://en.wikipedia.org/wiki/Parallel_computing Parallel Computing]
# Wikipedia, [http://en.wikipedia.org/wiki/Synchronization_(computer_science) Synchronization (computer science)]
# Wikipedia, [http://en.wikipedia.org/wiki/Transitive_relation Transitive Relation]
# Wikipedia, [http://en.wikipedia.org/wiki/Volatile_variable#In_Java Volatile Volatile Variables]
# Wikipedia, [http://en.wikipedia.org/wiki/Final_(Java) Final (Java)]

CSC/ECE 506 Spring 2011/ch10a dc

2011-04-14T18:24:23Z

Dmcarmon: rewrote for clarity and added more examples and references

Chapter 10a Supplement - Java Memory Model

=Introduction=

This chapter supplement discusses the [http://rsim.cs.illinois.edu/Pubs/popl05.pdf Java Memory Model] (JMM). First of all, we will cover the motivation for a memory model for Java. Secondly, the main aspects of JMM including happens-before relationships and final and volatile variables. And lastly, we'll mention double-checking.

=Motivation=

With [http://en.wikipedia.org/wiki/Parallel_computing parallel computing] becoming more popular, programming languages face many challenges including:

* multiple layers of cache across different processors (this introduces problems with [http://en.wikipedia.org/wiki/Cache_consistency cache consistancy])

* [http://en.wikipedia.org/wiki/Data_race data races] (that is, when two threads try to access the data at the same time when it is being altered by another thread)

* [http://en.wikipedia.org/wiki/Synchronization_(computer_science) synchronization] directives. Note: these may be different depending on whether you have a "strong" or "weak" memory model (see pages 290-313 in chapter 10 of Solihin's textbook, "Fundamentals of Parallel Computer Architecture)"

* compiler reordering of instructions (part of [http://en.wikipedia.org/wiki/Compiler_optimization compiler optimization])

Programmers need to know how these issues effect program execution so that they can write good software for parallel systems. For example, C/C++ has the [https://computing.llnl.gov/tutorials/pthreads/ pthreads] add-on to handle parallel programing. However, Java supports parallel programing by default. The JMM describes what is legal behavior for variables and memory accesses in programs with multiple threads.

=Main Aspects=

One of the most important parts of the Java Memory Model is the concept of [http://en.wikipedia.org/wiki/Happened-before "happens-before."] Two statements have a happens-before relationship if one must come before the other.

==Happens-before Illustration==
For example:

<pre>
// Thread 1
int xIsWritten = 0;
x = 1;
xIsWritten = 1;

// Thread 2
while(xIsWritten) {
};
</pre>

In this example it is important that the statement <tt>x = 1</tt> is completed before <tt>xIsWritten = 1</tt>, and that this order is seen by both threads. In other words, <tt>x = 1</tt> and <tt>xIsWritten</tt> need to have a happens-before relationship.

==Happens-before Rules==
Brian Goetz in [http://www2.lib.ncsu.edu/catalog/record/NCSU2282669 Java Concurrency in Practice] explains that happens-before relationships require the following rules:

* Program order rule - the order that statements are written in should be the order that every processor sees them executed in.

* Monitor lock rule - only one thread at a time is allowed to work on a synchronized method or block of code (synchronized means that it is protected by a monitor). Whenever a thread wants to enter a synchronized block of code it must acquire a lock (the monitor). The monitor lock rule insures that ever lock and unlock on the monitor is done in order. A monitor is like a key that a thread must get before it can access a synchronized method or block of code, and only one thread can have the key at any one time. Example code:

<pre>
// synchronized method
public synchronized insertLinkedList(int * element)
{ // each thread must acquire the monitor associated with the method
// here before executing the rest of the code

// ... code to insert element into linked list
}

// synchronized block
String myObj;
synchronized(myObj)
{ // each thread must acquire the monitor associated with the object
// before executing the rest of the code.

// ... critical code here
}
</pre>

Note: any java object regardless of type has a monitor associated with it which can be used to synchronize a block of code via <tt>synchronized(myObj)</tt>.

* Volatile variable rule - volatile variable rule says that a volatile variable is synchronized like a synchronized block of code or method is. In other words, only one thread at a time can write or read a volatile variable.

* Thread start rule - this ensures that insures that a thread can't start executing code before it has been properly set up (i.e. the call to Thread.start() has finished).

* Thread termination rule - this ensures that before a thread is terminated every other thread sees the result of the terminating thread's instructions.

* Interruption rule - one thread must complete the process of calling an interrupt on the other thread before the other thread starts servicing the interrupt.

* Finalizer rule - this ensures that the constructor finishes constructing the thread before the finalizer starts.

* Transitivity - ensures that [http://en.wikipedia.org/wiki/Transitive_relation transitive relationships] are kept. For example, if A follows B and C follows B then C *must* follow A.

These rules are the main framework for the Java programming model.
==Volatile and Final Variables==

[http://en.wikipedia.org/wiki/Volatile_variable#In_Java Volatile] and [http://en.wikipedia.org/wiki/Final_(Java) final] variables are also important to the JMM. As mentioned above in the happens-before rules, volatile variables may only be written or read by one thread at a time. Reads and writes to them have a global order. This is critical for global variables that may be written by more than one thread. On the other hand, a final variable can only be written once. This means that they are written once in the constructor of a object. Note that this does not imply that the variables are immutable (see reference for more information).

=Secondary Aspects=

Beyond the main principles of the Java Memory Model there are many details.

==Double-checked Locking==

One of the controversial issues that came up with parallel computing and the JMM was double-checked locking. People wanted to avoid time consuming synchronization so they implemented double-checked locking. Here is an example of double-checked locking from [http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html Jeremy Manson and Brien Goetz (2004)]

<pre>
// From Manson and Goetz (2004) JSR 133 (Java Memory Model) FAQ
// double-checked-locking - don't do this!

private static Something instance = null;

public Something getInstance() {
if (instance == null) {
synchronized (this) {
if (instance == null)
instance = new Something();
}
}
return instance;
}
</pre>

The problem with this code is that the reads may be reordered by the compiler (they are not happens-after statements). This means the code produces indeterminate results which could lead you to attempt to read from a null pointer while thinking that it had been initialized to new Something(). This can be avoided in the new version of the JMM by declaring the instance volatile due to the volatile rule.

A better alternative to this code is the [http://en.wikipedia.org/wiki/Initialization_on_demand_holder_idiom Initialization on Demand Holder Idiom]:

<pre>
// From Manson and Goetz (2004) JSR 133 (Java Memory Model) FAQ
private static class LazySomethingHolder {
public static Something something = new Something();
}

public static Something getInstance() {
return LazySomethingHolder.something;
}

</pre>

=Summary=

In summary the JMM is a useful and necessary tool. It's useful for programmers trying to deal with multiple threads; because, it lets them know what (and what not) to expect. The happens-after relationship allows the programmers to restrict certain instructions that must be done in order. And, the JMM is necessary because without the tools it provides for synchronization programs may have indeterminate results.

=References=

# Barney, Blaise [https://computing.llnl.gov/tutorials/pthreads/ POSIX Threads Programming]
# Goetz, Brian, [http://www2.lib.ncsu.edu/catalog/record/NCSU2282669 Java Concurrency in Practice]
# Manson and Goetz, [http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html JSR 133 (Java Memory Model) FAQ]
# Manson, Pugh and Adve, [http://rsim.cs.illinois.edu/Pubs/popl05.pdf The Java Memory Model]
# Solihin, Yan, Fundamentals of Parallel Computer Architencture
# Wikipedia, [http://en.wikipedia.org/wiki/Cache_consistency Cache Consistancy]
# Wikipedia, [http://en.wikipedia.org/wiki/Compiler_optimization Compiler Optimization]
# Wikipedia, [http://en.wikipedia.org/wiki/Data_race Data Race]
# Wikipedia, [http://en.wikipedia.org/wiki/Happened-before "Happened-before."]
# Wikipeida, [http://en.wikipedia.org/wiki/Initialization_on_demand_holder_idiom Initialization on Demand Holder Idiom]
# Wikipedia, [http://en.wikipedia.org/wiki/Parallel_computing Parallel Computing]
# Wikipedia, [http://en.wikipedia.org/wiki/Synchronization_(computer_science) Synchronization (computer science)]
# Wikipedia, [http://en.wikipedia.org/wiki/Transitive_relation Transitive Relation]
# Wikipedia, [[http://en.wikipedia.org/wiki/Volatile_variable#In_Java Volatile] Volatile Variables]
# Wikipedia, [http://en.wikipedia.org/wiki/Final_(Java) Final (Java)]

CSC/ECE 506 Spring 2011/ch2 dm

2011-04-11T22:04:41Z

Dmcarmon: Edited due to feedback

=Supplement to Chapter 2: The Data Parallel Programming Model=

Chapter 2 of [[#References | Solihin (2008)]] covers the shared memory and message passing parallel programming models. However, it does not address the [http://portal.acm.org/citation.cfm?id=1239917 data parallel] model (a model composed of a set of identical tasks which operate on different subsets of common data), another commonly recognized parallel programming model covered in other treatments like [http://www.mcs.anl.gov/~itf/dbpp/ Foster (1995)] and [[#References | Culler (1999)]].

==Introduction==

The data parallel programming model (mentioned in conference proceedings as early as [http://portal.acm.org/citation.cfm?id=642120 1974]) is a programming model for SIMD (Single Instruction, Multiple Data) parallel machines. It's defined as multiple processing elements performing an action simultaneously on different parts of a data set and exchanging information globally before processing more code synchronously. Although the shared memory and message passing models are often presented as competing models, the data parallel model addresses fundamentally different programming concerns and can be used in conjunction with either. The main distinction between the data parallel model and the other two models has to do with the outcome of the individual steps instead of the method of communication. The data parallel model was developed for scientific calculations and is generally associated with applications that involve a data set which is typically organized into a common structure, such as an array or matrix. Data parallel processing has been found to be effective in situations where the computations allow the processing to be divided spatially over memories by involving every element of a matrix in a uniform way.

In addition to the data parallel model, the task parallel model (a model composed of a set of differing tasks which operate on common data.) will also be introduced briefly in [[#Appendix_B:_Data_Parallel_Versus_Task-parallel | Appendix B]] as a point of contrast with the data-parallel model. Furthermore, we will discuss the role of the shared memory and message passing models in the history of parallel computing. The goal of this supplement is to provide a treatment of the data parallel model which complements Chapter 2 of [[#References | Solihin (2008)]].

=Examples with the Data Parallel Model, Shared Memory, and Message Passing=

While the [http://www.cs.cf.ac.uk/Parallel/Year2/section4.html shared memory and message passing] models focus on how parallel tasks access common data, the data parallel model focuses on how to divide up work into parallel instructions. Data parallel algorithms exploit parallelism by dividing a problem into a number of identical instructions which execute on different subsets of common data.

==Preliminary Example==

A supporting example of a data parallel code can be seen in Code 2.5 from [[#References | Solihin (2008)]]. Shown below, it has been annotated with comments identifying the region of the code which is data parallel.

// Data parallel code, adapted from [[#References|Solihin (2008), p. 27.]]

id = getmyid(); // Assume id = 0 for thread 0, id = 1 for thread 1
local_iter = 4;
start_iter = id * local_iter;
end_iter = start_iter + local_iter;

if (id == 0)
send_msg(P1, b[4..7], c[4..7]);
else
recv_msg(P0, b[4..7], c[4..7]);

// Begin data parallel section

for (i = start_iter; i < end_iter; i++)
a[i] = b[i] + c[i];
local_sum = 0;
for (i = start_iter; i < end_iter; i++)
if (a[i] > 0)
local_sum = local_sum + a[i];

// End data parallel section

if (id == 0)
{
recv_msg(P1, &local_sum1);
sum = local_sum + local_sum1;
Print sum;
}
else
send_msg(P0, local_sum);

In the code above, the three 8 element arrays are each divided into two 4 element chunks. In the data parallel section, the code executed by the two threads is identical, but each thread operates on a different chunk of data.

==Main Example==

Our main example is as follows. Suppose we want to perform the following operation on an array <code>a</code>: updating each element of <code>a</code> by the product of itself and its index, and adding together the elements of <code>a</code> into the variable <code>sum</code>. The corresponding code is shown below.

// simple sequential operation
sum = 0;
'''for''' (i = 0; i < a.length; i++)
{
a[i] = a[i] * i;
sum = sum + a[i];
}

When we orchestrate the operation using the data parallel programming model, the program can be divided into two parts. The first part performs the same operations on separate elements of the array for each processing element (sometimes referred to as PE). The second part reorganizes data among all processing elements (In our example data reorganization is summing up values across different processing elements).

===First Part: Decomposition===

The data parallel programming model defines the overall effects of parallel steps for the first part. [[#References | Hillis (1986)]] points out that a major benefit of data parallel algorithms is that they easily scale to take advantage of additional processing elements simply by dividing the data into smaller chunks. [[#References | Haveraaen (2000)]] also notes that data parallel codes typically bear a strong resemblance to sequential codes, making them easier to read and write.

The three code fragments below are examples for the first part of the program, shared-memory version of the second part, and message passing for the second part, respectively.

// data parallel programming: let each PE perform the same operation on different pieces of distributed data
pe_id = getid();
my_sum = 0;
'''for''' (i = pe_id; i < a.length; i += number_of_pe) //separate elements of the array are assigned to each PE
{
a[i] = a[i] * i;
my_sum = my_sum + a[i]; //all PEs accumulate elements assigned to them into local variable my_sum
}

In the above code, data parallelism is achieved by letting each processing element perform actions on array's separate elements, which are identified using the PE's id (<tt>pe_id</tt>. For instance, if three processing elements are used then one processing element would start at <tt>i = 0</tt>, one would start at <tt>i = 1</tt>, and the last would start at <tt>i = 2</tt>. Since there are three processing elements, the index of the array for each will increase by three on each iteration until the operation is complete (note that in our example elements assigned to each PE are interleaved instead of continuous). If the length of the array is a multiple of three then each processing element takes the same amount of time to execute its portion of the operation.

The picture below illustrates how elements of the array are assigned among different PEs for the specific case: length of the array is 7 and there are 3 PEs available. Elements in the array are marked by their indexes (0 to 6). As shown in the picture, PE0 will work on elements with index 0, 3, 6; PE1 is in charge of elements with index 1, 4; and elements with index 2, 5 are assigned to PE2. In this way, these 3 PEs work collectively on the array, while each PE works on different elements. Thus, data parallelism is achieved.

[[Image:506wiki1.png|frame|center|150px|Illustration of data parallel programming(adapted from [http://computing.llnl.gov/tutorials/parallel_comp/#ModelsData Introduction to Parallel Computing])]]

===Second Part: Orchestration===

The second part can be accomplished either through shared memory or message passing. The code below shows how data reorganization is done by the shared memory programming model. A shared variable is declared to store the global sum. Each PE accumulates their local my_sum into this variable. In this example, the <tt>lock()</tt> and <tt>unlock()</tt> routines are used to prevent race conditions and barrier ensures that all the local <tt>my_sum</tt> variables have been accumulated into the shared variable <tt>sum</tt> before the code proceeds. Notice that in this model there is only one copy of the data like in the data parallel model. However, in the shared memory model, the data must be protected since any PE could be using it at any point, whereas data is associated with a specific PE in the data parallel model.

// data reorganization via shared memory
'''shared''' sum;
lock(); //prevent race condition
sum = sum + my_sum; //each PE adds up their local my_sum to shared variable sum
unlock();
barrier;

The following section of code shows how data reorganization is done by the message passing programming model. PE0 acts as the one that collects the local my_sum variable from all the other PEs. This is done by the <tt>send_msg()</tt> and the <tt>recv_msg()</tt> routines: PEs other than PE0 send their my_sum variable as a message to PE0. PE0 receives the messages by specifying the sender in the '''for''' loop. PE ids are used in the message passing model in the same way they are in the data parallel model. On the contrary, in the data parallel model there is only one copy of data that is processed and there is no need to do any final accumulation by a single PE.

// data reorganization via message passing
'''if''' (pe_id != 0) send_msg (0, my_sum); //PE other than PE0 send their local my_sum
'''else''' //PE0 does this
{
'''for''' (i = 1; i < number_of_pe; i++) //for each other PE
{
recv_msg (i, temp); //receive local sum from other PEs
my_sum = my_sum + temp; //accumulate into total
}
sum = my_sum;
}

=History of Parallel Programming Models=

==Superscalar Machines==

A [http://en.wikipedia.org/wiki/Superscalar superscalar] processor is a pipelined processor able to retire multiple instructions in one cycle. The first superscalar machine was Cray's CDC 6600. It was released in 1964 and could execute 1 million floating point operations per second (1 MFLOP).

The CDC 6600 gained most of its speed through delegating memory access and I/O to other processors, handling only arithmetic and logic. These peripheral processors, and the main CPU, could be designed to be as simple as possible. The CDC 6600 remained the world's fastest computer until 1969, being replaced by the CDC 7600.

==Vector Machines==

First appearing in the late 1960s, [http://en.wikipedia.org/wiki/Vector_processor vector machines] were able to apply a single instruction to multiple data values. This type of operation is used frequently in scientific fields or in multimedia.

The Solomon project at Westinghouse was one of the first machines to use vector operations.
Its CPU had a large number of ALUs that would each be fed different data each cycle.
Solomon was unsuccessful and was cancelled, eventually to be reborn as the [http://research.microsoft.com/en-us/um/people/gbell/computer_structures__readings_and_examples/00000340.htm ILLIAC IV] at the University of Illinois. The ILLIAC IV showed great success at solving data-intensive problems, peaking at 150 MFLOPS under the right conditions.

An innovation came with the [http://en.wikipedia.org/w/index.php?title=Cray-1&oldid=409177730 Cray-1] supercomputer in 1976. The innovation stemmed from the fact that the large data sets are often manipulated by several instructions back-to-back, such as an addition followed by a multiplication. The [http://en.wikipedia.org/wiki/Instruction_pipeline instruction pipeline] of the Cray-1 was tweaked to take advantage of this using [http://people.engr.ncsu.edu/efg/506/s01/lectures/notes/lec28.pdf vector chaining]. In the ILLIAC, up to 64 data points were loaded from memory with every instruction, but had to be stored back to manipulate the rest of the vector. The Cray computer was only able to load 12 data points, but by completing multiple instructions before continuing the total number of memory accesses decreased.
In addition, the Cray-1 could perform at 240 MFLOPS. There continued to be new editions of Cray computers, the[http://en.wikipedia.org/wiki/Cray-2, Cray-2], [http://en.wikipedia.org/wiki/Cray-3 Cray-3] etc. One of the most recent versions, [http://en.wikipedia.org/wiki/Cray-YMP Cray Y-MP], was sold from 1988 and used a MIMD architecture.

One of the later vector machines was the [http://www.museumwaalsdorp.nl/computer/en/comp891E.html ETA10]. It had shared memory 4M words and common memory 8M words, where each word was 64 bits. It was clocked at 24ns, but had a theorectical peak speed of 146 Mflops.

Many of these early machines were shared memory machines. This is likely because the shared memory machines offer a easier to work with programming model and they had small enough systems that they did not worry about scallability. Also, memory was very expensive and message passing requires multiple copies of data.

==Connection Machines==

[http://longnow.org/essays/richard-feynman-connection-machine/ The connection machine] was a data parallel machine built in the 1980s. A connection machine had on the order of 64,000 processors. Each processor computed one bit of data and was connected to others via hypercube wiring. [http://www.mission-base.com/tamiko/cm/index.html Tamiko Thiel] describes the machine as being modeled after a human brain. The second connection machine (CM-2) which had more RAM and included floating point adders [http://en.wikipedia.org/wiki/Connection_Machine] came out in 1987, and two smaller editions, the CM-2a and the CM-200, were developed later.

==Distributed Memory and Message Passing==

In the 1980s, a manufacturing limit led to increased support for multiprocessor systems. The [http://en.wikipedia.org/wiki/Transputer transputer] architecture by Inmos was one of the first general-purpose microprocessors designed for parallel computing. The first transputers were released in 1984. Transputers were designed to be easily interlinkable; multiple processing chips could be easily combined into one system.

Each transputer processor could communicate with up to four other processors at up to 20 Mbps. Any number of processors could be combined into a massive processing farm. Of course, in large nets, the delay would be too great for any significant message passing.

==Recent Data Parallel Computing==

Today data parallelism is most commonly done in GPUs, due to the nature of graphics computation. Because GPUs often share memory with the main computer processor and other elements, they most commonly have a [http://en.wikipedia.org/wiki/Shared_Memory_Architecture shared memory architecture]. The supplement for [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_506_Spring_2011/ch2a_mc chapter 2a] discusses GPUs in depth.

=Summary=

Through the history of parallel computing we may observe the tradeoffs between the shared memory and message passing models. In the beginning, due to parallel programming being done for the most part exclusively on expensive and custom-made super computers, shared memory systems made sense. Later on, the invention of the personal computer and wider availability of smaller and less expensive computers led more people to a message passing approach. Furthermore, the message passing approach scales better. Most recently, data parallelism has been done with GPUs. Although shared-memory and message-passing models may be combined into hybrid approaches, the two models are fundamentally different ways of addressing the same problem (of access control to common data). In contrast, the data parallel model is concerned with a fundamentally different problem (how to divide work into parallel tasks). As such, the data parallel model may be used in conjunction with either the shared memory or the message passing model without conflict. In fact, [[#References | Klaiber (1994)]] compares the performance of a number of data parallel programs implemented with both shared memory and message passing models.

One of the major advantages of combining the data parallel and message passing models is a reduction in the amount and complexity of communication required relative to a task parallel approach. Similarly, combining the data parallel and shared memory models tends to simplify and reduce the amount of synchronization required. If the task parallel code given in the appendix were modified from a message passing model to a shared memory model, the two threads would require 8 signals be sent between the threads (instead of 8 messages). In contrast, the data parallel code would require a single barrier before the local sums are added to compute the full sum.

Much as the shared memory model can benefit from specialized hardware, the data parallel programming model can as well. [http://en.wikipedia.org/wiki/SIMD SIMD (single-instruction-multiple-data)] processors are specifically designed to run data parallel algorithms. These processors perform a single instruction on many different data locations simultaneously. Modern examples include [http://en.wikipedia.org/wiki/CUDA CUDA processors] developed by nVidia and [http://en.wikipedia.org/wiki/Cell_%28microprocessor%29 Cell processors] developed by STI (Sony, Toshiba, and IBM). For the curious, example code for CUDA processors is provided in the [[#Appendix C: C for CUDA Example Code | Appendix]]. However, whereas the shared memory model can be a difficult and costly abstraction in the absence of hardware support, the data parallel model—like the message passing model—does not require hardware support.

Since data parallel code tends to simplify communication and synchronization, data parallel code may be easier to develop than a more task parallel approach. Once written, data parallel programs can scale easily to large numbers of processors. The data parallel model implicitly encourages data locality by having each thread work on a chunk of data, and the regular data chunks also make it easier to reason about where to locate data and how to organize it. On the other hand, it is possible that a problem may not decompose easily into subproblems relying on largely independent chunks of data. In this case, it may be impractical or impossible to apply the data parallel model.

The table below is extended from Table 2.1 on page 22 of the Solihin text. A column has been added for the data parallel model. The table compares some key characteristics of each programming model. As you can see, the complexity of the data parallel model comes mainly in the form of dividing up the work among PEs. Most of this work is done by the programmer and does not necessarily require special hardware, although, specific types of hardware can optimize the benefits of the model. For instance, SIMD and SPMD (single program, multiple data) hardware are examples that have efficiently utilized the data parallel model.

{| align="center" class="wikitable" style="text-align:center;" border="1" !cellpadding = "2"
|+
! Aspects !! Data-Parallel !! Shared Memory !! Message Passing
|-
! Communication
| implicit - via loads/stores || implicit - via loads/stores || explicit messages
|-
! Synchronization
| none || explicit || implicit - via messages
|-
! Hardware support
| none || typically required || none
|-
! Development effort
| low || low || high
|-
! Tuning effort
| high || high || low
|}

=Definitions=

* ''Data parallel.'' A data parallel algorithm is composed of a set of identical tasks which operate on different subsets of common data.
* ''Task parallel.'' A task parallel algorithm is composed of a set of differing tasks which operate on common data.
* ''SIMD (single-instruction-multiple-data).'' A processor which executes a single instruction simultaneously on multiple data locations.

=References=

* Alexander C. Klaiber and Henry M. Levy, [http://portal.acm.org/citation.cfm?id=192020 "A comparison of message passing and shared memory architectures for data parallel programs,"] in ''Proceedings of the 21st Annual International Symposium on Computer Architecture,'' April 1994, pp. 94-105.

* Barnes et al., [http://research.microsoft.com/en-us/um/people/gbell/computer_structures__readings_and_examples/00000340.htm The ILLIAC IV Computer]
* Björn Lisper, ''Data parallelism and functional programming'', Lecture Notes in Computer Science, Volume 1132/1996, pp. 220-251, Springer Berlin, 1996.

* Blaise Barney, "Introduction to Parallel Computing: Data Parallel Model", Lawrence Livermore National Laboratory, [https://computing.llnl.gov/tutorials/parallel_comp/#ModelsData https://computing.llnl.gov/tutorials/parallel_comp/#ModelsData], January 2009.

* Computations Science Education Project, [http://www.phy.ornl.gov/csep/ca/node24.html Vector Processors]

* ''C.mmp - A multi-mini-processor'', W. A. Wulf and C. G. Bell, C-MU 1972 http://research.microsoft.com/en-us/um/people/gbell/CGB%20Files/Cmmp%20Multi-Mini-Processor%20ComConference%201972%20c.pdf

* [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_506_Spring_2011/ch2a_mc CSC/ECE_506_Spring_2011/ch2a_mc]

* David E. Culler, Jaswinder Pal Singh, and Anoop Gupta, ''Parallel Computer Architecture: A Hardware/Software Approach'', Gulf Professional Publishing, August 1998.

* David E. Culler, Jaswinder Pal Singh, and Anoop Gupta, [http://portal.acm.org/citation.cfm?id=550071 ''Parallel Computer Architecture: A Hardware/Software Approach,''] Morgan-Kauffman, 1999.

* Gehringer, Ed, [http://people.engr.ncsu.edu/efg/506/s01/lectures/notes/lec28.pdf Vector Chaining]

* Guy Blelloch, "Is Parallel Programming Hard?", Carnegie Mellon University, [http://www.cilk.com/multicore-blog/bid/9108/Is-Parallel-Programming-Hard http://www.cilk.com/multicore-blog/bid/9108/Is-Parallel-Programming-Hard], April 2009.

* History of Cluster Computing http://cunday.blogspot.com/2009/01/history-of-cluster-computing.html

* Ian Foster, [http://www.mcs.anl.gov/~itf/dbpp/ ''Designing and Building Parallel Programs,''] Addison-Wesley, 1995.

* Magne Haveraaen, [http://portal.acm.org/citation.cfm?id=1239917 "Machine and collection abstractions for user-implemented data-parallel programming,"] ''Scientific Programming,'' 8(4):231-246, 2000.

* Philip J. Hatcher, Michael Jay Quinn, ''Data-Parallel Programming on MIMD Computers'', The MIT Press, 1991.

*Radoy and Lipovski, [http://portal.acm.org/citation.cfm?id=642120 "Switched multiple instruction, multiple data stream processing", ISCA '75 Proceedings of the 2nd annual symposium on Computer architecture]

* Shared Memory and Message Passing http://www.cs.cf.ac.uk/Parallel/Year2/section4.html

* ''The period 1989 - 1994: ETA and CONVEX: between -40 and +40 Centigrade'' http://www.museumwaalsdorp.nl/computer/en/comp891E.html

* W. Daniel Hillis and Guy L. Steele, Jr., [http://portal.acm.org/citation.cfm?id=7903 "Data parallel algorithms,"] ''Communications of the ACM,'' 29(12):1170-1183, December 1986.

* Yan Solihin, ''Fundamentals of Parallel Computer Architecture: Multichip and Multicore Systems'', Solihin Books, August 2009.
* Wikipedia, IBM Personal Computer [http://en.wikipedia.org/wiki/IBM_Personal_Computer]

* Wikipedia, C.mmp [http://en.wikipedia.org/wiki/C.mmp]

* Wikipedia, CDC 6600 [http://en.wikipedia.org/wiki/CDC_6600]

* Wikipedia, Computer Cluster [http://en.wikipedia.org/wiki/Computer_cluster]

* Wikipedia, Cray-1 [http://en.wikipedia.org/w/index.php?title=Cray-1&oldid=409177730]

* Wikipedia, Lockstep [http://en.wikipedia.org/wiki/Lockstep_(computing) http://en.wikipedia.org/wiki/Lockstep_(computing)].

* Wikipedia, MIMD [http://en.wikipedia.org/wiki/MIMD http://en.wikipedia.org/wiki/MIMD].

* Wikipedia, Shared Memory Architecture [http://en.wikipedia.org/wiki/Shared_Memory_Architecture]

* Wikipedia, SIMD [http://en.wikipedia.org/wiki/SIMD http://en.wikipedia.org/wiki/SIMD].

* Wikipedia, SPMD [http://en.wikipedia.org/wiki/SPMD http://en.wikipedia.org/wiki/SPMD].

* Wikipedia, Transputer http://en.wikipedia.org/wiki/Transputer

* Wikipedia, Vector processor http://en.wikipedia.org/wiki/Vector_processor

* Wikipedia, VMScluster http://en.wikipedia.org/wiki/VMScluster



=Appendix A: Example of Data Parallel with Other Code=

Comparison of the data parallel section of code identified above with the sequential Code 2.3 of [[#References | Solihin (2008)]], which is reproduced below, supports the assertions of Hillis and Haveraaen mentioned above. The only differences between Codes 2.4 and 2.3 are the start and end indices and that, in the data parallel example, the variable sum is replaced by a private variable. Structurally the two codes are identical.

// Sequential code, from [[#References|Solihin (2008), p. 25.]]

for (i = 0; i < 8; i++)
a[i] = b[i] + c[i];
sum = 0;
for (i = 0; i < 8; i++)
if (a[i] > 0)
sum = sum + a[i];
Print sum;

=Appendix B: Data Parallel Versus Task-parallel=

The logical opposite of data parallel is [[#Definitions | ''task parallel,'']] in which a number of distinct tasks operate on common data. An example of a task parallel code which is functionally equivalent to the sequential and data parallel codes given above follows below for code 2.3 of [[#References | Solihin (2008)]] which was above written in data parallel format.

// Task parallel code.

int id = getmyid(); // assume id = 0 for thread 0, id = 1 for thread 1

if (id == 0)
{
for (i = 0; i < 8; i++)
{
a[i] = b[i] + c[i];
send_msg(P1, a[i]);
}
}
else
{
sum = 0;
for (i = 0; i < 8; i++)
{
recv_msg(P0, a[i]);
if (a[i] > 0)
sum = sum + a[i];
}
Print sum;
}

In the code above, work is divided into two parallel tasks. The first performs the element-wise addition of arrays ''b'' and ''c'' and stores the result in ''a.'' The other sums the elements of ''a.'' These tasks both operate on all elements of ''a'' (rather than on separate chunks), and the code executed by each thread is different (rather than identical).

Since each parallel task is unique, a major limitation of task parallel algorithms is that the maximum degree of parallelism attainable is limited to the number of tasks that have been formulated. This is in contrast to data parallel algorithms, which can be scaled easily to take advantage of an arbitrary number of processing elements. In addition, unique tasks are likely to have significantly different run times, making it more challenging to balance load across processors. [[#References | Haveraaen (2000)]] also notes that task parallel algorithms are inherently more complex, requiring a greater degree of communication and synchronization. In the task parallel code above, after thread 0 computes an element of ''a'' it must send it to thread 1. To support this, sends and receives occur every iteration of the two loops, resulting in a total of 8 messages being sent between the threads. In contrast, the data parallel code sends only 2 messages, one at the beginning and one at the end. The table below summarizes the key differences between data parallel and task parallel programming models.

{| class="wikitable" border="1" align="center"
|+ '''Comparison between data parallel and task parallel programming models.'''
|-
! Aspects
! Data Parallel
! Task Parallel
|-
| Decomposition
| Partition data into subsets
| Partition program into subtasks
|-
| Parallel tasks
| Identical
| Unique
|-
| Degree of parallelism
| Scales easily
| Fixed
|-
| Load balancing
| Easier
| Harder
|-
| Communication overhead
| Lower
| Higher
|}

One important feature of data parallel programming model or data parallelism (SIMD) is the single control flow: there is only one control processor that directs the activities of all the processing elements. In stark contrast to this is task parallelism (MIMD: Multiple Instruction, Multiple Data): characterized by its multiple control flows, it allows the concurrent execution of multiple instruction streams, each manipulates its own data and services separate functions. Below is a contrast between the data parallelism and task parallelism models from wikipedia: [http://en.wikipedia.org/wiki/SIMD SIMD] and [http://en.wikipedia.org/wiki/MIMD MIMD]. In the following subsections we continue to compare and contrast different features of data parallel model and task-parallel model to help reader understand the unique characteristics of data parallel programming model.
[[Image:Smid.png|frame|center|425px|contrast between data parallelism and task parallelism]]

== Synchronous vs Asynchronous ==
While the [http://en.wikipedia.org/wiki/Lockstep_(computing) lockstep] imposed by data parallelism on all data streams ensures synchronous computation (all PEs perform their tasks at the exact same pace), every processor in task parallelism performs its task at their own pace, which we call asynchronous computation. Thus, at a certain point of a task parallel program's execution, communication and synchronization primitives are needed to allow different instruction streams to coordinate their efforts, and that is where variable-sharing and message-passing come into play.

== Determinism vs. Non-Determinism ==
Data parallelism's synchronous nature and task parallelism's asynchronism give rise to another pair of features that add to the difference between these two models: determinism versus non-determinism. Data parallelism is deterministic, i.e. computing with the same input will always yield the same result, since its synchronism ensures that issues like relative timing between PEs will not arise. In contrast, task parallelism's asynchronous updates of common data can give rise to non-determinism, i.e, the same input won't always yield the same computation result (the result of a computation will depend also on factors outside the program control, such as scheduling and timing of other PEs). Obviously, non-determinism makes it harder to write and maintain correct programs. This partially explains the advantage of data parallel programming model over data parallelism in terms of development effort (also discussed in section 4.2).

=Appendix C: C for CUDA Example Code=

The following code is a data parallel implementation of the sequential Code 2.3 from [[#References | Solihin (2008)]] using [http://www.nvidia.com/object/cuda_learn.html C for CUDA]. It is presented to give an impression of programming for a SIMD architecture, but a detailed discussion is beyond the scope of this supplement. Ignoring memory allocation issues, the code is very similar to the data parallel example, Code 2.5 from [[#References | Solihin (2008)]], discussed earlier. The main difference is the presence of a control thread that sends the parallel tasks to the CUDA device.

// Data parallel implementation of the example code using C for CUDA.

#include <iostream>

__global__ void kernel(float* a, float* b, float* c, float* local_sum)
{
int id = threadIdx.x;
int local_iter = 4;
int start_iter = id * local_iter;
int end_iter = start_iter + local_iter;

// Begin data parallel section

for (int i = start_iter; i < end_iter; i++)
a[i] = b[i] + c[i];
local_sum[id] = 0;
for (int i = start_iter; i < end_iter; i++)
if (a[i] > 0)
local_sum[id] = local_sum[id] + a[i];

// End data parallel section
}

int main()
{
float h_a[8], h_b[8], h_c[8], h_sum[2];
float *d_a, *d_b, *d_c, *d_sum;
float sum;

size_t size = 8 * sizeof(float);
size_t size2 = 2 * sizeof(float);

cudaMalloc((void**)&d_a, size);
cudaMalloc((void**)&d_b, size);
cudaMalloc((void**)&d_c, size);
cudaMalloc((void**)&d_local_sum, size2);

cudaMemcpy(d_b, h_b, size, cudaMemcpyHostToDevice);
cudaMemcpy(d_c, h_c, size, cudaMemcpyHostToDevice);

kernel<<<1, 2>>>(d_a, d_b, d_c, d_sum);

cudaMemcpy(h_a, d_a, size, cudaMemcpyDeviceToHost);
cudaMemcpy(h_sum, d_sum, size2, cudaMemcpyDeviceToHost);

sum = h_sum[0] + h_sum[1];
std::cout << sum;

cudaFree(d_a);
cudaFree(d_b);
cudaFree(d_c);
cudaFree(d_sum);
}