Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-29T02:53:48Z

Lwillia: /* Example 5 */

==Introduction==

===Problem===
In class, we had some difficulty coming up with good examples of programming by contract. Find some concise ones that illustrate the principle well, and are accessible to a general audience of programmers.

===Programming By Contract===
'''Programming by contract (PBC)''' is also called design by contract. It is a form of progamming that deals with pre conditions, post conditions, and invariants. These are used in a client/supplier model. Pre conditions, post conditons, and invariants are specified first. After that, the code is written based on the specified conditions and invariants. It can be seen as a contract because the code needs to abide by the specifications. These contracts are enforced by assertions.[1] Programming by contract uses assertions to enforce the contract between requirements and code. PBC puts the responsibilities on the client to specify the conditions of the functions and other code to meet while and the supplier to honor these requirements that form a contract. [9]

==Implementation and Reasons For==

===Why Use Programming By Contract?===

* PBC helps to define and show the responsibilities of the client and the server. [9]
* Works very well with Inheritance. Any inherited methods need to conform to the contract. [9]
* Able to use assertions to uphold the contract. [9]
* Tests for pre-conditions as well as post-conditions. [9]
* Handles abmormal cases which goes great with exception handling. [10]

===How it works===

* The client has the responsibility of specifying the post conditions for the supplier.
* The post conditions are used by the supplier to develop code.
* The developed code is then given back to the client with pre-conditions.
* These pre-conditions have to be honored in order for the post conditions to be honored
* This in turn becomes a contract between both sides

''' Previous information came from reference [9]. '''

==Example 1==

This example shows design by contract using a sort function in the Python Progamming language. It defines pre and post conditions for the function and also tests the function to make sure that these conditions are upheld. If any of the pre or post conditions are not upheld, an exception is thrown.

* The "pre:" section defines a precondition. This precondition checks to make sure that the parameter a is an instance of a list. It also checks to see if each element within the list can be compared to all of the other elements within the list. Both of these preconditions need to be met in order for the sort function to work properly.

* The "post:" section defines a postcondition. There are three conditions that are required to be met at the end of the function. First the length of the list must never change during the sorting of the list. Second, no elements should be lost or gained from sorting the list. Lastly the list has to actually be sorted. These three conditions assures the integrity of the list.

* The "pre:" and "post:" together make up the contract of the function.

* The function is then sorted.

* The code after "# enable contract checking" is used to test the function and verify that the contract is upheld. The function is simply imported and ran with an arbitrary list.

* The example below is from link 3.

<pre>
def sort(a):
"""Sort a list *IN PLACE*.

>>> a = [1, 1, 1, 1, 1, 2, 2, 1]
>>> sort(a)
>>> a
[1, 1, 1, 1, 1, 1, 2, 2]
>>> a = 'the quick brown fox jumped over the lazy dog'.split()
>>> sort(a)
>>> a
['brown', 'dog', 'fox', 'jumped', 'lazy', 'over', 'quick', 'the', 'the']

pre:
# must be a list
isinstance(a, list)

# all elements must be comparable with all other items
forall(range(len(a)),
lambda i: forall(range(len(a)),
lambda j: (a[i] < a[j]) ^ (a[i] >= a[j])))

post[a]:
# length of array is unchanged
len(a) == len(__old__.a)

# all elements given are still in the array
forall(__old__.a, lambda e: __old__.a.count(e) == a.count(e))

# the array is sorted
forall([a[i] >= a[i-1] for i in range(1, len(a))])
"""
a.sort()

# enable contract checking
import contract
contract.checkmod(__name__)

def _test():
import doctest, sort
return doctest.testmod(sort)

if __name__ == "__main__":
_test()
</pre>

==Example 2==

This example is an API example that adds a number to a list. The number has to be between 0 and 100. This example shows different ways of designing by contract. There are three functions and each one defines ever a invariant, pre-condition, or a post-condition. Notice that the assert keyword is used for upholding the contract of each condition.

* "def _initparms" is the initialization for the class while "def addNumber(self, number)" adds the number to the list.

* "def _invariant(self):" is an invariant that uses an assertion to verify that the length of the list doesn't exceed 100 and that there is at least one element in the list.

* "def addNumber_pre_condition(self, number):" defines a pre-condition for the addNumber function. The conditions that have to be met are a variable must contain an integer only and the number must be less than 100 and greater than zero.

* "def length_post_condition(self, result):" Is the post condition for the length function. This insures that after the length is found that the list is never bigger than

* The pre-condition for addNumber and the post-condition for length together make up the contract of this class. The contract is enforced through the assertions and invariants.

* The example below is from link 4.

<pre>
class SampleTool(StandardTool):

def _initparms(self):
self.lst = []

def _invariant(self):
assert len(self.lst) < 100

def addNumber(self, number):
self.lst.append(number)

def addNumber_pre_condition(self, number):
assert type(number) == type(1), "Type must be integer"
assert (number < 100) and (number > 0), "Number must be less than 100, but greater than 0"

def length(self):
return len(self.lst)

def length_post_condition(self, result):
assert (result < 100) and (result >= 0), "Result must be less than 100, but greater or equal 0"
</pre>

==Example 3==

Below is a C example of two contracts for functions. Contracts in C begin with "/**" and end with "*/". They are placed directly on top of the function.

The contract below contains two preconditions and one post condition. The first pre-condition make sure that the index is greater than zero. The second makes sure that the index is less than the length of the array. The post-condition simply states that a pointer to the index element within the array passed in is what is returned.

<pre>
/**
pre: index >= 0
pre: index < ary->length
post: return == ary->ptr[index]
*/
void *DArray_get(DArray_T ary, long index)
{
return ary->ptr[index];
}
</pre>

The function below returns a copy of the array that is a parameter. The contract for this function contaisn a post conditions which states that the array returned must not be null. Also, the length of the copy must be equal to the length of the array copied. The last post-condition states that each element in the copied array equals each element in the original array.

<pre>
/**
post: return != NULL implies return->length == ary->length and
forall (long i in 0...ary->length | return->ptr[i] == ary->ptr[i])
*/
DArray_T DArray_copy(DArray_T ary)
{
/* ... */
}
</pre>

==Example 4==

This example is written in Java and is an implementation of a stack. The implementation contains functions to push and pop off on the stack. Also, the size of stack can be determined by the Size function. The remaining function returns how many more objects can be pushed onto the stack. Pre and post conditions are implemented as well as an invariant.

* "preconditions()" defines a prec-onditon for Push and a pre-condition for Pop. The pre-condition for Push is to assure that the size of the stack is less than the maximum capacity of the stack before pushing another element on it. The pre-condition for Pop is that the stack contains at least one element to be popped off.
* "postconditions()" defines one post-condition for push. This post condition simply assures that after placing something on the stack it is greater than zero.
* The invariant asurres that at all times the size of the stack is greater than zero and less than the maximum capacity.
* The contract consists of the preconditions and post-conditions in this example.
* The example is taken from link 7.

<pre>
class Stack
{
public Stack()
{
objects = new Object[MAX];
top = 0;
}
public void Push(Object o)
{
objects[top] = o;
top++;
}
public Object Pop()
{
top--;
return objects[top];
}
public int Size()
{
return top;
}

private int Remaining()
{
assert (false);
return MAX - top;
}

private Object[] objects;
private int top;
private static final int MAX = 10;

preconditions()
{
Push:
top < MAX;
Pop:
top > 0;
}

postconditions()
{
Push:
top > 0;
}

invariants()
{
top >= 0;
top <= MAX;
}
}
</pre>

==References==

# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://www.javaworld.com/javaworld/jw-02-2001/jw-0216-cooltools.html?page=1
# http://www.wayforward.net/pycontract/
# http://pyds.muensterland.org/wiki/programmingbycontractforwebservices.html
# http://www.javaworld.com/javaworld/jw-11-2001/jw-1109-assert.html?page=2
# http://www.codeproject.com/csharp/designbycontract.asp
# http://mozart-dev.sourceforge.net/pi-assert.html
# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://onestepback.org/index.cgi/Tech/Programming/DbcAndTesting.html
# http://archive.eiffel.com/doc/manuals/technology/contract/
# http://www.muc.de/~hoelzl/tools/dbc/dbc.lisp
# http://www.onlamp.com/pub/a/onlamp/2004/10/28/design_by_contract_in_c.html

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-29T02:49:21Z

Lwillia: /* Example 4 */

==Introduction==

===Problem===
In class, we had some difficulty coming up with good examples of programming by contract. Find some concise ones that illustrate the principle well, and are accessible to a general audience of programmers.

===Programming By Contract===
'''Programming by contract (PBC)''' is also called design by contract. It is a form of progamming that deals with pre conditions, post conditions, and invariants. These are used in a client/supplier model. Pre conditions, post conditons, and invariants are specified first. After that, the code is written based on the specified conditions and invariants. It can be seen as a contract because the code needs to abide by the specifications. These contracts are enforced by assertions.[1] Programming by contract uses assertions to enforce the contract between requirements and code. PBC puts the responsibilities on the client to specify the conditions of the functions and other code to meet while and the supplier to honor these requirements that form a contract. [9]

==Implementation and Reasons For==

===Why Use Programming By Contract?===

* PBC helps to define and show the responsibilities of the client and the server. [9]
* Works very well with Inheritance. Any inherited methods need to conform to the contract. [9]
* Able to use assertions to uphold the contract. [9]
* Tests for pre-conditions as well as post-conditions. [9]
* Handles abmormal cases which goes great with exception handling. [10]

===How it works===

* The client has the responsibility of specifying the post conditions for the supplier.
* The post conditions are used by the supplier to develop code.
* The developed code is then given back to the client with pre-conditions.
* These pre-conditions have to be honored in order for the post conditions to be honored
* This in turn becomes a contract between both sides

''' Previous information came from reference [9]. '''

==Example 1==

This example shows design by contract using a sort function in the Python Progamming language. It defines pre and post conditions for the function and also tests the function to make sure that these conditions are upheld. If any of the pre or post conditions are not upheld, an exception is thrown.

* The "pre:" section defines a precondition. This precondition checks to make sure that the parameter a is an instance of a list. It also checks to see if each element within the list can be compared to all of the other elements within the list. Both of these preconditions need to be met in order for the sort function to work properly.

* The "post:" section defines a postcondition. There are three conditions that are required to be met at the end of the function. First the length of the list must never change during the sorting of the list. Second, no elements should be lost or gained from sorting the list. Lastly the list has to actually be sorted. These three conditions assures the integrity of the list.

* The "pre:" and "post:" together make up the contract of the function.

* The function is then sorted.

* The code after "# enable contract checking" is used to test the function and verify that the contract is upheld. The function is simply imported and ran with an arbitrary list.

* The example below is from link 3.

<pre>
def sort(a):
"""Sort a list *IN PLACE*.

>>> a = [1, 1, 1, 1, 1, 2, 2, 1]
>>> sort(a)
>>> a
[1, 1, 1, 1, 1, 1, 2, 2]
>>> a = 'the quick brown fox jumped over the lazy dog'.split()
>>> sort(a)
>>> a
['brown', 'dog', 'fox', 'jumped', 'lazy', 'over', 'quick', 'the', 'the']

pre:
# must be a list
isinstance(a, list)

# all elements must be comparable with all other items
forall(range(len(a)),
lambda i: forall(range(len(a)),
lambda j: (a[i] < a[j]) ^ (a[i] >= a[j])))

post[a]:
# length of array is unchanged
len(a) == len(__old__.a)

# all elements given are still in the array
forall(__old__.a, lambda e: __old__.a.count(e) == a.count(e))

# the array is sorted
forall([a[i] >= a[i-1] for i in range(1, len(a))])
"""
a.sort()

# enable contract checking
import contract
contract.checkmod(__name__)

def _test():
import doctest, sort
return doctest.testmod(sort)

if __name__ == "__main__":
_test()
</pre>

==Example 2==

This example is an API example that adds a number to a list. The number has to be between 0 and 100. This example shows different ways of designing by contract. There are three functions and each one defines ever a invariant, pre-condition, or a post-condition. Notice that the assert keyword is used for upholding the contract of each condition.

* "def _initparms" is the initialization for the class while "def addNumber(self, number)" adds the number to the list.

* "def _invariant(self):" is an invariant that uses an assertion to verify that the length of the list doesn't exceed 100 and that there is at least one element in the list.

* "def addNumber_pre_condition(self, number):" defines a pre-condition for the addNumber function. The conditions that have to be met are a variable must contain an integer only and the number must be less than 100 and greater than zero.

* "def length_post_condition(self, result):" Is the post condition for the length function. This insures that after the length is found that the list is never bigger than

* The pre-condition for addNumber and the post-condition for length together make up the contract of this class. The contract is enforced through the assertions and invariants.

* The example below is from link 4.

<pre>
class SampleTool(StandardTool):

def _initparms(self):
self.lst = []

def _invariant(self):
assert len(self.lst) < 100

def addNumber(self, number):
self.lst.append(number)

def addNumber_pre_condition(self, number):
assert type(number) == type(1), "Type must be integer"
assert (number < 100) and (number > 0), "Number must be less than 100, but greater than 0"

def length(self):
return len(self.lst)

def length_post_condition(self, result):
assert (result < 100) and (result >= 0), "Result must be less than 100, but greater or equal 0"
</pre>

==Example 3==

Below is a C example of two contracts for functions. Contracts in C begin with "/**" and end with "*/". They are placed directly on top of the function.

The contract below contains two preconditions and one post condition. The first pre-condition make sure that the index is greater than zero. The second makes sure that the index is less than the length of the array. The post-condition simply states that a pointer to the index element within the array passed in is what is returned.

<pre>
/**
pre: index >= 0
pre: index < ary->length
post: return == ary->ptr[index]
*/
void *DArray_get(DArray_T ary, long index)
{
return ary->ptr[index];
}
</pre>

The function below returns a copy of the array that is a parameter. The contract for this function contaisn a post conditions which states that the array returned must not be null. Also, the length of the copy must be equal to the length of the array copied. The last post-condition states that each element in the copied array equals each element in the original array.

<pre>
/**
post: return != NULL implies return->length == ary->length and
forall (long i in 0...ary->length | return->ptr[i] == ary->ptr[i])
*/
DArray_T DArray_copy(DArray_T ary)
{
/* ... */
}
</pre>

==Example 4==

This example is written in Java and is an implementation of a stack. The implementation contains functions to push and pop off on the stack. Also, the size of stack can be determined by the Size function. The remaining function returns how many more objects can be pushed onto the stack. Pre and post conditions are implemented as well as an invariant.

* "preconditions()" defines a prec-onditon for Push and a pre-condition for Pop. The pre-condition for Push is to assure that the size of the stack is less than the maximum capacity of the stack before pushing another element on it. The pre-condition for Pop is that the stack contains at least one element to be popped off.
* "postconditions()" defines one post-condition for push. This post condition simply assures that after placing something on the stack it is greater than zero.
* The invariant asurres that at all times the size of the stack is greater than zero and less than the maximum capacity.
* The contract consists of the preconditions and post-conditions in this example.
* The example is taken from link 7.

<pre>
class Stack
{
public Stack()
{
objects = new Object[MAX];
top = 0;
}
public void Push(Object o)
{
objects[top] = o;
top++;
}
public Object Pop()
{
top--;
return objects[top];
}
public int Size()
{
return top;
}

private int Remaining()
{
assert (false);
return MAX - top;
}

private Object[] objects;
private int top;
private static final int MAX = 10;

preconditions()
{
Push:
top < MAX;
Pop:
top > 0;
}

postconditions()
{
Push:
top > 0;
}

invariants()
{
top >= 0;
top <= MAX;
}
}
</pre>

==Example 5==

This example is written in Java. Below is two functions that use assertions to check for null and in range. The example is taken from link 8.
<pre>
/**
* This method asserts that a specified object is not null.
* @param object - the object that should not be null.
* @param name - the name of the object to be used for error reporting.
*/
public final static boolean notNull(Object object, String name) {
assert object != null: name + " must not be null";
return true;
}

/**
* This method asserts that an int value is within a specified range.
* @param value - the value that must be within the specified range.
* @param min - the minimum value specified of the specified range.
* @param max - the maximum value of the specified range.
* @param name - the name of the value to be used for error reporting.
*/
public final static boolean inRange(int value, int min, int max, String name) {
assert value >= min && value <= max: name + " must be in the range [" + min + " to " + max + "]. Value is " + value;
return true;
}
</pre>

==References==

# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://www.javaworld.com/javaworld/jw-02-2001/jw-0216-cooltools.html?page=1
# http://www.wayforward.net/pycontract/
# http://pyds.muensterland.org/wiki/programmingbycontractforwebservices.html
# http://www.javaworld.com/javaworld/jw-11-2001/jw-1109-assert.html?page=2
# http://www.codeproject.com/csharp/designbycontract.asp
# http://mozart-dev.sourceforge.net/pi-assert.html
# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://onestepback.org/index.cgi/Tech/Programming/DbcAndTesting.html
# http://archive.eiffel.com/doc/manuals/technology/contract/
# http://www.muc.de/~hoelzl/tools/dbc/dbc.lisp
# http://www.onlamp.com/pub/a/onlamp/2004/10/28/design_by_contract_in_c.html

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-29T02:49:04Z

Lwillia: /* Example 4 */

==Introduction==

===Problem===
In class, we had some difficulty coming up with good examples of programming by contract. Find some concise ones that illustrate the principle well, and are accessible to a general audience of programmers.

===Programming By Contract===
'''Programming by contract (PBC)''' is also called design by contract. It is a form of progamming that deals with pre conditions, post conditions, and invariants. These are used in a client/supplier model. Pre conditions, post conditons, and invariants are specified first. After that, the code is written based on the specified conditions and invariants. It can be seen as a contract because the code needs to abide by the specifications. These contracts are enforced by assertions.[1] Programming by contract uses assertions to enforce the contract between requirements and code. PBC puts the responsibilities on the client to specify the conditions of the functions and other code to meet while and the supplier to honor these requirements that form a contract. [9]

==Implementation and Reasons For==

===Why Use Programming By Contract?===

* PBC helps to define and show the responsibilities of the client and the server. [9]
* Works very well with Inheritance. Any inherited methods need to conform to the contract. [9]
* Able to use assertions to uphold the contract. [9]
* Tests for pre-conditions as well as post-conditions. [9]
* Handles abmormal cases which goes great with exception handling. [10]

===How it works===

* The client has the responsibility of specifying the post conditions for the supplier.
* The post conditions are used by the supplier to develop code.
* The developed code is then given back to the client with pre-conditions.
* These pre-conditions have to be honored in order for the post conditions to be honored
* This in turn becomes a contract between both sides

''' Previous information came from reference [9]. '''

==Example 1==

This example shows design by contract using a sort function in the Python Progamming language. It defines pre and post conditions for the function and also tests the function to make sure that these conditions are upheld. If any of the pre or post conditions are not upheld, an exception is thrown.

* The "pre:" section defines a precondition. This precondition checks to make sure that the parameter a is an instance of a list. It also checks to see if each element within the list can be compared to all of the other elements within the list. Both of these preconditions need to be met in order for the sort function to work properly.

* The "post:" section defines a postcondition. There are three conditions that are required to be met at the end of the function. First the length of the list must never change during the sorting of the list. Second, no elements should be lost or gained from sorting the list. Lastly the list has to actually be sorted. These three conditions assures the integrity of the list.

* The "pre:" and "post:" together make up the contract of the function.

* The function is then sorted.

* The code after "# enable contract checking" is used to test the function and verify that the contract is upheld. The function is simply imported and ran with an arbitrary list.

* The example below is from link 3.

<pre>
def sort(a):
"""Sort a list *IN PLACE*.

>>> a = [1, 1, 1, 1, 1, 2, 2, 1]
>>> sort(a)
>>> a
[1, 1, 1, 1, 1, 1, 2, 2]
>>> a = 'the quick brown fox jumped over the lazy dog'.split()
>>> sort(a)
>>> a
['brown', 'dog', 'fox', 'jumped', 'lazy', 'over', 'quick', 'the', 'the']

pre:
# must be a list
isinstance(a, list)

# all elements must be comparable with all other items
forall(range(len(a)),
lambda i: forall(range(len(a)),
lambda j: (a[i] < a[j]) ^ (a[i] >= a[j])))

post[a]:
# length of array is unchanged
len(a) == len(__old__.a)

# all elements given are still in the array
forall(__old__.a, lambda e: __old__.a.count(e) == a.count(e))

# the array is sorted
forall([a[i] >= a[i-1] for i in range(1, len(a))])
"""
a.sort()

# enable contract checking
import contract
contract.checkmod(__name__)

def _test():
import doctest, sort
return doctest.testmod(sort)

if __name__ == "__main__":
_test()
</pre>

==Example 2==

This example is an API example that adds a number to a list. The number has to be between 0 and 100. This example shows different ways of designing by contract. There are three functions and each one defines ever a invariant, pre-condition, or a post-condition. Notice that the assert keyword is used for upholding the contract of each condition.

* "def _initparms" is the initialization for the class while "def addNumber(self, number)" adds the number to the list.

* "def _invariant(self):" is an invariant that uses an assertion to verify that the length of the list doesn't exceed 100 and that there is at least one element in the list.

* "def addNumber_pre_condition(self, number):" defines a pre-condition for the addNumber function. The conditions that have to be met are a variable must contain an integer only and the number must be less than 100 and greater than zero.

* "def length_post_condition(self, result):" Is the post condition for the length function. This insures that after the length is found that the list is never bigger than

* The pre-condition for addNumber and the post-condition for length together make up the contract of this class. The contract is enforced through the assertions and invariants.

* The example below is from link 4.

<pre>
class SampleTool(StandardTool):

def _initparms(self):
self.lst = []

def _invariant(self):
assert len(self.lst) < 100

def addNumber(self, number):
self.lst.append(number)

def addNumber_pre_condition(self, number):
assert type(number) == type(1), "Type must be integer"
assert (number < 100) and (number > 0), "Number must be less than 100, but greater than 0"

def length(self):
return len(self.lst)

def length_post_condition(self, result):
assert (result < 100) and (result >= 0), "Result must be less than 100, but greater or equal 0"
</pre>

==Example 3==

Below is a C example of two contracts for functions. Contracts in C begin with "/**" and end with "*/". They are placed directly on top of the function.

The contract below contains two preconditions and one post condition. The first pre-condition make sure that the index is greater than zero. The second makes sure that the index is less than the length of the array. The post-condition simply states that a pointer to the index element within the array passed in is what is returned.

<pre>
/**
pre: index >= 0
pre: index < ary->length
post: return == ary->ptr[index]
*/
void *DArray_get(DArray_T ary, long index)
{
return ary->ptr[index];
}
</pre>

The function below returns a copy of the array that is a parameter. The contract for this function contaisn a post conditions which states that the array returned must not be null. Also, the length of the copy must be equal to the length of the array copied. The last post-condition states that each element in the copied array equals each element in the original array.

<pre>
/**
post: return != NULL implies return->length == ary->length and
forall (long i in 0...ary->length | return->ptr[i] == ary->ptr[i])
*/
DArray_T DArray_copy(DArray_T ary)
{
/* ... */
}
</pre>

==Example 4==

This example is written in Java and is an implementation of a stack. The implementation contains functions to push and pop off on the stack. Also, the size of stack can be determined by the Size function. The remaining function returns how many more objects can be pushed onto the stack. Pre and post conditions are implemented as well as an invariant.

preconditions()
{
Push:
top < MAX;
Pop:
top > 0;
}

postconditions()
{
Push:
top > 0;
}

invariants()
{
top >= 0;
top <= MAX;
}

* "preconditions()" defines a prec-onditon for Push and a pre-condition for Pop. The pre-condition for Push is to assure that the size of the stack is less than the maximum capacity of the stack before pushing another element on it. The pre-condition for Pop is that the stack contains at least one element to be popped off.
* "postconditions()" defines one post-condition for push. This post condition simply assures that after placing something on the stack it is greater than zero.
* The invariant asurres that at all times the size of the stack is greater than zero and less than the maximum capacity.
* The contract consists of the preconditions and post-conditions in this example.
* The example is taken from link 7.

<pre>
class Stack
{
public Stack()
{
objects = new Object[MAX];
top = 0;
}
public void Push(Object o)
{
objects[top] = o;
top++;
}
public Object Pop()
{
top--;
return objects[top];
}
public int Size()
{
return top;
}

private int Remaining()
{
assert (false);
return MAX - top;
}

private Object[] objects;
private int top;
private static final int MAX = 10;

preconditions()
{
Push:
top < MAX;
Pop:
top > 0;
}

postconditions()
{
Push:
top > 0;
}

invariants()
{
top >= 0;
top <= MAX;
}
}
</pre>

==Example 5==

This example is written in Java. Below is two functions that use assertions to check for null and in range. The example is taken from link 8.
<pre>
/**
* This method asserts that a specified object is not null.
* @param object - the object that should not be null.
* @param name - the name of the object to be used for error reporting.
*/
public final static boolean notNull(Object object, String name) {
assert object != null: name + " must not be null";
return true;
}

/**
* This method asserts that an int value is within a specified range.
* @param value - the value that must be within the specified range.
* @param min - the minimum value specified of the specified range.
* @param max - the maximum value of the specified range.
* @param name - the name of the value to be used for error reporting.
*/
public final static boolean inRange(int value, int min, int max, String name) {
assert value >= min && value <= max: name + " must be in the range [" + min + " to " + max + "]. Value is " + value;
return true;
}
</pre>

==References==

# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://www.javaworld.com/javaworld/jw-02-2001/jw-0216-cooltools.html?page=1
# http://www.wayforward.net/pycontract/
# http://pyds.muensterland.org/wiki/programmingbycontractforwebservices.html
# http://www.javaworld.com/javaworld/jw-11-2001/jw-1109-assert.html?page=2
# http://www.codeproject.com/csharp/designbycontract.asp
# http://mozart-dev.sourceforge.net/pi-assert.html
# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://onestepback.org/index.cgi/Tech/Programming/DbcAndTesting.html
# http://archive.eiffel.com/doc/manuals/technology/contract/
# http://www.muc.de/~hoelzl/tools/dbc/dbc.lisp
# http://www.onlamp.com/pub/a/onlamp/2004/10/28/design_by_contract_in_c.html

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-29T02:41:05Z

Lwillia: /* Example 4 */

==Introduction==

===Problem===
In class, we had some difficulty coming up with good examples of programming by contract. Find some concise ones that illustrate the principle well, and are accessible to a general audience of programmers.

===Programming By Contract===
'''Programming by contract (PBC)''' is also called design by contract. It is a form of progamming that deals with pre conditions, post conditions, and invariants. These are used in a client/supplier model. Pre conditions, post conditons, and invariants are specified first. After that, the code is written based on the specified conditions and invariants. It can be seen as a contract because the code needs to abide by the specifications. These contracts are enforced by assertions.[1] Programming by contract uses assertions to enforce the contract between requirements and code. PBC puts the responsibilities on the client to specify the conditions of the functions and other code to meet while and the supplier to honor these requirements that form a contract. [9]

==Implementation and Reasons For==

===Why Use Programming By Contract?===

* PBC helps to define and show the responsibilities of the client and the server. [9]
* Works very well with Inheritance. Any inherited methods need to conform to the contract. [9]
* Able to use assertions to uphold the contract. [9]
* Tests for pre-conditions as well as post-conditions. [9]
* Handles abmormal cases which goes great with exception handling. [10]

===How it works===

* The client has the responsibility of specifying the post conditions for the supplier.
* The post conditions are used by the supplier to develop code.
* The developed code is then given back to the client with pre-conditions.
* These pre-conditions have to be honored in order for the post conditions to be honored
* This in turn becomes a contract between both sides

''' Previous information came from reference [9]. '''

==Example 1==

This example shows design by contract using a sort function in the Python Progamming language. It defines pre and post conditions for the function and also tests the function to make sure that these conditions are upheld. If any of the pre or post conditions are not upheld, an exception is thrown.

* The "pre:" section defines a precondition. This precondition checks to make sure that the parameter a is an instance of a list. It also checks to see if each element within the list can be compared to all of the other elements within the list. Both of these preconditions need to be met in order for the sort function to work properly.

* The "post:" section defines a postcondition. There are three conditions that are required to be met at the end of the function. First the length of the list must never change during the sorting of the list. Second, no elements should be lost or gained from sorting the list. Lastly the list has to actually be sorted. These three conditions assures the integrity of the list.

* The "pre:" and "post:" together make up the contract of the function.

* The function is then sorted.

* The code after "# enable contract checking" is used to test the function and verify that the contract is upheld. The function is simply imported and ran with an arbitrary list.

* The example below is from link 3.

<pre>
def sort(a):
"""Sort a list *IN PLACE*.

>>> a = [1, 1, 1, 1, 1, 2, 2, 1]
>>> sort(a)
>>> a
[1, 1, 1, 1, 1, 1, 2, 2]
>>> a = 'the quick brown fox jumped over the lazy dog'.split()
>>> sort(a)
>>> a
['brown', 'dog', 'fox', 'jumped', 'lazy', 'over', 'quick', 'the', 'the']

pre:
# must be a list
isinstance(a, list)

# all elements must be comparable with all other items
forall(range(len(a)),
lambda i: forall(range(len(a)),
lambda j: (a[i] < a[j]) ^ (a[i] >= a[j])))

post[a]:
# length of array is unchanged
len(a) == len(__old__.a)

# all elements given are still in the array
forall(__old__.a, lambda e: __old__.a.count(e) == a.count(e))

# the array is sorted
forall([a[i] >= a[i-1] for i in range(1, len(a))])
"""
a.sort()

# enable contract checking
import contract
contract.checkmod(__name__)

def _test():
import doctest, sort
return doctest.testmod(sort)

if __name__ == "__main__":
_test()
</pre>

==Example 2==

This example is an API example that adds a number to a list. The number has to be between 0 and 100. This example shows different ways of designing by contract. There are three functions and each one defines ever a invariant, pre-condition, or a post-condition. Notice that the assert keyword is used for upholding the contract of each condition.

* "def _initparms" is the initialization for the class while "def addNumber(self, number)" adds the number to the list.

* "def _invariant(self):" is an invariant that uses an assertion to verify that the length of the list doesn't exceed 100 and that there is at least one element in the list.

* "def addNumber_pre_condition(self, number):" defines a pre-condition for the addNumber function. The conditions that have to be met are a variable must contain an integer only and the number must be less than 100 and greater than zero.

* "def length_post_condition(self, result):" Is the post condition for the length function. This insures that after the length is found that the list is never bigger than

* The pre-condition for addNumber and the post-condition for length together make up the contract of this class. The contract is enforced through the assertions and invariants.

* The example below is from link 4.

<pre>
class SampleTool(StandardTool):

def _initparms(self):
self.lst = []

def _invariant(self):
assert len(self.lst) < 100

def addNumber(self, number):
self.lst.append(number)

def addNumber_pre_condition(self, number):
assert type(number) == type(1), "Type must be integer"
assert (number < 100) and (number > 0), "Number must be less than 100, but greater than 0"

def length(self):
return len(self.lst)

def length_post_condition(self, result):
assert (result < 100) and (result >= 0), "Result must be less than 100, but greater or equal 0"
</pre>

==Example 3==

Below is a C example of two contracts for functions. Contracts in C begin with "/**" and end with "*/". They are placed directly on top of the function.

The contract below contains two preconditions and one post condition. The first pre-condition make sure that the index is greater than zero. The second makes sure that the index is less than the length of the array. The post-condition simply states that a pointer to the index element within the array passed in is what is returned.

<pre>
/**
pre: index >= 0
pre: index < ary->length
post: return == ary->ptr[index]
*/
void *DArray_get(DArray_T ary, long index)
{
return ary->ptr[index];
}
</pre>

The function below returns a copy of the array that is a parameter. The contract for this function contaisn a post conditions which states that the array returned must not be null. Also, the length of the copy must be equal to the length of the array copied. The last post-condition states that each element in the copied array equals each element in the original array.

<pre>
/**
post: return != NULL implies return->length == ary->length and
forall (long i in 0...ary->length | return->ptr[i] == ary->ptr[i])
*/
DArray_T DArray_copy(DArray_T ary)
{
/* ... */
}
</pre>

==Example 4==

This example is written in Java and is an implementation of a stack. The implementation contains functions to push and pop off on the stack. Also, the size of stack can be determined by the Size function. The remaining function returns how many more objects can be pushed onto the stack. Pre and post conditions are implemented as well as an invariant.

*
*
* The example is taken from link 7.

<pre>
class Stack
{
public Stack()
{
objects = new Object[MAX];
top = 0;
}
public void Push(Object o)
{
objects[top] = o;
top++;
}
public Object Pop()
{
top--;
return objects[top];
}
public int Size()
{
return top;
}

private int Remaining()
{
assert (false);
return MAX - top;
}

private Object[] objects;
private int top;
private static final int MAX = 10;

preconditions()
{
Push:
top < MAX;
Pop:
top > 0;
}

postconditions()
{
Push:
top > 0;
}

invariants()
{
top >= 0;
top <= MAX;
}
}
</pre>

==Example 5==

This example is written in Java. Below is two functions that use assertions to check for null and in range. The example is taken from link 8.
<pre>
/**
* This method asserts that a specified object is not null.
* @param object - the object that should not be null.
* @param name - the name of the object to be used for error reporting.
*/
public final static boolean notNull(Object object, String name) {
assert object != null: name + " must not be null";
return true;
}

/**
* This method asserts that an int value is within a specified range.
* @param value - the value that must be within the specified range.
* @param min - the minimum value specified of the specified range.
* @param max - the maximum value of the specified range.
* @param name - the name of the value to be used for error reporting.
*/
public final static boolean inRange(int value, int min, int max, String name) {
assert value >= min && value <= max: name + " must be in the range [" + min + " to " + max + "]. Value is " + value;
return true;
}
</pre>

==References==

# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://www.javaworld.com/javaworld/jw-02-2001/jw-0216-cooltools.html?page=1
# http://www.wayforward.net/pycontract/
# http://pyds.muensterland.org/wiki/programmingbycontractforwebservices.html
# http://www.javaworld.com/javaworld/jw-11-2001/jw-1109-assert.html?page=2
# http://www.codeproject.com/csharp/designbycontract.asp
# http://mozart-dev.sourceforge.net/pi-assert.html
# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://onestepback.org/index.cgi/Tech/Programming/DbcAndTesting.html
# http://archive.eiffel.com/doc/manuals/technology/contract/
# http://www.muc.de/~hoelzl/tools/dbc/dbc.lisp
# http://www.onlamp.com/pub/a/onlamp/2004/10/28/design_by_contract_in_c.html

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-29T02:38:45Z

Lwillia: /* Example 4 */

==Introduction==

===Problem===
In class, we had some difficulty coming up with good examples of programming by contract. Find some concise ones that illustrate the principle well, and are accessible to a general audience of programmers.

===Programming By Contract===
'''Programming by contract (PBC)''' is also called design by contract. It is a form of progamming that deals with pre conditions, post conditions, and invariants. These are used in a client/supplier model. Pre conditions, post conditons, and invariants are specified first. After that, the code is written based on the specified conditions and invariants. It can be seen as a contract because the code needs to abide by the specifications. These contracts are enforced by assertions.[1] Programming by contract uses assertions to enforce the contract between requirements and code. PBC puts the responsibilities on the client to specify the conditions of the functions and other code to meet while and the supplier to honor these requirements that form a contract. [9]

==Implementation and Reasons For==

===Why Use Programming By Contract?===

* PBC helps to define and show the responsibilities of the client and the server. [9]
* Works very well with Inheritance. Any inherited methods need to conform to the contract. [9]
* Able to use assertions to uphold the contract. [9]
* Tests for pre-conditions as well as post-conditions. [9]
* Handles abmormal cases which goes great with exception handling. [10]

===How it works===

* The client has the responsibility of specifying the post conditions for the supplier.
* The post conditions are used by the supplier to develop code.
* The developed code is then given back to the client with pre-conditions.
* These pre-conditions have to be honored in order for the post conditions to be honored
* This in turn becomes a contract between both sides

''' Previous information came from reference [9]. '''

==Example 1==

This example shows design by contract using a sort function in the Python Progamming language. It defines pre and post conditions for the function and also tests the function to make sure that these conditions are upheld. If any of the pre or post conditions are not upheld, an exception is thrown.

* The "pre:" section defines a precondition. This precondition checks to make sure that the parameter a is an instance of a list. It also checks to see if each element within the list can be compared to all of the other elements within the list. Both of these preconditions need to be met in order for the sort function to work properly.

* The "post:" section defines a postcondition. There are three conditions that are required to be met at the end of the function. First the length of the list must never change during the sorting of the list. Second, no elements should be lost or gained from sorting the list. Lastly the list has to actually be sorted. These three conditions assures the integrity of the list.

* The "pre:" and "post:" together make up the contract of the function.

* The function is then sorted.

* The code after "# enable contract checking" is used to test the function and verify that the contract is upheld. The function is simply imported and ran with an arbitrary list.

* The example below is from link 3.

<pre>
def sort(a):
"""Sort a list *IN PLACE*.

>>> a = [1, 1, 1, 1, 1, 2, 2, 1]
>>> sort(a)
>>> a
[1, 1, 1, 1, 1, 1, 2, 2]
>>> a = 'the quick brown fox jumped over the lazy dog'.split()
>>> sort(a)
>>> a
['brown', 'dog', 'fox', 'jumped', 'lazy', 'over', 'quick', 'the', 'the']

pre:
# must be a list
isinstance(a, list)

# all elements must be comparable with all other items
forall(range(len(a)),
lambda i: forall(range(len(a)),
lambda j: (a[i] < a[j]) ^ (a[i] >= a[j])))

post[a]:
# length of array is unchanged
len(a) == len(__old__.a)

# all elements given are still in the array
forall(__old__.a, lambda e: __old__.a.count(e) == a.count(e))

# the array is sorted
forall([a[i] >= a[i-1] for i in range(1, len(a))])
"""
a.sort()

# enable contract checking
import contract
contract.checkmod(__name__)

def _test():
import doctest, sort
return doctest.testmod(sort)

if __name__ == "__main__":
_test()
</pre>

==Example 2==

This example is an API example that adds a number to a list. The number has to be between 0 and 100. This example shows different ways of designing by contract. There are three functions and each one defines ever a invariant, pre-condition, or a post-condition. Notice that the assert keyword is used for upholding the contract of each condition.

* "def _initparms" is the initialization for the class while "def addNumber(self, number)" adds the number to the list.

* "def _invariant(self):" is an invariant that uses an assertion to verify that the length of the list doesn't exceed 100 and that there is at least one element in the list.

* "def addNumber_pre_condition(self, number):" defines a pre-condition for the addNumber function. The conditions that have to be met are a variable must contain an integer only and the number must be less than 100 and greater than zero.

* "def length_post_condition(self, result):" Is the post condition for the length function. This insures that after the length is found that the list is never bigger than

* The pre-condition for addNumber and the post-condition for length together make up the contract of this class. The contract is enforced through the assertions and invariants.

* The example below is from link 4.

<pre>
class SampleTool(StandardTool):

def _initparms(self):
self.lst = []

def _invariant(self):
assert len(self.lst) < 100

def addNumber(self, number):
self.lst.append(number)

def addNumber_pre_condition(self, number):
assert type(number) == type(1), "Type must be integer"
assert (number < 100) and (number > 0), "Number must be less than 100, but greater than 0"

def length(self):
return len(self.lst)

def length_post_condition(self, result):
assert (result < 100) and (result >= 0), "Result must be less than 100, but greater or equal 0"
</pre>

==Example 3==

Below is a C example of two contracts for functions. Contracts in C begin with "/**" and end with "*/". They are placed directly on top of the function.

The contract below contains two preconditions and one post condition. The first pre-condition make sure that the index is greater than zero. The second makes sure that the index is less than the length of the array. The post-condition simply states that a pointer to the index element within the array passed in is what is returned.

<pre>
/**
pre: index >= 0
pre: index < ary->length
post: return == ary->ptr[index]
*/
void *DArray_get(DArray_T ary, long index)
{
return ary->ptr[index];
}
</pre>

The function below returns a copy of the array that is a parameter. The contract for this function contaisn a post conditions which states that the array returned must not be null. Also, the length of the copy must be equal to the length of the array copied. The last post-condition states that each element in the copied array equals each element in the original array.

<pre>
/**
post: return != NULL implies return->length == ary->length and
forall (long i in 0...ary->length | return->ptr[i] == ary->ptr[i])
*/
DArray_T DArray_copy(DArray_T ary)
{
/* ... */
}
</pre>

==Example 4==

This example is written in Java and is an implementation of a stack. The implementation contains functions to push and pop off on the stack. Also, the size of stack can be determined by the Size function. Pre and post conditions are implemented as well as an invariant.

* The example is taken from link 7.

<pre>
class Stack
{
public Stack()
{
objects = new Object[MAX];
top = 0;
}
public void Push(Object o)
{
objects[top] = o;
top++;
}
public Object Pop()
{
top--;
return objects[top];
}
public int Size()
{
return top;
}

private int Remaining()
{
assert (false);
return MAX - top;
}

private Object[] objects;
private int top;
private static final int MAX = 10;

preconditions()
{
Push:
top < MAX;
Pop:
top > 0;
}

postconditions()
{
Push:
top > 0;
}

invariants()
{
top >= 0;
top <= MAX;
}
}
</pre>

==Example 5==

This example is written in Java. Below is two functions that use assertions to check for null and in range. The example is taken from link 8.
<pre>
/**
* This method asserts that a specified object is not null.
* @param object - the object that should not be null.
* @param name - the name of the object to be used for error reporting.
*/
public final static boolean notNull(Object object, String name) {
assert object != null: name + " must not be null";
return true;
}

/**
* This method asserts that an int value is within a specified range.
* @param value - the value that must be within the specified range.
* @param min - the minimum value specified of the specified range.
* @param max - the maximum value of the specified range.
* @param name - the name of the value to be used for error reporting.
*/
public final static boolean inRange(int value, int min, int max, String name) {
assert value >= min && value <= max: name + " must be in the range [" + min + " to " + max + "]. Value is " + value;
return true;
}
</pre>

==References==

# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://www.javaworld.com/javaworld/jw-02-2001/jw-0216-cooltools.html?page=1
# http://www.wayforward.net/pycontract/
# http://pyds.muensterland.org/wiki/programmingbycontractforwebservices.html
# http://www.javaworld.com/javaworld/jw-11-2001/jw-1109-assert.html?page=2
# http://www.codeproject.com/csharp/designbycontract.asp
# http://mozart-dev.sourceforge.net/pi-assert.html
# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://onestepback.org/index.cgi/Tech/Programming/DbcAndTesting.html
# http://archive.eiffel.com/doc/manuals/technology/contract/
# http://www.muc.de/~hoelzl/tools/dbc/dbc.lisp
# http://www.onlamp.com/pub/a/onlamp/2004/10/28/design_by_contract_in_c.html

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-29T02:36:25Z

Lwillia: /* Example 3 */

==Introduction==

===Problem===
In class, we had some difficulty coming up with good examples of programming by contract. Find some concise ones that illustrate the principle well, and are accessible to a general audience of programmers.

===Programming By Contract===
'''Programming by contract (PBC)''' is also called design by contract. It is a form of progamming that deals with pre conditions, post conditions, and invariants. These are used in a client/supplier model. Pre conditions, post conditons, and invariants are specified first. After that, the code is written based on the specified conditions and invariants. It can be seen as a contract because the code needs to abide by the specifications. These contracts are enforced by assertions.[1] Programming by contract uses assertions to enforce the contract between requirements and code. PBC puts the responsibilities on the client to specify the conditions of the functions and other code to meet while and the supplier to honor these requirements that form a contract. [9]

==Implementation and Reasons For==

===Why Use Programming By Contract?===

* PBC helps to define and show the responsibilities of the client and the server. [9]
* Works very well with Inheritance. Any inherited methods need to conform to the contract. [9]
* Able to use assertions to uphold the contract. [9]
* Tests for pre-conditions as well as post-conditions. [9]
* Handles abmormal cases which goes great with exception handling. [10]

===How it works===

* The client has the responsibility of specifying the post conditions for the supplier.
* The post conditions are used by the supplier to develop code.
* The developed code is then given back to the client with pre-conditions.
* These pre-conditions have to be honored in order for the post conditions to be honored
* This in turn becomes a contract between both sides

''' Previous information came from reference [9]. '''

==Example 1==

This example shows design by contract using a sort function in the Python Progamming language. It defines pre and post conditions for the function and also tests the function to make sure that these conditions are upheld. If any of the pre or post conditions are not upheld, an exception is thrown.

* The "pre:" section defines a precondition. This precondition checks to make sure that the parameter a is an instance of a list. It also checks to see if each element within the list can be compared to all of the other elements within the list. Both of these preconditions need to be met in order for the sort function to work properly.

* The "post:" section defines a postcondition. There are three conditions that are required to be met at the end of the function. First the length of the list must never change during the sorting of the list. Second, no elements should be lost or gained from sorting the list. Lastly the list has to actually be sorted. These three conditions assures the integrity of the list.

* The "pre:" and "post:" together make up the contract of the function.

* The function is then sorted.

* The code after "# enable contract checking" is used to test the function and verify that the contract is upheld. The function is simply imported and ran with an arbitrary list.

* The example below is from link 3.

<pre>
def sort(a):
"""Sort a list *IN PLACE*.

>>> a = [1, 1, 1, 1, 1, 2, 2, 1]
>>> sort(a)
>>> a
[1, 1, 1, 1, 1, 1, 2, 2]
>>> a = 'the quick brown fox jumped over the lazy dog'.split()
>>> sort(a)
>>> a
['brown', 'dog', 'fox', 'jumped', 'lazy', 'over', 'quick', 'the', 'the']

pre:
# must be a list
isinstance(a, list)

# all elements must be comparable with all other items
forall(range(len(a)),
lambda i: forall(range(len(a)),
lambda j: (a[i] < a[j]) ^ (a[i] >= a[j])))

post[a]:
# length of array is unchanged
len(a) == len(__old__.a)

# all elements given are still in the array
forall(__old__.a, lambda e: __old__.a.count(e) == a.count(e))

# the array is sorted
forall([a[i] >= a[i-1] for i in range(1, len(a))])
"""
a.sort()

# enable contract checking
import contract
contract.checkmod(__name__)

def _test():
import doctest, sort
return doctest.testmod(sort)

if __name__ == "__main__":
_test()
</pre>

==Example 2==

This example is an API example that adds a number to a list. The number has to be between 0 and 100. This example shows different ways of designing by contract. There are three functions and each one defines ever a invariant, pre-condition, or a post-condition. Notice that the assert keyword is used for upholding the contract of each condition.

* "def _initparms" is the initialization for the class while "def addNumber(self, number)" adds the number to the list.

* "def _invariant(self):" is an invariant that uses an assertion to verify that the length of the list doesn't exceed 100 and that there is at least one element in the list.

* "def addNumber_pre_condition(self, number):" defines a pre-condition for the addNumber function. The conditions that have to be met are a variable must contain an integer only and the number must be less than 100 and greater than zero.

* "def length_post_condition(self, result):" Is the post condition for the length function. This insures that after the length is found that the list is never bigger than

* The pre-condition for addNumber and the post-condition for length together make up the contract of this class. The contract is enforced through the assertions and invariants.

* The example below is from link 4.

<pre>
class SampleTool(StandardTool):

def _initparms(self):
self.lst = []

def _invariant(self):
assert len(self.lst) < 100

def addNumber(self, number):
self.lst.append(number)

def addNumber_pre_condition(self, number):
assert type(number) == type(1), "Type must be integer"
assert (number < 100) and (number > 0), "Number must be less than 100, but greater than 0"

def length(self):
return len(self.lst)

def length_post_condition(self, result):
assert (result < 100) and (result >= 0), "Result must be less than 100, but greater or equal 0"
</pre>

==Example 3==

Below is a C example of two contracts for functions. Contracts in C begin with "/**" and end with "*/". They are placed directly on top of the function.

The contract below contains two preconditions and one post condition. The first pre-condition make sure that the index is greater than zero. The second makes sure that the index is less than the length of the array. The post-condition simply states that a pointer to the index element within the array passed in is what is returned.

<pre>
/**
pre: index >= 0
pre: index < ary->length
post: return == ary->ptr[index]
*/
void *DArray_get(DArray_T ary, long index)
{
return ary->ptr[index];
}
</pre>

The function below returns a copy of the array that is a parameter. The contract for this function contaisn a post conditions which states that the array returned must not be null. Also, the length of the copy must be equal to the length of the array copied. The last post-condition states that each element in the copied array equals each element in the original array.

<pre>
/**
post: return != NULL implies return->length == ary->length and
forall (long i in 0...ary->length | return->ptr[i] == ary->ptr[i])
*/
DArray_T DArray_copy(DArray_T ary)
{
/* ... */
}
</pre>

==Example 4==

This example is written in Java and is an implementation of a stack. Pre and post conditions are implemented as well as an invariant. The example is taken from link 7.
<pre>
class Stack
{
public Stack()
{
objects = new Object[MAX];
top = 0;
}
public void Push(Object o)
{
objects[top] = o;
top++;
}
public Object Pop()
{
top--;
return objects[top];
}
public int Size()
{
return top;
}

private int Remaining()
{
assert (false);
return MAX - top;
}

private Object[] objects;
private int top;
private static final int MAX = 10;

preconditions()
{
Push:
top < MAX;
Pop:
top > 0;
}

postconditions()
{
Push:
top > 0;
}

invariants()
{
top >= 0;
top <= MAX;
}
}
</pre>

==Example 5==

This example is written in Java. Below is two functions that use assertions to check for null and in range. The example is taken from link 8.
<pre>
/**
* This method asserts that a specified object is not null.
* @param object - the object that should not be null.
* @param name - the name of the object to be used for error reporting.
*/
public final static boolean notNull(Object object, String name) {
assert object != null: name + " must not be null";
return true;
}

/**
* This method asserts that an int value is within a specified range.
* @param value - the value that must be within the specified range.
* @param min - the minimum value specified of the specified range.
* @param max - the maximum value of the specified range.
* @param name - the name of the value to be used for error reporting.
*/
public final static boolean inRange(int value, int min, int max, String name) {
assert value >= min && value <= max: name + " must be in the range [" + min + " to " + max + "]. Value is " + value;
return true;
}
</pre>

==References==

# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://www.javaworld.com/javaworld/jw-02-2001/jw-0216-cooltools.html?page=1
# http://www.wayforward.net/pycontract/
# http://pyds.muensterland.org/wiki/programmingbycontractforwebservices.html
# http://www.javaworld.com/javaworld/jw-11-2001/jw-1109-assert.html?page=2
# http://www.codeproject.com/csharp/designbycontract.asp
# http://mozart-dev.sourceforge.net/pi-assert.html
# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://onestepback.org/index.cgi/Tech/Programming/DbcAndTesting.html
# http://archive.eiffel.com/doc/manuals/technology/contract/
# http://www.muc.de/~hoelzl/tools/dbc/dbc.lisp
# http://www.onlamp.com/pub/a/onlamp/2004/10/28/design_by_contract_in_c.html

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-29T02:27:31Z

Lwillia: /* Example 3 */

==Introduction==

===Problem===
In class, we had some difficulty coming up with good examples of programming by contract. Find some concise ones that illustrate the principle well, and are accessible to a general audience of programmers.

===Programming By Contract===
'''Programming by contract (PBC)''' is also called design by contract. It is a form of progamming that deals with pre conditions, post conditions, and invariants. These are used in a client/supplier model. Pre conditions, post conditons, and invariants are specified first. After that, the code is written based on the specified conditions and invariants. It can be seen as a contract because the code needs to abide by the specifications. These contracts are enforced by assertions.[1] Programming by contract uses assertions to enforce the contract between requirements and code. PBC puts the responsibilities on the client to specify the conditions of the functions and other code to meet while and the supplier to honor these requirements that form a contract. [9]

==Implementation and Reasons For==

===Why Use Programming By Contract?===

* PBC helps to define and show the responsibilities of the client and the server. [9]
* Works very well with Inheritance. Any inherited methods need to conform to the contract. [9]
* Able to use assertions to uphold the contract. [9]
* Tests for pre-conditions as well as post-conditions. [9]
* Handles abmormal cases which goes great with exception handling. [10]

===How it works===

* The client has the responsibility of specifying the post conditions for the supplier.
* The post conditions are used by the supplier to develop code.
* The developed code is then given back to the client with pre-conditions.
* These pre-conditions have to be honored in order for the post conditions to be honored
* This in turn becomes a contract between both sides

''' Previous information came from reference [9]. '''

==Example 1==

This example shows design by contract using a sort function in the Python Progamming language. It defines pre and post conditions for the function and also tests the function to make sure that these conditions are upheld. If any of the pre or post conditions are not upheld, an exception is thrown.

* The "pre:" section defines a precondition. This precondition checks to make sure that the parameter a is an instance of a list. It also checks to see if each element within the list can be compared to all of the other elements within the list. Both of these preconditions need to be met in order for the sort function to work properly.

* The "post:" section defines a postcondition. There are three conditions that are required to be met at the end of the function. First the length of the list must never change during the sorting of the list. Second, no elements should be lost or gained from sorting the list. Lastly the list has to actually be sorted. These three conditions assures the integrity of the list.

* The "pre:" and "post:" together make up the contract of the function.

* The function is then sorted.

* The code after "# enable contract checking" is used to test the function and verify that the contract is upheld. The function is simply imported and ran with an arbitrary list.

* The example below is from link 3.

<pre>
def sort(a):
"""Sort a list *IN PLACE*.

>>> a = [1, 1, 1, 1, 1, 2, 2, 1]
>>> sort(a)
>>> a
[1, 1, 1, 1, 1, 1, 2, 2]
>>> a = 'the quick brown fox jumped over the lazy dog'.split()
>>> sort(a)
>>> a
['brown', 'dog', 'fox', 'jumped', 'lazy', 'over', 'quick', 'the', 'the']

pre:
# must be a list
isinstance(a, list)

# all elements must be comparable with all other items
forall(range(len(a)),
lambda i: forall(range(len(a)),
lambda j: (a[i] < a[j]) ^ (a[i] >= a[j])))

post[a]:
# length of array is unchanged
len(a) == len(__old__.a)

# all elements given are still in the array
forall(__old__.a, lambda e: __old__.a.count(e) == a.count(e))

# the array is sorted
forall([a[i] >= a[i-1] for i in range(1, len(a))])
"""
a.sort()

# enable contract checking
import contract
contract.checkmod(__name__)

def _test():
import doctest, sort
return doctest.testmod(sort)

if __name__ == "__main__":
_test()
</pre>

==Example 2==

This example is an API example that adds a number to a list. The number has to be between 0 and 100. This example shows different ways of designing by contract. There are three functions and each one defines ever a invariant, pre-condition, or a post-condition. Notice that the assert keyword is used for upholding the contract of each condition.

* "def _initparms" is the initialization for the class while "def addNumber(self, number)" adds the number to the list.

* "def _invariant(self):" is an invariant that uses an assertion to verify that the length of the list doesn't exceed 100 and that there is at least one element in the list.

* "def addNumber_pre_condition(self, number):" defines a pre-condition for the addNumber function. The conditions that have to be met are a variable must contain an integer only and the number must be less than 100 and greater than zero.

* "def length_post_condition(self, result):" Is the post condition for the length function. This insures that after the length is found that the list is never bigger than

* The pre-condition for addNumber and the post-condition for length together make up the contract of this class. The contract is enforced through the assertions and invariants.

* The example below is from link 4.

<pre>
class SampleTool(StandardTool):

def _initparms(self):
self.lst = []

def _invariant(self):
assert len(self.lst) < 100

def addNumber(self, number):
self.lst.append(number)

def addNumber_pre_condition(self, number):
assert type(number) == type(1), "Type must be integer"
assert (number < 100) and (number > 0), "Number must be less than 100, but greater than 0"

def length(self):
return len(self.lst)

def length_post_condition(self, result):
assert (result < 100) and (result >= 0), "Result must be less than 100, but greater or equal 0"
</pre>

==Example 3==

Below is a C example of two contracts for functions. Contracts in c begin with "/**" and end with "*/". They are placed directly on top of the function.

<pre>
/**
pre: index >= 0
pre: index < ary->length
post: return == ary->ptr[index]
*/
void *DArray_get(DArray_T ary, long index)
{
return ary->ptr[index];
}
</pre>

<pre>
/**
post: return != NULL implies return->length == ary->length and
forall (long i in 0...ary->length | return->ptr[i] == ary->ptr[i])
*/
DArray_T DArray_copy(DArray_T ary)
{
/* ... */
}
</pre>

==Example 4==

This example is written in Java and is an implementation of a stack. Pre and post conditions are implemented as well as an invariant. The example is taken from link 7.
<pre>
class Stack
{
public Stack()
{
objects = new Object[MAX];
top = 0;
}
public void Push(Object o)
{
objects[top] = o;
top++;
}
public Object Pop()
{
top--;
return objects[top];
}
public int Size()
{
return top;
}

private int Remaining()
{
assert (false);
return MAX - top;
}

private Object[] objects;
private int top;
private static final int MAX = 10;

preconditions()
{
Push:
top < MAX;
Pop:
top > 0;
}

postconditions()
{
Push:
top > 0;
}

invariants()
{
top >= 0;
top <= MAX;
}
}
</pre>

==Example 5==

This example is written in Java. Below is two functions that use assertions to check for null and in range. The example is taken from link 8.
<pre>
/**
* This method asserts that a specified object is not null.
* @param object - the object that should not be null.
* @param name - the name of the object to be used for error reporting.
*/
public final static boolean notNull(Object object, String name) {
assert object != null: name + " must not be null";
return true;
}

/**
* This method asserts that an int value is within a specified range.
* @param value - the value that must be within the specified range.
* @param min - the minimum value specified of the specified range.
* @param max - the maximum value of the specified range.
* @param name - the name of the value to be used for error reporting.
*/
public final static boolean inRange(int value, int min, int max, String name) {
assert value >= min && value <= max: name + " must be in the range [" + min + " to " + max + "]. Value is " + value;
return true;
}
</pre>

==References==

# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://www.javaworld.com/javaworld/jw-02-2001/jw-0216-cooltools.html?page=1
# http://www.wayforward.net/pycontract/
# http://pyds.muensterland.org/wiki/programmingbycontractforwebservices.html
# http://www.javaworld.com/javaworld/jw-11-2001/jw-1109-assert.html?page=2
# http://www.codeproject.com/csharp/designbycontract.asp
# http://mozart-dev.sourceforge.net/pi-assert.html
# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://onestepback.org/index.cgi/Tech/Programming/DbcAndTesting.html
# http://archive.eiffel.com/doc/manuals/technology/contract/
# http://www.muc.de/~hoelzl/tools/dbc/dbc.lisp
# http://www.onlamp.com/pub/a/onlamp/2004/10/28/design_by_contract_in_c.html

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-29T02:25:37Z

Lwillia: /* References */

==Introduction==

===Problem===
In class, we had some difficulty coming up with good examples of programming by contract. Find some concise ones that illustrate the principle well, and are accessible to a general audience of programmers.

===Programming By Contract===
'''Programming by contract (PBC)''' is also called design by contract. It is a form of progamming that deals with pre conditions, post conditions, and invariants. These are used in a client/supplier model. Pre conditions, post conditons, and invariants are specified first. After that, the code is written based on the specified conditions and invariants. It can be seen as a contract because the code needs to abide by the specifications. These contracts are enforced by assertions.[1] Programming by contract uses assertions to enforce the contract between requirements and code. PBC puts the responsibilities on the client to specify the conditions of the functions and other code to meet while and the supplier to honor these requirements that form a contract. [9]

==Implementation and Reasons For==

===Why Use Programming By Contract?===

* PBC helps to define and show the responsibilities of the client and the server. [9]
* Works very well with Inheritance. Any inherited methods need to conform to the contract. [9]
* Able to use assertions to uphold the contract. [9]
* Tests for pre-conditions as well as post-conditions. [9]
* Handles abmormal cases which goes great with exception handling. [10]

===How it works===

* The client has the responsibility of specifying the post conditions for the supplier.
* The post conditions are used by the supplier to develop code.
* The developed code is then given back to the client with pre-conditions.
* These pre-conditions have to be honored in order for the post conditions to be honored
* This in turn becomes a contract between both sides

''' Previous information came from reference [9]. '''

==Example 1==

This example shows design by contract using a sort function in the Python Progamming language. It defines pre and post conditions for the function and also tests the function to make sure that these conditions are upheld. If any of the pre or post conditions are not upheld, an exception is thrown.

* The "pre:" section defines a precondition. This precondition checks to make sure that the parameter a is an instance of a list. It also checks to see if each element within the list can be compared to all of the other elements within the list. Both of these preconditions need to be met in order for the sort function to work properly.

* The "post:" section defines a postcondition. There are three conditions that are required to be met at the end of the function. First the length of the list must never change during the sorting of the list. Second, no elements should be lost or gained from sorting the list. Lastly the list has to actually be sorted. These three conditions assures the integrity of the list.

* The "pre:" and "post:" together make up the contract of the function.

* The function is then sorted.

* The code after "# enable contract checking" is used to test the function and verify that the contract is upheld. The function is simply imported and ran with an arbitrary list.

* The example below is from link 3.

<pre>
def sort(a):
"""Sort a list *IN PLACE*.

>>> a = [1, 1, 1, 1, 1, 2, 2, 1]
>>> sort(a)
>>> a
[1, 1, 1, 1, 1, 1, 2, 2]
>>> a = 'the quick brown fox jumped over the lazy dog'.split()
>>> sort(a)
>>> a
['brown', 'dog', 'fox', 'jumped', 'lazy', 'over', 'quick', 'the', 'the']

pre:
# must be a list
isinstance(a, list)

# all elements must be comparable with all other items
forall(range(len(a)),
lambda i: forall(range(len(a)),
lambda j: (a[i] < a[j]) ^ (a[i] >= a[j])))

post[a]:
# length of array is unchanged
len(a) == len(__old__.a)

# all elements given are still in the array
forall(__old__.a, lambda e: __old__.a.count(e) == a.count(e))

# the array is sorted
forall([a[i] >= a[i-1] for i in range(1, len(a))])
"""
a.sort()

# enable contract checking
import contract
contract.checkmod(__name__)

def _test():
import doctest, sort
return doctest.testmod(sort)

if __name__ == "__main__":
_test()
</pre>

==Example 2==

This example is an API example that adds a number to a list. The number has to be between 0 and 100. This example shows different ways of designing by contract. There are three functions and each one defines ever a invariant, pre-condition, or a post-condition. Notice that the assert keyword is used for upholding the contract of each condition.

* "def _initparms" is the initialization for the class while "def addNumber(self, number)" adds the number to the list.

* "def _invariant(self):" is an invariant that uses an assertion to verify that the length of the list doesn't exceed 100 and that there is at least one element in the list.

* "def addNumber_pre_condition(self, number):" defines a pre-condition for the addNumber function. The conditions that have to be met are a variable must contain an integer only and the number must be less than 100 and greater than zero.

* "def length_post_condition(self, result):" Is the post condition for the length function. This insures that after the length is found that the list is never bigger than

* The pre-condition for addNumber and the post-condition for length together make up the contract of this class. The contract is enforced through the assertions and invariants.

* The example below is from link 4.

<pre>
class SampleTool(StandardTool):

def _initparms(self):
self.lst = []

def _invariant(self):
assert len(self.lst) < 100

def addNumber(self, number):
self.lst.append(number)

def addNumber_pre_condition(self, number):
assert type(number) == type(1), "Type must be integer"
assert (number < 100) and (number > 0), "Number must be less than 100, but greater than 0"

def length(self):
return len(self.lst)

def length_post_condition(self, result):
assert (result < 100) and (result >= 0), "Result must be less than 100, but greater or equal 0"
</pre>

==Example 3==

This is a C++ example of a bar class. The class takes a value but assures that the value is greater than zero. This example is from link 5.
<pre>
public class Bar
{
public void m1( int value )
{
assert 0 <= value : "Value must be non-negative: value= " + value;
System.out.println( "OK" );
}
public static void main( String[] args )
{
Bar bar = new Bar();
System.out.print( "bar.m1( 1 ): " );
bar.m1( 1 );
System.out.print( "bar.m1( -1 ): " );
bar.m1( -1 );
}
}
</pre>

==Example 4==

This example is written in Java and is an implementation of a stack. Pre and post conditions are implemented as well as an invariant. The example is taken from link 7.
<pre>
class Stack
{
public Stack()
{
objects = new Object[MAX];
top = 0;
}
public void Push(Object o)
{
objects[top] = o;
top++;
}
public Object Pop()
{
top--;
return objects[top];
}
public int Size()
{
return top;
}

private int Remaining()
{
assert (false);
return MAX - top;
}

private Object[] objects;
private int top;
private static final int MAX = 10;

preconditions()
{
Push:
top < MAX;
Pop:
top > 0;
}

postconditions()
{
Push:
top > 0;
}

invariants()
{
top >= 0;
top <= MAX;
}
}
</pre>

==Example 5==

This example is written in Java. Below is two functions that use assertions to check for null and in range. The example is taken from link 8.
<pre>
/**
* This method asserts that a specified object is not null.
* @param object - the object that should not be null.
* @param name - the name of the object to be used for error reporting.
*/
public final static boolean notNull(Object object, String name) {
assert object != null: name + " must not be null";
return true;
}

/**
* This method asserts that an int value is within a specified range.
* @param value - the value that must be within the specified range.
* @param min - the minimum value specified of the specified range.
* @param max - the maximum value of the specified range.
* @param name - the name of the value to be used for error reporting.
*/
public final static boolean inRange(int value, int min, int max, String name) {
assert value >= min && value <= max: name + " must be in the range [" + min + " to " + max + "]. Value is " + value;
return true;
}
</pre>

==References==

# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://www.javaworld.com/javaworld/jw-02-2001/jw-0216-cooltools.html?page=1
# http://www.wayforward.net/pycontract/
# http://pyds.muensterland.org/wiki/programmingbycontractforwebservices.html
# http://www.javaworld.com/javaworld/jw-11-2001/jw-1109-assert.html?page=2
# http://www.codeproject.com/csharp/designbycontract.asp
# http://mozart-dev.sourceforge.net/pi-assert.html
# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://onestepback.org/index.cgi/Tech/Programming/DbcAndTesting.html
# http://archive.eiffel.com/doc/manuals/technology/contract/
# http://www.muc.de/~hoelzl/tools/dbc/dbc.lisp
# http://www.onlamp.com/pub/a/onlamp/2004/10/28/design_by_contract_in_c.html

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-29T02:22:38Z

Lwillia: /* Example 2 */

==Introduction==

===Problem===
In class, we had some difficulty coming up with good examples of programming by contract. Find some concise ones that illustrate the principle well, and are accessible to a general audience of programmers.

===Programming By Contract===
'''Programming by contract (PBC)''' is also called design by contract. It is a form of progamming that deals with pre conditions, post conditions, and invariants. These are used in a client/supplier model. Pre conditions, post conditons, and invariants are specified first. After that, the code is written based on the specified conditions and invariants. It can be seen as a contract because the code needs to abide by the specifications. These contracts are enforced by assertions.[1] Programming by contract uses assertions to enforce the contract between requirements and code. PBC puts the responsibilities on the client to specify the conditions of the functions and other code to meet while and the supplier to honor these requirements that form a contract. [9]

==Implementation and Reasons For==

===Why Use Programming By Contract?===

* PBC helps to define and show the responsibilities of the client and the server. [9]
* Works very well with Inheritance. Any inherited methods need to conform to the contract. [9]
* Able to use assertions to uphold the contract. [9]
* Tests for pre-conditions as well as post-conditions. [9]
* Handles abmormal cases which goes great with exception handling. [10]

===How it works===

* The client has the responsibility of specifying the post conditions for the supplier.
* The post conditions are used by the supplier to develop code.
* The developed code is then given back to the client with pre-conditions.
* These pre-conditions have to be honored in order for the post conditions to be honored
* This in turn becomes a contract between both sides

''' Previous information came from reference [9]. '''

==Example 1==

This example shows design by contract using a sort function in the Python Progamming language. It defines pre and post conditions for the function and also tests the function to make sure that these conditions are upheld. If any of the pre or post conditions are not upheld, an exception is thrown.

* The "pre:" section defines a precondition. This precondition checks to make sure that the parameter a is an instance of a list. It also checks to see if each element within the list can be compared to all of the other elements within the list. Both of these preconditions need to be met in order for the sort function to work properly.

* The "post:" section defines a postcondition. There are three conditions that are required to be met at the end of the function. First the length of the list must never change during the sorting of the list. Second, no elements should be lost or gained from sorting the list. Lastly the list has to actually be sorted. These three conditions assures the integrity of the list.

* The "pre:" and "post:" together make up the contract of the function.

* The function is then sorted.

* The code after "# enable contract checking" is used to test the function and verify that the contract is upheld. The function is simply imported and ran with an arbitrary list.

* The example below is from link 3.

<pre>
def sort(a):
"""Sort a list *IN PLACE*.

>>> a = [1, 1, 1, 1, 1, 2, 2, 1]
>>> sort(a)
>>> a
[1, 1, 1, 1, 1, 1, 2, 2]
>>> a = 'the quick brown fox jumped over the lazy dog'.split()
>>> sort(a)
>>> a
['brown', 'dog', 'fox', 'jumped', 'lazy', 'over', 'quick', 'the', 'the']

pre:
# must be a list
isinstance(a, list)

# all elements must be comparable with all other items
forall(range(len(a)),
lambda i: forall(range(len(a)),
lambda j: (a[i] < a[j]) ^ (a[i] >= a[j])))

post[a]:
# length of array is unchanged
len(a) == len(__old__.a)

# all elements given are still in the array
forall(__old__.a, lambda e: __old__.a.count(e) == a.count(e))

# the array is sorted
forall([a[i] >= a[i-1] for i in range(1, len(a))])
"""
a.sort()

# enable contract checking
import contract
contract.checkmod(__name__)

def _test():
import doctest, sort
return doctest.testmod(sort)

if __name__ == "__main__":
_test()
</pre>

==Example 2==

This example is an API example that adds a number to a list. The number has to be between 0 and 100. This example shows different ways of designing by contract. There are three functions and each one defines ever a invariant, pre-condition, or a post-condition. Notice that the assert keyword is used for upholding the contract of each condition.

* "def _initparms" is the initialization for the class while "def addNumber(self, number)" adds the number to the list.

* "def _invariant(self):" is an invariant that uses an assertion to verify that the length of the list doesn't exceed 100 and that there is at least one element in the list.

* "def addNumber_pre_condition(self, number):" defines a pre-condition for the addNumber function. The conditions that have to be met are a variable must contain an integer only and the number must be less than 100 and greater than zero.

* "def length_post_condition(self, result):" Is the post condition for the length function. This insures that after the length is found that the list is never bigger than

* The pre-condition for addNumber and the post-condition for length together make up the contract of this class. The contract is enforced through the assertions and invariants.

* The example below is from link 4.

<pre>
class SampleTool(StandardTool):

def _initparms(self):
self.lst = []

def _invariant(self):
assert len(self.lst) < 100

def addNumber(self, number):
self.lst.append(number)

def addNumber_pre_condition(self, number):
assert type(number) == type(1), "Type must be integer"
assert (number < 100) and (number > 0), "Number must be less than 100, but greater than 0"

def length(self):
return len(self.lst)

def length_post_condition(self, result):
assert (result < 100) and (result >= 0), "Result must be less than 100, but greater or equal 0"
</pre>

==Example 3==

This is a C++ example of a bar class. The class takes a value but assures that the value is greater than zero. This example is from link 5.
<pre>
public class Bar
{
public void m1( int value )
{
assert 0 <= value : "Value must be non-negative: value= " + value;
System.out.println( "OK" );
}
public static void main( String[] args )
{
Bar bar = new Bar();
System.out.print( "bar.m1( 1 ): " );
bar.m1( 1 );
System.out.print( "bar.m1( -1 ): " );
bar.m1( -1 );
}
}
</pre>

==Example 4==

This example is written in Java and is an implementation of a stack. Pre and post conditions are implemented as well as an invariant. The example is taken from link 7.
<pre>
class Stack
{
public Stack()
{
objects = new Object[MAX];
top = 0;
}
public void Push(Object o)
{
objects[top] = o;
top++;
}
public Object Pop()
{
top--;
return objects[top];
}
public int Size()
{
return top;
}

private int Remaining()
{
assert (false);
return MAX - top;
}

private Object[] objects;
private int top;
private static final int MAX = 10;

preconditions()
{
Push:
top < MAX;
Pop:
top > 0;
}

postconditions()
{
Push:
top > 0;
}

invariants()
{
top >= 0;
top <= MAX;
}
}
</pre>

==Example 5==

This example is written in Java. Below is two functions that use assertions to check for null and in range. The example is taken from link 8.
<pre>
/**
* This method asserts that a specified object is not null.
* @param object - the object that should not be null.
* @param name - the name of the object to be used for error reporting.
*/
public final static boolean notNull(Object object, String name) {
assert object != null: name + " must not be null";
return true;
}

/**
* This method asserts that an int value is within a specified range.
* @param value - the value that must be within the specified range.
* @param min - the minimum value specified of the specified range.
* @param max - the maximum value of the specified range.
* @param name - the name of the value to be used for error reporting.
*/
public final static boolean inRange(int value, int min, int max, String name) {
assert value >= min && value <= max: name + " must be in the range [" + min + " to " + max + "]. Value is " + value;
return true;
}
</pre>

==References==

# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://www.javaworld.com/javaworld/jw-02-2001/jw-0216-cooltools.html?page=1
# http://www.wayforward.net/pycontract/
# http://pyds.muensterland.org/wiki/programmingbycontractforwebservices.html
# http://www.javaworld.com/javaworld/jw-11-2001/jw-1109-assert.html?page=2
# http://www.codeproject.com/csharp/designbycontract.asp
# http://mozart-dev.sourceforge.net/pi-assert.html
# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://onestepback.org/index.cgi/Tech/Programming/DbcAndTesting.html
# http://archive.eiffel.com/doc/manuals/technology/contract/
# http://www.muc.de/~hoelzl/tools/dbc/dbc.lisp

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-29T02:21:29Z

Lwillia: /* Example 2 */

==Introduction==

===Problem===
In class, we had some difficulty coming up with good examples of programming by contract. Find some concise ones that illustrate the principle well, and are accessible to a general audience of programmers.

===Programming By Contract===
'''Programming by contract (PBC)''' is also called design by contract. It is a form of progamming that deals with pre conditions, post conditions, and invariants. These are used in a client/supplier model. Pre conditions, post conditons, and invariants are specified first. After that, the code is written based on the specified conditions and invariants. It can be seen as a contract because the code needs to abide by the specifications. These contracts are enforced by assertions.[1] Programming by contract uses assertions to enforce the contract between requirements and code. PBC puts the responsibilities on the client to specify the conditions of the functions and other code to meet while and the supplier to honor these requirements that form a contract. [9]

==Implementation and Reasons For==

===Why Use Programming By Contract?===

* PBC helps to define and show the responsibilities of the client and the server. [9]
* Works very well with Inheritance. Any inherited methods need to conform to the contract. [9]
* Able to use assertions to uphold the contract. [9]
* Tests for pre-conditions as well as post-conditions. [9]
* Handles abmormal cases which goes great with exception handling. [10]

===How it works===

* The client has the responsibility of specifying the post conditions for the supplier.
* The post conditions are used by the supplier to develop code.
* The developed code is then given back to the client with pre-conditions.
* These pre-conditions have to be honored in order for the post conditions to be honored
* This in turn becomes a contract between both sides

''' Previous information came from reference [9]. '''

==Example 1==

This example shows design by contract using a sort function in the Python Progamming language. It defines pre and post conditions for the function and also tests the function to make sure that these conditions are upheld. If any of the pre or post conditions are not upheld, an exception is thrown.

* The "pre:" section defines a precondition. This precondition checks to make sure that the parameter a is an instance of a list. It also checks to see if each element within the list can be compared to all of the other elements within the list. Both of these preconditions need to be met in order for the sort function to work properly.

* The "post:" section defines a postcondition. There are three conditions that are required to be met at the end of the function. First the length of the list must never change during the sorting of the list. Second, no elements should be lost or gained from sorting the list. Lastly the list has to actually be sorted. These three conditions assures the integrity of the list.

* The "pre:" and "post:" together make up the contract of the function.

* The function is then sorted.

* The code after "# enable contract checking" is used to test the function and verify that the contract is upheld. The function is simply imported and ran with an arbitrary list.

* The example below is from link 3.

<pre>
def sort(a):
"""Sort a list *IN PLACE*.

>>> a = [1, 1, 1, 1, 1, 2, 2, 1]
>>> sort(a)
>>> a
[1, 1, 1, 1, 1, 1, 2, 2]
>>> a = 'the quick brown fox jumped over the lazy dog'.split()
>>> sort(a)
>>> a
['brown', 'dog', 'fox', 'jumped', 'lazy', 'over', 'quick', 'the', 'the']

pre:
# must be a list
isinstance(a, list)

# all elements must be comparable with all other items
forall(range(len(a)),
lambda i: forall(range(len(a)),
lambda j: (a[i] < a[j]) ^ (a[i] >= a[j])))

post[a]:
# length of array is unchanged
len(a) == len(__old__.a)

# all elements given are still in the array
forall(__old__.a, lambda e: __old__.a.count(e) == a.count(e))

# the array is sorted
forall([a[i] >= a[i-1] for i in range(1, len(a))])
"""
a.sort()

# enable contract checking
import contract
contract.checkmod(__name__)

def _test():
import doctest, sort
return doctest.testmod(sort)

if __name__ == "__main__":
_test()
</pre>

==Example 2==

This example is an API example that adds a number to a list. The number has to be between 0 and 100. This example shows different ways of designing by contract. There are three functions and each one defines ever a invariant, pre-condition, or a post-condition. Notice that the assert keyword is used for upholding the contract of each condition.

* "def _initparms" is the initialization for the class while "def addNumber(self, number)" adds the number to the list.

* "def _invariant(self):" is an invariant that uses an assertion to verify that the length of the list doesn't exceed 100 and that there is at least one element in the list.

* "def addNumber_pre_condition(self, number):" defines a pre-condition for the addNumber function. The conditions that have to be met are a variable must contain an integer only and the number must be less than 100 and greater than zero.

* "def length_post_condition(self, result):" Is the post condition for the length function. This insures that after the length is found that the list is never bigger than

* The example below is from link 4.

<pre>
class SampleTool(StandardTool):

def _initparms(self):
self.lst = []

def _invariant(self):
assert len(self.lst) < 100

def addNumber(self, number):
self.lst.append(number)

def addNumber_pre_condition(self, number):
assert type(number) == type(1), "Type must be integer"
assert (number < 100) and (number > 0), "Number must be less than 100, but greater than 0"

def length(self):
return len(self.lst)

def length_post_condition(self, result):
assert (result < 100) and (result >= 0), "Result must be less than 100, but greater or equal 0"
</pre>

==Example 3==

This is a C++ example of a bar class. The class takes a value but assures that the value is greater than zero. This example is from link 5.
<pre>
public class Bar
{
public void m1( int value )
{
assert 0 <= value : "Value must be non-negative: value= " + value;
System.out.println( "OK" );
}
public static void main( String[] args )
{
Bar bar = new Bar();
System.out.print( "bar.m1( 1 ): " );
bar.m1( 1 );
System.out.print( "bar.m1( -1 ): " );
bar.m1( -1 );
}
}
</pre>

==Example 4==

This example is written in Java and is an implementation of a stack. Pre and post conditions are implemented as well as an invariant. The example is taken from link 7.
<pre>
class Stack
{
public Stack()
{
objects = new Object[MAX];
top = 0;
}
public void Push(Object o)
{
objects[top] = o;
top++;
}
public Object Pop()
{
top--;
return objects[top];
}
public int Size()
{
return top;
}

private int Remaining()
{
assert (false);
return MAX - top;
}

private Object[] objects;
private int top;
private static final int MAX = 10;

preconditions()
{
Push:
top < MAX;
Pop:
top > 0;
}

postconditions()
{
Push:
top > 0;
}

invariants()
{
top >= 0;
top <= MAX;
}
}
</pre>

==Example 5==

This example is written in Java. Below is two functions that use assertions to check for null and in range. The example is taken from link 8.
<pre>
/**
* This method asserts that a specified object is not null.
* @param object - the object that should not be null.
* @param name - the name of the object to be used for error reporting.
*/
public final static boolean notNull(Object object, String name) {
assert object != null: name + " must not be null";
return true;
}

/**
* This method asserts that an int value is within a specified range.
* @param value - the value that must be within the specified range.
* @param min - the minimum value specified of the specified range.
* @param max - the maximum value of the specified range.
* @param name - the name of the value to be used for error reporting.
*/
public final static boolean inRange(int value, int min, int max, String name) {
assert value >= min && value <= max: name + " must be in the range [" + min + " to " + max + "]. Value is " + value;
return true;
}
</pre>

==References==

# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://www.javaworld.com/javaworld/jw-02-2001/jw-0216-cooltools.html?page=1
# http://www.wayforward.net/pycontract/
# http://pyds.muensterland.org/wiki/programmingbycontractforwebservices.html
# http://www.javaworld.com/javaworld/jw-11-2001/jw-1109-assert.html?page=2
# http://www.codeproject.com/csharp/designbycontract.asp
# http://mozart-dev.sourceforge.net/pi-assert.html
# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://onestepback.org/index.cgi/Tech/Programming/DbcAndTesting.html
# http://archive.eiffel.com/doc/manuals/technology/contract/
# http://www.muc.de/~hoelzl/tools/dbc/dbc.lisp

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-29T02:18:55Z

Lwillia:

==Introduction==

===Problem===
In class, we had some difficulty coming up with good examples of programming by contract. Find some concise ones that illustrate the principle well, and are accessible to a general audience of programmers.

===Programming By Contract===
'''Programming by contract (PBC)''' is also called design by contract. It is a form of progamming that deals with pre conditions, post conditions, and invariants. These are used in a client/supplier model. Pre conditions, post conditons, and invariants are specified first. After that, the code is written based on the specified conditions and invariants. It can be seen as a contract because the code needs to abide by the specifications. These contracts are enforced by assertions.[1] Programming by contract uses assertions to enforce the contract between requirements and code. PBC puts the responsibilities on the client to specify the conditions of the functions and other code to meet while and the supplier to honor these requirements that form a contract. [9]

==Implementation and Reasons For==

===Why Use Programming By Contract?===

* PBC helps to define and show the responsibilities of the client and the server. [9]
* Works very well with Inheritance. Any inherited methods need to conform to the contract. [9]
* Able to use assertions to uphold the contract. [9]
* Tests for pre-conditions as well as post-conditions. [9]
* Handles abmormal cases which goes great with exception handling. [10]

===How it works===

* The client has the responsibility of specifying the post conditions for the supplier.
* The post conditions are used by the supplier to develop code.
* The developed code is then given back to the client with pre-conditions.
* These pre-conditions have to be honored in order for the post conditions to be honored
* This in turn becomes a contract between both sides

''' Previous information came from reference [9]. '''

==Example 1==

This example shows design by contract using a sort function in the Python Progamming language. It defines pre and post conditions for the function and also tests the function to make sure that these conditions are upheld. If any of the pre or post conditions are not upheld, an exception is thrown.

* The "pre:" section defines a precondition. This precondition checks to make sure that the parameter a is an instance of a list. It also checks to see if each element within the list can be compared to all of the other elements within the list. Both of these preconditions need to be met in order for the sort function to work properly.

* The "post:" section defines a postcondition. There are three conditions that are required to be met at the end of the function. First the length of the list must never change during the sorting of the list. Second, no elements should be lost or gained from sorting the list. Lastly the list has to actually be sorted. These three conditions assures the integrity of the list.

* The "pre:" and "post:" together make up the contract of the function.

* The function is then sorted.

* The code after "# enable contract checking" is used to test the function and verify that the contract is upheld. The function is simply imported and ran with an arbitrary list.

* The example below is from link 3.

<pre>
def sort(a):
"""Sort a list *IN PLACE*.

>>> a = [1, 1, 1, 1, 1, 2, 2, 1]
>>> sort(a)
>>> a
[1, 1, 1, 1, 1, 1, 2, 2]
>>> a = 'the quick brown fox jumped over the lazy dog'.split()
>>> sort(a)
>>> a
['brown', 'dog', 'fox', 'jumped', 'lazy', 'over', 'quick', 'the', 'the']

pre:
# must be a list
isinstance(a, list)

# all elements must be comparable with all other items
forall(range(len(a)),
lambda i: forall(range(len(a)),
lambda j: (a[i] < a[j]) ^ (a[i] >= a[j])))

post[a]:
# length of array is unchanged
len(a) == len(__old__.a)

# all elements given are still in the array
forall(__old__.a, lambda e: __old__.a.count(e) == a.count(e))

# the array is sorted
forall([a[i] >= a[i-1] for i in range(1, len(a))])
"""
a.sort()

# enable contract checking
import contract
contract.checkmod(__name__)

def _test():
import doctest, sort
return doctest.testmod(sort)

if __name__ == "__main__":
_test()
</pre>

==Example 2==

This example is an API example that adds a number to a list. The number has to be between 0 and 100. This example shows different ways of designing by contract. There are three functions and each one defines ever a invariant, pre-condition, or a post-condition. Notice that the assert keyword is used for upholding the contract of each condition.

* "def _initparms" is the initialization for the class while "def addNumber(self, number)" adds the number to the list.

* "def _invariant(self):" is an invariant that uses an assertion to verify that every number in the list is under 100 at any given time.

* "def addNumber_pre_condition(self, number):" defines a pre-condition for the addNumber function. The conditions that have to be met are a variable must contain an integer only and the number must be less than 100 and greater than zero.

* "def length_post_condition(self, result):"

* The example below is from link 4.

<pre>
class SampleTool(StandardTool):

def _initparms(self):
self.lst = []

def _invariant(self):
assert len(self.lst) < 100

def addNumber(self, number):
self.lst.append(number)

def addNumber_pre_condition(self, number):
assert type(number) == type(1), "Type must be integer"
assert (number < 100) and (number > 0), "Number must be less than 100, but greater than 0"

def length(self):
return len(self.lst)

def length_post_condition(self, result):
assert (result < 100) and (result >= 0), "Result must be less than 100, but greater or equal 0"
</pre>

==Example 3==

This is a C++ example of a bar class. The class takes a value but assures that the value is greater than zero. This example is from link 5.
<pre>
public class Bar
{
public void m1( int value )
{
assert 0 <= value : "Value must be non-negative: value= " + value;
System.out.println( "OK" );
}
public static void main( String[] args )
{
Bar bar = new Bar();
System.out.print( "bar.m1( 1 ): " );
bar.m1( 1 );
System.out.print( "bar.m1( -1 ): " );
bar.m1( -1 );
}
}
</pre>

==Example 4==

This example is written in Java and is an implementation of a stack. Pre and post conditions are implemented as well as an invariant. The example is taken from link 7.
<pre>
class Stack
{
public Stack()
{
objects = new Object[MAX];
top = 0;
}
public void Push(Object o)
{
objects[top] = o;
top++;
}
public Object Pop()
{
top--;
return objects[top];
}
public int Size()
{
return top;
}

private int Remaining()
{
assert (false);
return MAX - top;
}

private Object[] objects;
private int top;
private static final int MAX = 10;

preconditions()
{
Push:
top < MAX;
Pop:
top > 0;
}

postconditions()
{
Push:
top > 0;
}

invariants()
{
top >= 0;
top <= MAX;
}
}
</pre>

==Example 5==

This example is written in Java. Below is two functions that use assertions to check for null and in range. The example is taken from link 8.
<pre>
/**
* This method asserts that a specified object is not null.
* @param object - the object that should not be null.
* @param name - the name of the object to be used for error reporting.
*/
public final static boolean notNull(Object object, String name) {
assert object != null: name + " must not be null";
return true;
}

/**
* This method asserts that an int value is within a specified range.
* @param value - the value that must be within the specified range.
* @param min - the minimum value specified of the specified range.
* @param max - the maximum value of the specified range.
* @param name - the name of the value to be used for error reporting.
*/
public final static boolean inRange(int value, int min, int max, String name) {
assert value >= min && value <= max: name + " must be in the range [" + min + " to " + max + "]. Value is " + value;
return true;
}
</pre>

==References==

# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://www.javaworld.com/javaworld/jw-02-2001/jw-0216-cooltools.html?page=1
# http://www.wayforward.net/pycontract/
# http://pyds.muensterland.org/wiki/programmingbycontractforwebservices.html
# http://www.javaworld.com/javaworld/jw-11-2001/jw-1109-assert.html?page=2
# http://www.codeproject.com/csharp/designbycontract.asp
# http://mozart-dev.sourceforge.net/pi-assert.html
# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://onestepback.org/index.cgi/Tech/Programming/DbcAndTesting.html
# http://archive.eiffel.com/doc/manuals/technology/contract/
# http://www.muc.de/~hoelzl/tools/dbc/dbc.lisp

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-29T01:59:29Z

Lwillia: /* Example 2 */

==Introduction==

===Problem===
In class, we had some difficulty coming up with good examples of programming by contract. Find some concise ones that illustrate the principle well, and are accessible to a general audience of programmers.

===Programming By Contract===
'''Programming by contract (PBC)''' is also called design by contract. It is a form of progamming that deals with pre conditions, post conditions, and invariants. These are used in a client/supplier model. Pre conditions, post conditons, and invariants are specified first. After that, the code is written based on the specified conditions and invariants. It can be seen as a contract because the code needs to abide by the specifications. These contracts are enforced by assertions.[1] Programming by contract uses assertions to enforce the contract between requirements and code. PBC puts the responsibilities on the client to specify the conditions of the functions and other code to meet while and the supplier to honor these requirements that form a contract. [9]

==Implementation and Reasons For==

===Why Use Programming By Contract?===

* PBC helps to define and show the responsibilities of the client and the server. [9]
* Works very well with Inheritance. Any inherited methods need to conform to the contract. [9]
* Able to use assertions to uphold the contract. [9]
* Tests for pre-conditions as well as post-conditions. [9]
* Handles abmormal cases which goes great with exception handling. [10]

===How it works===

* The client has the responsibility of specifying the post conditions for the supplier.
* The post conditions are used by the supplier to develop code.
* The developed code is then given back to the client with pre-conditions.
* These pre-conditions have to be honored in order for the post conditions to be honored
* This in turn becomes a contract between both sides

''' Previous information came from reference [9]. '''

==Example 1==

This example shows design by contract using a sort function in the Python Progamming language. It defines pre and post conditions for the function and also tests the function to make sure that these conditions are upheld. If any of the pre or post conditions are not upheld, an exception is thrown.

* The "pre:" section defines a precondition. This precondition checks to make sure that the parameter a is an instance of a list. It also checks to see if each element within the list can be compared to all of the other elements within the list. Both of these preconditions need to be met in order for the sort function to work properly.

* The "post:" section defines a postcondition. There are three conditions that are required to be met at the end of the function. First the length of the list must never change during the sorting of the list. Second, no elements should be lost or gained from sorting the list. Lastly the list has to actually be sorted. These three conditions assures the integrity of the list.

* The "pre:" and "post:" together make up the contract of the function.

* The function is then sorted.

* The code after "# enable contract checking" is used to test the function and verify that the contract is upheld. The function is simply imported and ran with an arbitrary list.

* The example below is from link 3.

<pre>
def sort(a):
"""Sort a list *IN PLACE*.

>>> a = [1, 1, 1, 1, 1, 2, 2, 1]
>>> sort(a)
>>> a
[1, 1, 1, 1, 1, 1, 2, 2]
>>> a = 'the quick brown fox jumped over the lazy dog'.split()
>>> sort(a)
>>> a
['brown', 'dog', 'fox', 'jumped', 'lazy', 'over', 'quick', 'the', 'the']

pre:
# must be a list
isinstance(a, list)

# all elements must be comparable with all other items
forall(range(len(a)),
lambda i: forall(range(len(a)),
lambda j: (a[i] < a[j]) ^ (a[i] >= a[j])))

post[a]:
# length of array is unchanged
len(a) == len(__old__.a)

# all elements given are still in the array
forall(__old__.a, lambda e: __old__.a.count(e) == a.count(e))

# the array is sorted
forall([a[i] >= a[i-1] for i in range(1, len(a))])
"""
a.sort()

# enable contract checking
import contract
contract.checkmod(__name__)

def _test():
import doctest, sort
return doctest.testmod(sort)

if __name__ == "__main__":
_test()
</pre>

==Example 2==

This example is an API example that adds a number to a list. The number has to be between 0 and 100. This example shows how invariants and assetions can be used designing by contract. There are three functions and each one defines ever a invariant, pre-condition, or a post-condition. Notice that the assert keyword is used for upholding the contract of each condition. The example below is from link 4.
<pre>
class SampleTool(StandardTool):

def _initparms(self):
self.lst = []

def _invariant(self):
assert len(self.lst) < 100

def addNumber(self, number):
self.lst.append(number)

def addNumber_pre_condition(self, number):
assert type(number) == type(1), "Type must be integer"
assert (number < 100) and (number > 0), "Number must be less than 100, but greater than 0"

def length(self):
return len(self.lst)

def length_post_condition(self, result):
assert (result < 100) and (result >= 0), "Result must be less than 100, but greater or equal 0"
</pre>

==Example 3==

This is a C++ example of a bar class. The class takes a value but assures that the value is greater than zero. This example is from link 5.
<pre>
public class Bar
{
public void m1( int value )
{
assert 0 <= value : "Value must be non-negative: value= " + value;
System.out.println( "OK" );
}
public static void main( String[] args )
{
Bar bar = new Bar();
System.out.print( "bar.m1( 1 ): " );
bar.m1( 1 );
System.out.print( "bar.m1( -1 ): " );
bar.m1( -1 );
}
}
</pre>

==Example 4==

This example is written in Java and is an implementation of a stack. Pre and post conditions are implemented as well as an invariant. The example is taken from link 7.
<pre>
class Stack
{
public Stack()
{
objects = new Object[MAX];
top = 0;
}
public void Push(Object o)
{
objects[top] = o;
top++;
}
public Object Pop()
{
top--;
return objects[top];
}
public int Size()
{
return top;
}

private int Remaining()
{
assert (false);
return MAX - top;
}

private Object[] objects;
private int top;
private static final int MAX = 10;

preconditions()
{
Push:
top < MAX;
Pop:
top > 0;
}

postconditions()
{
Push:
top > 0;
}

invariants()
{
top >= 0;
top <= MAX;
}
}
</pre>

==Example 5==

This example is written in Java. Below is two functions that use assertions to check for null and in range. The example is taken from link 8.
<pre>
/**
* This method asserts that a specified object is not null.
* @param object - the object that should not be null.
* @param name - the name of the object to be used for error reporting.
*/
public final static boolean notNull(Object object, String name) {
assert object != null: name + " must not be null";
return true;
}

/**
* This method asserts that an int value is within a specified range.
* @param value - the value that must be within the specified range.
* @param min - the minimum value specified of the specified range.
* @param max - the maximum value of the specified range.
* @param name - the name of the value to be used for error reporting.
*/
public final static boolean inRange(int value, int min, int max, String name) {
assert value >= min && value <= max: name + " must be in the range [" + min + " to " + max + "]. Value is " + value;
return true;
}
</pre>

==References==

# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://www.javaworld.com/javaworld/jw-02-2001/jw-0216-cooltools.html?page=1
# http://www.wayforward.net/pycontract/
# http://pyds.muensterland.org/wiki/programmingbycontractforwebservices.html
# http://www.javaworld.com/javaworld/jw-11-2001/jw-1109-assert.html?page=2
# http://www.codeproject.com/csharp/designbycontract.asp
# http://mozart-dev.sourceforge.net/pi-assert.html
# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://onestepback.org/index.cgi/Tech/Programming/DbcAndTesting.html
# http://archive.eiffel.com/doc/manuals/technology/contract/
# http://www.muc.de/~hoelzl/tools/dbc/dbc.lisp

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-29T01:56:05Z

Lwillia: /* Example 1 */

==Introduction==

===Problem===
In class, we had some difficulty coming up with good examples of programming by contract. Find some concise ones that illustrate the principle well, and are accessible to a general audience of programmers.

===Programming By Contract===
'''Programming by contract (PBC)''' is also called design by contract. It is a form of progamming that deals with pre conditions, post conditions, and invariants. These are used in a client/supplier model. Pre conditions, post conditons, and invariants are specified first. After that, the code is written based on the specified conditions and invariants. It can be seen as a contract because the code needs to abide by the specifications. These contracts are enforced by assertions.[1] Programming by contract uses assertions to enforce the contract between requirements and code. PBC puts the responsibilities on the client to specify the conditions of the functions and other code to meet while and the supplier to honor these requirements that form a contract. [9]

==Implementation and Reasons For==

===Why Use Programming By Contract?===

* PBC helps to define and show the responsibilities of the client and the server. [9]
* Works very well with Inheritance. Any inherited methods need to conform to the contract. [9]
* Able to use assertions to uphold the contract. [9]
* Tests for pre-conditions as well as post-conditions. [9]
* Handles abmormal cases which goes great with exception handling. [10]

===How it works===

* The client has the responsibility of specifying the post conditions for the supplier.
* The post conditions are used by the supplier to develop code.
* The developed code is then given back to the client with pre-conditions.
* These pre-conditions have to be honored in order for the post conditions to be honored
* This in turn becomes a contract between both sides

''' Previous information came from reference [9]. '''

==Example 1==

This example shows design by contract using a sort function in the Python Progamming language. It defines pre and post conditions for the function and also tests the function to make sure that these conditions are upheld. If any of the pre or post conditions are not upheld, an exception is thrown.

* The "pre:" section defines a precondition. This precondition checks to make sure that the parameter a is an instance of a list. It also checks to see if each element within the list can be compared to all of the other elements within the list. Both of these preconditions need to be met in order for the sort function to work properly.

* The "post:" section defines a postcondition. There are three conditions that are required to be met at the end of the function. First the length of the list must never change during the sorting of the list. Second, no elements should be lost or gained from sorting the list. Lastly the list has to actually be sorted. These three conditions assures the integrity of the list.

* The "pre:" and "post:" together make up the contract of the function.

* The function is then sorted.

* The code after "# enable contract checking" is used to test the function and verify that the contract is upheld. The function is simply imported and ran with an arbitrary list.

* The example below is from link 3.

<pre>
def sort(a):
"""Sort a list *IN PLACE*.

>>> a = [1, 1, 1, 1, 1, 2, 2, 1]
>>> sort(a)
>>> a
[1, 1, 1, 1, 1, 1, 2, 2]
>>> a = 'the quick brown fox jumped over the lazy dog'.split()
>>> sort(a)
>>> a
['brown', 'dog', 'fox', 'jumped', 'lazy', 'over', 'quick', 'the', 'the']

pre:
# must be a list
isinstance(a, list)

# all elements must be comparable with all other items
forall(range(len(a)),
lambda i: forall(range(len(a)),
lambda j: (a[i] < a[j]) ^ (a[i] >= a[j])))

post[a]:
# length of array is unchanged
len(a) == len(__old__.a)

# all elements given are still in the array
forall(__old__.a, lambda e: __old__.a.count(e) == a.count(e))

# the array is sorted
forall([a[i] >= a[i-1] for i in range(1, len(a))])
"""
a.sort()

# enable contract checking
import contract
contract.checkmod(__name__)

def _test():
import doctest, sort
return doctest.testmod(sort)

if __name__ == "__main__":
_test()
</pre>

==Example 2==

This example is an API example that adds a number to a list. The number has to be between 0 and 100. This example shows different ways of designing by contract. There are three functions and each one defines ever a invariant, pre-condition, or a post-condition. Notice that the assert keyword is used for upholding the contract of each condition. The example below is from link 4.
<pre>
class SampleTool(StandardTool):

def _initparms(self):
self.lst = []

def _invariant(self):
assert len(self.lst) < 100

def addNumber(self, number):
self.lst.append(number)

def addNumber_pre_condition(self, number):
assert type(number) == type(1), "Type must be integer"
assert (number < 100) and (number > 0), "Number must be less than 100, but greater than 0"

def length(self):
return len(self.lst)

def length_post_condition(self, result):
assert (result < 100) and (result >= 0), "Result must be less than 100, but greater or equal 0"
</pre>

==Example 3==

This is a C++ example of a bar class. The class takes a value but assures that the value is greater than zero. This example is from link 5.
<pre>
public class Bar
{
public void m1( int value )
{
assert 0 <= value : "Value must be non-negative: value= " + value;
System.out.println( "OK" );
}
public static void main( String[] args )
{
Bar bar = new Bar();
System.out.print( "bar.m1( 1 ): " );
bar.m1( 1 );
System.out.print( "bar.m1( -1 ): " );
bar.m1( -1 );
}
}
</pre>

==Example 4==

This example is written in Java and is an implementation of a stack. Pre and post conditions are implemented as well as an invariant. The example is taken from link 7.
<pre>
class Stack
{
public Stack()
{
objects = new Object[MAX];
top = 0;
}
public void Push(Object o)
{
objects[top] = o;
top++;
}
public Object Pop()
{
top--;
return objects[top];
}
public int Size()
{
return top;
}

private int Remaining()
{
assert (false);
return MAX - top;
}

private Object[] objects;
private int top;
private static final int MAX = 10;

preconditions()
{
Push:
top < MAX;
Pop:
top > 0;
}

postconditions()
{
Push:
top > 0;
}

invariants()
{
top >= 0;
top <= MAX;
}
}
</pre>

==Example 5==

This example is written in Java. Below is two functions that use assertions to check for null and in range. The example is taken from link 8.
<pre>
/**
* This method asserts that a specified object is not null.
* @param object - the object that should not be null.
* @param name - the name of the object to be used for error reporting.
*/
public final static boolean notNull(Object object, String name) {
assert object != null: name + " must not be null";
return true;
}

/**
* This method asserts that an int value is within a specified range.
* @param value - the value that must be within the specified range.
* @param min - the minimum value specified of the specified range.
* @param max - the maximum value of the specified range.
* @param name - the name of the value to be used for error reporting.
*/
public final static boolean inRange(int value, int min, int max, String name) {
assert value >= min && value <= max: name + " must be in the range [" + min + " to " + max + "]. Value is " + value;
return true;
}
</pre>

==References==

# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://www.javaworld.com/javaworld/jw-02-2001/jw-0216-cooltools.html?page=1
# http://www.wayforward.net/pycontract/
# http://pyds.muensterland.org/wiki/programmingbycontractforwebservices.html
# http://www.javaworld.com/javaworld/jw-11-2001/jw-1109-assert.html?page=2
# http://www.codeproject.com/csharp/designbycontract.asp
# http://mozart-dev.sourceforge.net/pi-assert.html
# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://onestepback.org/index.cgi/Tech/Programming/DbcAndTesting.html
# http://archive.eiffel.com/doc/manuals/technology/contract/
# http://www.muc.de/~hoelzl/tools/dbc/dbc.lisp

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-29T01:55:57Z

Lwillia: /* Example 1 */

==Introduction==

===Problem===
In class, we had some difficulty coming up with good examples of programming by contract. Find some concise ones that illustrate the principle well, and are accessible to a general audience of programmers.

===Programming By Contract===
'''Programming by contract (PBC)''' is also called design by contract. It is a form of progamming that deals with pre conditions, post conditions, and invariants. These are used in a client/supplier model. Pre conditions, post conditons, and invariants are specified first. After that, the code is written based on the specified conditions and invariants. It can be seen as a contract because the code needs to abide by the specifications. These contracts are enforced by assertions.[1] Programming by contract uses assertions to enforce the contract between requirements and code. PBC puts the responsibilities on the client to specify the conditions of the functions and other code to meet while and the supplier to honor these requirements that form a contract. [9]

==Implementation and Reasons For==

===Why Use Programming By Contract?===

* PBC helps to define and show the responsibilities of the client and the server. [9]
* Works very well with Inheritance. Any inherited methods need to conform to the contract. [9]
* Able to use assertions to uphold the contract. [9]
* Tests for pre-conditions as well as post-conditions. [9]
* Handles abmormal cases which goes great with exception handling. [10]

===How it works===

* The client has the responsibility of specifying the post conditions for the supplier.
* The post conditions are used by the supplier to develop code.
* The developed code is then given back to the client with pre-conditions.
* These pre-conditions have to be honored in order for the post conditions to be honored
* This in turn becomes a contract between both sides

''' Previous information came from reference [9]. '''

==Example 1==

This example shows design by contract using a sort function in the Python Progamming language. It defines pre and post conditions for the function and also tests the function to make sure that these conditions are upheld. If any of the pre or post conditions are not upheld, an exception is thrown.

* The "pre:" section defines a precondition. This precondition checks to make sure that the parameter a is an instance of a list. It also checks to see if each element within the list can be compared to all of the other elements within the list. Both of these preconditions need to be met in order for the sort function to work properly.

* The "post:" section defines a postcondition. There are three conditions that are required to be met at the end of the function. First the length of the list must never change during the sorting of the list. Second, no elements should be lost or gained from sorting the list. Lastly the list has to actually be sorted. These three conditions assures the integrity of the list.

* The "pre:" and "post:" together make up the contract of the function.

* The function is then sorted.

* The code after "# enable contract checking" is used to test the function and verify that the contract is upheld. The function is simply imported and ran with an arbitrary list.

* The example below is from link 3.

<pre>
def sort(a):
"""Sort a list *IN PLACE*.

>>> a = [1, 1, 1, 1, 1, 2, 2, 1]
>>> sort(a)
>>> a
[1, 1, 1, 1, 1, 1, 2, 2]
>>> a = 'the quick brown fox jumped over the lazy dog'.split()
>>> sort(a)
>>> a
['brown', 'dog', 'fox', 'jumped', 'lazy', 'over', 'quick', 'the', 'the']

pre:
# must be a list
isinstance(a, list)

# all elements must be comparable with all other items
forall(range(len(a)),
lambda i: forall(range(len(a)),
lambda j: (a[i] < a[j]) ^ (a[i] >= a[j])))

post[a]:
# length of array is unchanged
len(a) == len(__old__.a)

# all elements given are still in the array
forall(__old__.a, lambda e: __old__.a.count(e) == a.count(e))

# the array is sorted
forall([a[i] >= a[i-1] for i in range(1, len(a))])
"""
a.sort()

# enable contract checking
import contract
contract.checkmod(__name__)

def _test():
import doctest, sort
return doctest.testmod(sort)

if __name__ == "__main__":
_test()
</pre>

==Example 2==

This example is an API example that adds a number to a list. The number has to be between 0 and 100. This example shows different ways of designing by contract. There are three functions and each one defines ever a invariant, pre-condition, or a post-condition. Notice that the assert keyword is used for upholding the contract of each condition. The example below is from link 4.
<pre>
class SampleTool(StandardTool):

def _initparms(self):
self.lst = []

def _invariant(self):
assert len(self.lst) < 100

def addNumber(self, number):
self.lst.append(number)

def addNumber_pre_condition(self, number):
assert type(number) == type(1), "Type must be integer"
assert (number < 100) and (number > 0), "Number must be less than 100, but greater than 0"

def length(self):
return len(self.lst)

def length_post_condition(self, result):
assert (result < 100) and (result >= 0), "Result must be less than 100, but greater or equal 0"
</pre>

==Example 3==

This is a C++ example of a bar class. The class takes a value but assures that the value is greater than zero. This example is from link 5.
<pre>
public class Bar
{
public void m1( int value )
{
assert 0 <= value : "Value must be non-negative: value= " + value;
System.out.println( "OK" );
}
public static void main( String[] args )
{
Bar bar = new Bar();
System.out.print( "bar.m1( 1 ): " );
bar.m1( 1 );
System.out.print( "bar.m1( -1 ): " );
bar.m1( -1 );
}
}
</pre>

==Example 4==

This example is written in Java and is an implementation of a stack. Pre and post conditions are implemented as well as an invariant. The example is taken from link 7.
<pre>
class Stack
{
public Stack()
{
objects = new Object[MAX];
top = 0;
}
public void Push(Object o)
{
objects[top] = o;
top++;
}
public Object Pop()
{
top--;
return objects[top];
}
public int Size()
{
return top;
}

private int Remaining()
{
assert (false);
return MAX - top;
}

private Object[] objects;
private int top;
private static final int MAX = 10;

preconditions()
{
Push:
top < MAX;
Pop:
top > 0;
}

postconditions()
{
Push:
top > 0;
}

invariants()
{
top >= 0;
top <= MAX;
}
}
</pre>

==Example 5==

This example is written in Java. Below is two functions that use assertions to check for null and in range. The example is taken from link 8.
<pre>
/**
* This method asserts that a specified object is not null.
* @param object - the object that should not be null.
* @param name - the name of the object to be used for error reporting.
*/
public final static boolean notNull(Object object, String name) {
assert object != null: name + " must not be null";
return true;
}

/**
* This method asserts that an int value is within a specified range.
* @param value - the value that must be within the specified range.
* @param min - the minimum value specified of the specified range.
* @param max - the maximum value of the specified range.
* @param name - the name of the value to be used for error reporting.
*/
public final static boolean inRange(int value, int min, int max, String name) {
assert value >= min && value <= max: name + " must be in the range [" + min + " to " + max + "]. Value is " + value;
return true;
}
</pre>

==References==

# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://www.javaworld.com/javaworld/jw-02-2001/jw-0216-cooltools.html?page=1
# http://www.wayforward.net/pycontract/
# http://pyds.muensterland.org/wiki/programmingbycontractforwebservices.html
# http://www.javaworld.com/javaworld/jw-11-2001/jw-1109-assert.html?page=2
# http://www.codeproject.com/csharp/designbycontract.asp
# http://mozart-dev.sourceforge.net/pi-assert.html
# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://onestepback.org/index.cgi/Tech/Programming/DbcAndTesting.html
# http://archive.eiffel.com/doc/manuals/technology/contract/
# http://www.muc.de/~hoelzl/tools/dbc/dbc.lisp

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-29T01:55:34Z

Lwillia: /* Example 1 */

==Introduction==

===Problem===
In class, we had some difficulty coming up with good examples of programming by contract. Find some concise ones that illustrate the principle well, and are accessible to a general audience of programmers.

===Programming By Contract===
'''Programming by contract (PBC)''' is also called design by contract. It is a form of progamming that deals with pre conditions, post conditions, and invariants. These are used in a client/supplier model. Pre conditions, post conditons, and invariants are specified first. After that, the code is written based on the specified conditions and invariants. It can be seen as a contract because the code needs to abide by the specifications. These contracts are enforced by assertions.[1] Programming by contract uses assertions to enforce the contract between requirements and code. PBC puts the responsibilities on the client to specify the conditions of the functions and other code to meet while and the supplier to honor these requirements that form a contract. [9]

==Implementation and Reasons For==

===Why Use Programming By Contract?===

* PBC helps to define and show the responsibilities of the client and the server. [9]
* Works very well with Inheritance. Any inherited methods need to conform to the contract. [9]
* Able to use assertions to uphold the contract. [9]
* Tests for pre-conditions as well as post-conditions. [9]
* Handles abmormal cases which goes great with exception handling. [10]

===How it works===

* The client has the responsibility of specifying the post conditions for the supplier.
* The post conditions are used by the supplier to develop code.
* The developed code is then given back to the client with pre-conditions.
* These pre-conditions have to be honored in order for the post conditions to be honored
* This in turn becomes a contract between both sides

''' Previous information came from reference [9]. '''

==Example 1==

This example shows design by contract using a sort function in the Python Progamming language. It defines pre and post conditions for the function and also tests the function to make sure that these conditions are upheld. If any of the pre or post conditions are not upheld, an exception is thrown.

* The "pre:" section defines a precondition. This precondition checks to make sure that the parameter a is an instance of a list. It also checks to see if each element within the list can be compared to all of the other elements within the list. Both of these preconditions need to be met in order for the sort function to work properly.

* The "post:" section defines a postcondition. There are three conditions that are required to be met at the end of the function. First the length of the list must never change during the sorting of the list. Second, no elements should be lost or gained from sorting the list. Lastly the list has to actually be sorted. These three conditions assures the integrity of the list.

* The "pre:" and "post:" together make up the contract of the function.

* The function is then sorted.

* The code after "# enable contract checking" is used to test the function and verify that the contract is upheld. The function is simply imported and ran with an arbitrary list.

* The example below is from link 3.

<pre>
def sort(a):
"""Sort a list *IN PLACE*.

>>> a = [1, 1, 1, 1, 1, 2, 2, 1]
>>> sort(a)
>>> a
[1, 1, 1, 1, 1, 1, 2, 2]
>>> a = 'the quick brown fox jumped over the lazy dog'.split()
>>> sort(a)
>>> a
['brown', 'dog', 'fox', 'jumped', 'lazy', 'over', 'quick', 'the', 'the']

pre:
# must be a list
isinstance(a, list)

# all elements must be comparable with all other items
forall(range(len(a)),
lambda i: forall(range(len(a)),
lambda j: (a[i] < a[j]) ^ (a[i] >= a[j])))

post[a]:
# length of array is unchanged
len(a) == len(__old__.a)

# all elements given are still in the array
forall(__old__.a, lambda e: __old__.a.count(e) == a.count(e))

# the array is sorted
forall([a[i] >= a[i-1] for i in range(1, len(a))])
"""
a.sort()

# enable contract checking
import contract
contract.checkmod(__name__)

def _test():
import doctest, sort
return doctest.testmod(sort)

if __name__ == "__main__":
_test()
</pre>

==Example 2==

This example is an API example that adds a number to a list. The number has to be between 0 and 100. This example shows different ways of designing by contract. There are three functions and each one defines ever a invariant, pre-condition, or a post-condition. Notice that the assert keyword is used for upholding the contract of each condition. The example below is from link 4.
<pre>
class SampleTool(StandardTool):

def _initparms(self):
self.lst = []

def _invariant(self):
assert len(self.lst) < 100

def addNumber(self, number):
self.lst.append(number)

def addNumber_pre_condition(self, number):
assert type(number) == type(1), "Type must be integer"
assert (number < 100) and (number > 0), "Number must be less than 100, but greater than 0"

def length(self):
return len(self.lst)

def length_post_condition(self, result):
assert (result < 100) and (result >= 0), "Result must be less than 100, but greater or equal 0"
</pre>

==Example 3==

This is a C++ example of a bar class. The class takes a value but assures that the value is greater than zero. This example is from link 5.
<pre>
public class Bar
{
public void m1( int value )
{
assert 0 <= value : "Value must be non-negative: value= " + value;
System.out.println( "OK" );
}
public static void main( String[] args )
{
Bar bar = new Bar();
System.out.print( "bar.m1( 1 ): " );
bar.m1( 1 );
System.out.print( "bar.m1( -1 ): " );
bar.m1( -1 );
}
}
</pre>

==Example 4==

This example is written in Java and is an implementation of a stack. Pre and post conditions are implemented as well as an invariant. The example is taken from link 7.
<pre>
class Stack
{
public Stack()
{
objects = new Object[MAX];
top = 0;
}
public void Push(Object o)
{
objects[top] = o;
top++;
}
public Object Pop()
{
top--;
return objects[top];
}
public int Size()
{
return top;
}

private int Remaining()
{
assert (false);
return MAX - top;
}

private Object[] objects;
private int top;
private static final int MAX = 10;

preconditions()
{
Push:
top < MAX;
Pop:
top > 0;
}

postconditions()
{
Push:
top > 0;
}

invariants()
{
top >= 0;
top <= MAX;
}
}
</pre>

==Example 5==

This example is written in Java. Below is two functions that use assertions to check for null and in range. The example is taken from link 8.
<pre>
/**
* This method asserts that a specified object is not null.
* @param object - the object that should not be null.
* @param name - the name of the object to be used for error reporting.
*/
public final static boolean notNull(Object object, String name) {
assert object != null: name + " must not be null";
return true;
}

/**
* This method asserts that an int value is within a specified range.
* @param value - the value that must be within the specified range.
* @param min - the minimum value specified of the specified range.
* @param max - the maximum value of the specified range.
* @param name - the name of the value to be used for error reporting.
*/
public final static boolean inRange(int value, int min, int max, String name) {
assert value >= min && value <= max: name + " must be in the range [" + min + " to " + max + "]. Value is " + value;
return true;
}
</pre>

==References==

# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://www.javaworld.com/javaworld/jw-02-2001/jw-0216-cooltools.html?page=1
# http://www.wayforward.net/pycontract/
# http://pyds.muensterland.org/wiki/programmingbycontractforwebservices.html
# http://www.javaworld.com/javaworld/jw-11-2001/jw-1109-assert.html?page=2
# http://www.codeproject.com/csharp/designbycontract.asp
# http://mozart-dev.sourceforge.net/pi-assert.html
# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://onestepback.org/index.cgi/Tech/Programming/DbcAndTesting.html
# http://archive.eiffel.com/doc/manuals/technology/contract/
# http://www.muc.de/~hoelzl/tools/dbc/dbc.lisp

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-29T01:55:08Z

Lwillia: /* Example 1 */

==Introduction==

===Problem===
In class, we had some difficulty coming up with good examples of programming by contract. Find some concise ones that illustrate the principle well, and are accessible to a general audience of programmers.

===Programming By Contract===
'''Programming by contract (PBC)''' is also called design by contract. It is a form of progamming that deals with pre conditions, post conditions, and invariants. These are used in a client/supplier model. Pre conditions, post conditons, and invariants are specified first. After that, the code is written based on the specified conditions and invariants. It can be seen as a contract because the code needs to abide by the specifications. These contracts are enforced by assertions.[1] Programming by contract uses assertions to enforce the contract between requirements and code. PBC puts the responsibilities on the client to specify the conditions of the functions and other code to meet while and the supplier to honor these requirements that form a contract. [9]

==Implementation and Reasons For==

===Why Use Programming By Contract?===

* PBC helps to define and show the responsibilities of the client and the server. [9]
* Works very well with Inheritance. Any inherited methods need to conform to the contract. [9]
* Able to use assertions to uphold the contract. [9]
* Tests for pre-conditions as well as post-conditions. [9]
* Handles abmormal cases which goes great with exception handling. [10]

===How it works===

* The client has the responsibility of specifying the post conditions for the supplier.
* The post conditions are used by the supplier to develop code.
* The developed code is then given back to the client with pre-conditions.
* These pre-conditions have to be honored in order for the post conditions to be honored
* This in turn becomes a contract between both sides

''' Previous information came from reference [9]. '''

==Example 1==

This example shows design by contract using a sort function in the Python Progamming language. It defines pre and post conditions for the function and also tests the function to make sure that these conditions are upheld. If any of the pre or post conditions are not upheld, an exception is thrown.

The "pre:" section defines a precondition. This precondition checks to make sure that the parameter a is an instance of a list. It also checks to see if each element within the list can be compared to all of the other elements within the list. Both of these preconditions need to be met in order for the sort function to work properly.

The "post:" section defines a postcondition. There are three conditions that are required to be met at the end of the function. First the length of the list must never change during the sorting of the list. Second, no elements should be lost or gained from sorting the list. Lastly the list has to actually be sorted. These three conditions assures the integrity of the list.

The "pre:" and "post:" together make up the contract of the function.

The function is then sorted.

The code after "# enable contract checking" is used to test the function and verify that the contract is upheld. The function is simply imported and ran with an arbitrary list.

The example below is from link 3.

<pre>
def sort(a):
"""Sort a list *IN PLACE*.

>>> a = [1, 1, 1, 1, 1, 2, 2, 1]
>>> sort(a)
>>> a
[1, 1, 1, 1, 1, 1, 2, 2]
>>> a = 'the quick brown fox jumped over the lazy dog'.split()
>>> sort(a)
>>> a
['brown', 'dog', 'fox', 'jumped', 'lazy', 'over', 'quick', 'the', 'the']

pre:
# must be a list
isinstance(a, list)

# all elements must be comparable with all other items
forall(range(len(a)),
lambda i: forall(range(len(a)),
lambda j: (a[i] < a[j]) ^ (a[i] >= a[j])))

post[a]:
# length of array is unchanged
len(a) == len(__old__.a)

# all elements given are still in the array
forall(__old__.a, lambda e: __old__.a.count(e) == a.count(e))

# the array is sorted
forall([a[i] >= a[i-1] for i in range(1, len(a))])
"""
a.sort()

# enable contract checking
import contract
contract.checkmod(__name__)

def _test():
import doctest, sort
return doctest.testmod(sort)

if __name__ == "__main__":
_test()
</pre>

==Example 2==

This example is an API example that adds a number to a list. The number has to be between 0 and 100. This example shows different ways of designing by contract. There are three functions and each one defines ever a invariant, pre-condition, or a post-condition. Notice that the assert keyword is used for upholding the contract of each condition. The example below is from link 4.
<pre>
class SampleTool(StandardTool):

def _initparms(self):
self.lst = []

def _invariant(self):
assert len(self.lst) < 100

def addNumber(self, number):
self.lst.append(number)

def addNumber_pre_condition(self, number):
assert type(number) == type(1), "Type must be integer"
assert (number < 100) and (number > 0), "Number must be less than 100, but greater than 0"

def length(self):
return len(self.lst)

def length_post_condition(self, result):
assert (result < 100) and (result >= 0), "Result must be less than 100, but greater or equal 0"
</pre>

==Example 3==

This is a C++ example of a bar class. The class takes a value but assures that the value is greater than zero. This example is from link 5.
<pre>
public class Bar
{
public void m1( int value )
{
assert 0 <= value : "Value must be non-negative: value= " + value;
System.out.println( "OK" );
}
public static void main( String[] args )
{
Bar bar = new Bar();
System.out.print( "bar.m1( 1 ): " );
bar.m1( 1 );
System.out.print( "bar.m1( -1 ): " );
bar.m1( -1 );
}
}
</pre>

==Example 4==

This example is written in Java and is an implementation of a stack. Pre and post conditions are implemented as well as an invariant. The example is taken from link 7.
<pre>
class Stack
{
public Stack()
{
objects = new Object[MAX];
top = 0;
}
public void Push(Object o)
{
objects[top] = o;
top++;
}
public Object Pop()
{
top--;
return objects[top];
}
public int Size()
{
return top;
}

private int Remaining()
{
assert (false);
return MAX - top;
}

private Object[] objects;
private int top;
private static final int MAX = 10;

preconditions()
{
Push:
top < MAX;
Pop:
top > 0;
}

postconditions()
{
Push:
top > 0;
}

invariants()
{
top >= 0;
top <= MAX;
}
}
</pre>

==Example 5==

This example is written in Java. Below is two functions that use assertions to check for null and in range. The example is taken from link 8.
<pre>
/**
* This method asserts that a specified object is not null.
* @param object - the object that should not be null.
* @param name - the name of the object to be used for error reporting.
*/
public final static boolean notNull(Object object, String name) {
assert object != null: name + " must not be null";
return true;
}

/**
* This method asserts that an int value is within a specified range.
* @param value - the value that must be within the specified range.
* @param min - the minimum value specified of the specified range.
* @param max - the maximum value of the specified range.
* @param name - the name of the value to be used for error reporting.
*/
public final static boolean inRange(int value, int min, int max, String name) {
assert value >= min && value <= max: name + " must be in the range [" + min + " to " + max + "]. Value is " + value;
return true;
}
</pre>

==References==

# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://www.javaworld.com/javaworld/jw-02-2001/jw-0216-cooltools.html?page=1
# http://www.wayforward.net/pycontract/
# http://pyds.muensterland.org/wiki/programmingbycontractforwebservices.html
# http://www.javaworld.com/javaworld/jw-11-2001/jw-1109-assert.html?page=2
# http://www.codeproject.com/csharp/designbycontract.asp
# http://mozart-dev.sourceforge.net/pi-assert.html
# http://www.dugaldmorrow.com/index.php?option=com_content&task=view&id=19&Itemid=38
# http://onestepback.org/index.cgi/Tech/Programming/DbcAndTesting.html
# http://archive.eiffel.com/doc/manuals/technology/contract/
# http://www.muc.de/~hoelzl/tools/dbc/dbc.lisp

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T22:38:17Z

Lwillia: /* Implementation and Reasons For */

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T22:24:44Z

Lwillia: /* References */

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T22:22:57Z

Lwillia: /* References */

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T22:22:17Z

Lwillia: /* Implementation and Reasons For */

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T22:18:06Z

Lwillia: /* Why Use Programming By Contract? */

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T20:37:18Z

Lwillia: /* Why Use Programming By Contract? */

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T20:29:07Z

Lwillia: /* Implementation and Reasons For */

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T20:28:47Z

Lwillia:

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T20:26:26Z

Lwillia: /* How it works */

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T20:25:44Z

Lwillia: /* Programming By Contract */

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T20:22:58Z

Lwillia: /* Introduction */

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T20:21:31Z

Lwillia: /* Introduction */

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T20:21:04Z

Lwillia: /* Introduction */

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T20:02:59Z

Lwillia:

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T20:00:06Z

Lwillia: /* Introduction */

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T17:51:52Z

Lwillia: /* Example 5 */

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T17:51:36Z

Lwillia: /* Example 4 */

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T17:51:14Z

Lwillia: /* Example 3 */

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T17:50:48Z

Lwillia: /* Example 2 */

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-28T17:50:26Z

Lwillia: /* Example 1 */

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-19T03:09:19Z

Lwillia:

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-19T02:47:45Z

Lwillia:

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-19T02:41:30Z

Lwillia:

CSC/ECE 517 Fall 2007/wiki3 2 c4

2007-11-19T02:22:50Z

Lwillia:

CSC/ECE 517 Fall 2007/wiki2 10 c4

2007-10-29T15:39:22Z

Lwillia: /* Example 2 */

==Introduction==

===Problem===

Inheritance vs. delegation. Follow the debate on inheritance vs. delegation. Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

===Inheritance===

Inheritance is the process of one class having access to another class's attributes. Inheritance occurs when a class, also called the superclass, is created with generalized methods and attributes, and then another class is created as a subclass to the first class. The subclass provides provides detailed methods and attributes and automatically has access to methods and data members of the superclass. These subclasses can also override the generalized methods of the super class. Sometimes subclasses inherit from more than one super class; the occurrance of this is naturally called multiple inheritance.[1]

===Delegation===

Delegation is the process of assigning the implementation of a method, within a class, to another method. Generally, the implementation responsibility is forwarded to the parent class. If the parent class can not handle the implementation responsibility, it forwards it to its parent and so on and so on.
This forwarding allows a class to dynamically change by changing the parent class relations. Delegation is also called dynamic inheritance.[2]

==Inheritance vs Delegation==

Inheritance and delegation are used in different situations in object oriented programming. Although they can be used simultaneously, its rarely done due to the difficulty in it. Most of the time people use them interchangeably but are doing so incorrectly.

===When to use Inheritance===

* Inheritance is used when two objects are of the same type but one of the objects needs to handle somethings differently. The second object would inherit from the first and simply rewrite the code needed in the second object.[3]

* Inheritance is used in is-a relationships between objects. [3]

* Inheritance is used to sub categorize objects.[3]

* Inheritance should be restricted to objects of the same type.[3]

* When the base class is to general but the functionality is still needed.

=== When to use Delegation===

* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally.[3]

* Delegation is used in has-a relationships where the type of object that is included may change during runtime.

* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known right away. [6]

* When code execution within objects needs to be determined dynamically.

Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

==Inheritance is Better==

===Example 1===

Inheritance is better in this example because any specific account type will require the basic attributes of an account. An interest bearing account also "is a" account. Delegation would not be great in this case because allowing for methods to be determined dynamically opens up opportunities for hacker and calculation issues. Example below is from link [7] and link [8].

public class Account {
protected double balance; // Constructor to initialise balance

public Account( double amount ) {
balance = amount;
}
// Overloaded constructor for empty balance
public Account() {
balance = 0.0;
}
public void deposit( double amount ) {
balance += amount;
}
public double withdraw( double amount ) {
// See if amount can be withdrawn
if (balance >= amount) {
balance -= amount; return amount;
} else
// Withdrawal not allowed return 0.0;
}
public double getbalance() {
return balance;
}
}

class InterestBearingAccount extends Account{
private static double default_interest = 7.95;
private double interest_rate;

// Overloaded constructor accepting balance and an interest rate
public InterestBearingAccount( double amount, double interest){
balance = amount;
interest_rate = interest;
}
// Overloaded constructor accepting balance with a default interest rate
public InterestBearingAccount( double amount ){
balance = amount;
interest_rate = default_interest;
}
// Overloaded constructor with empty balance and a default interest rate
public InterestBearingAccount(){
balance = 0.0;
interest_rate = default_interest;
}

public void add_monthly_interest(){
// Add interest to our account
balance = balance +
(balance * interest_rate / 100) / 12;
}
}

===Example 2===

Here is another example where inheritance is better than delegation. The generalized shape interface is used as a basis for all of the subclasses.
Notice that each subclass is designed to personal specifications for the object. Here there would be no need for any of the code to dynamically change. Example below is from link [9].

public interface Shape{
public double getArea();
public double getPerimeter();
}

public class Rectangle implements Shape
{
private int width;
private int height;

public Rectangle(){
this(1,1);
}

public Rectangle(int width, int height){
this.width = width;
this.height = height;
}

public int getWidth(){
return this.width;
}

public int getHeight(){
return this.height;
}

public double getPerimeter(){
return 2 * this.height + 2 * this.width;
}

public double getArea(){
return width * height;
}

public String toString(){
return "width: " + this.width + ", height: " + this.height;
}
}

public class Square extends Rectangle{
public Square(int lengthOfSide){
super(lengthOfSide, lengthOfSide);
}

public int getSide(){
return getWidth();
}

public String toString(){
return "Length of Side: " + getSide();
}
}

public class Circle implements Shape
{
private int radius;

public Circle(int radius){
this.radius = radius;
}

public double getArea(){
return Math.PI * this.radius * this.radius;
}

public double getPerimeter(){
return 2 * Math.PI * this.radius;
}
}

==Delegation is Better==

===Example 1===

Delegation is better in this example because class Student doesnt know if it wants to use class Classroom or class Cafeteria's implementation of the f and g methods. During the running of the code class Student can change which class implementation of the functions it points to by calling toClassroom or toCafeteria. Students go between classrooms, libraries, and the cafeteria pretty often throughout a day, delegation allows for an easy change betewen these locations. Inheritance isnt able to handle this dynamically. Any implementation of the code would have to be either in the current class or its parent. It couldnt be in a sibling class. Example below is from link [11]. I have adapted it so that it is more clear to understand. SchoolLocation = I, A = Classroom, B = Cafeteria, C = Student;

interface SchoolLocation {
void f();
void g();
}

class Classroom implements School {
public void f() { System.out.println("A: doing f()"); }
public void g() { System.out.println("A: doing g()"); }
}

class Cafeteria implements School {
public void f() { System.out.println("B: doing f()"); }
public void g() { System.out.println("B: doing g()"); }
}

class Sudent implements School {
// delegation
SchoolLocation location = new Classroom();

public void f() { location.f(); }
public void g() { location.g(); }

// normal attributes
void toClassroom() { location = new Classroom(); }
void toCafeteria() { location = new Cafeteria(); }
}

===Example 2===

Below is the link to a great example of how to use delegation for a real world scenario. It isn't code but is in the form of diagrams.
This link uses a school registration system as an example. The school registration system consists of students and faculty. This is then broken down further into graduate and undergraduate students. Graduate students can be phd or master students. Some graduate students can also teach classes and be faculty. This brings up a situation where a graduate student needs to inherit from two places. Many know that multiple inheritance isn't a good dway to handle this. The example uses an delegation and interfaces to handle this issue.

http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Exampleofdelegation.html

http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Addingcomplexity.html

http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Crossingboundaries.html

==References==

# http://searchsmb.techtarget.com/sDefinition/0,,sid44_gci212351,00.html
# http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html
# http://www.tek-tips.com/viewthread.cfm?qid=372254
# http://www.python.org/ftp/python/doc/delegation.ps
# http://www.softwarefederation.com/csci4448/courseNotes/05_ObjectOrientedDesign.pdf
# http://www.javaworld.com/javaworld/javaqa/2001-09/01-qa-0914-delegate.html
# http://www.javacoffeebreak.com/java102/Account.java
# http://www.javacoffeebreak.com/java104/java104.html
# http://www.cs.utexas.edu/~scottm/cs305j/codingSamples.htm
# http://www.tanguay.info/web/codeExample.php?id=492
# http://en.wikipedia.org/wiki/Delegation_pattern
# http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Exampleofdelegation.html

CSC/ECE 517 Fall 2007/wiki2 10 c4

2007-10-29T15:26:07Z

Lwillia: /* Example 1 */

==Introduction==

===Problem===

Inheritance vs. delegation. Follow the debate on inheritance vs. delegation. Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

===Inheritance===

Inheritance is the process of one class having access to another class's attributes. Inheritance occurs when a class, also called the superclass, is created with generalized methods and attributes, and then another class is created as a subclass to the first class. The subclass provides provides detailed methods and attributes and automatically has access to methods and data members of the superclass. These subclasses can also override the generalized methods of the super class. Sometimes subclasses inherit from more than one super class; the occurrance of this is naturally called multiple inheritance.[1]

===Delegation===

Delegation is the process of assigning the implementation of a method, within a class, to another method. Generally, the implementation responsibility is forwarded to the parent class. If the parent class can not handle the implementation responsibility, it forwards it to its parent and so on and so on.
This forwarding allows a class to dynamically change by changing the parent class relations. Delegation is also called dynamic inheritance.[2]

==Inheritance vs Delegation==

Inheritance and delegation are used in different situations in object oriented programming. Although they can be used simultaneously, its rarely done due to the difficulty in it. Most of the time people use them interchangeably but are doing so incorrectly.

===When to use Inheritance===

* Inheritance is used when two objects are of the same type but one of the objects needs to handle somethings differently. The second object would inherit from the first and simply rewrite the code needed in the second object.[3]

* Inheritance is used in is-a relationships between objects. [3]

* Inheritance is used to sub categorize objects.[3]

* Inheritance should be restricted to objects of the same type.[3]

* When the base class is to general but the functionality is still needed.

=== When to use Delegation===

* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally.[3]

* Delegation is used in has-a relationships where the type of object that is included may change during runtime.

* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known right away. [6]

* When code execution within objects needs to be determined dynamically.

Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

==Inheritance is Better==

===Example 1===

Inheritance is better in this example because any specific account type will require the basic attributes of an account. An interest bearing account also "is a" account. Delegation would not be great in this case because allowing for methods to be determined dynamically opens up opportunities for hacker and calculation issues. Example below is from link [7] and link [8].

public class Account {
protected double balance; // Constructor to initialise balance

public Account( double amount ) {
balance = amount;
}
// Overloaded constructor for empty balance
public Account() {
balance = 0.0;
}
public void deposit( double amount ) {
balance += amount;
}
public double withdraw( double amount ) {
// See if amount can be withdrawn
if (balance >= amount) {
balance -= amount; return amount;
} else
// Withdrawal not allowed return 0.0;
}
public double getbalance() {
return balance;
}
}

class InterestBearingAccount extends Account{
private static double default_interest = 7.95;
private double interest_rate;

// Overloaded constructor accepting balance and an interest rate
public InterestBearingAccount( double amount, double interest){
balance = amount;
interest_rate = interest;
}
// Overloaded constructor accepting balance with a default interest rate
public InterestBearingAccount( double amount ){
balance = amount;
interest_rate = default_interest;
}
// Overloaded constructor with empty balance and a default interest rate
public InterestBearingAccount(){
balance = 0.0;
interest_rate = default_interest;
}

public void add_monthly_interest(){
// Add interest to our account
balance = balance +
(balance * interest_rate / 100) / 12;
}
}

===Example 2===

Here is another example where inheritance is better than delegation. The generalized shape interface is used as a basis for all of the subclasses.
Notice that each subclass is designed to personal specifications for the object. Here there would be no need for any of the code to dynamically change. Example below is from link [9].

public interface Shape{
public double getArea();
public double getPerimeter();
}

public class Rectangle implements Shape
{
private int width;
private int height;

public Rectangle(){
this(1,1);
}

public Rectangle(int width, int height){
this.width = width;
this.height = height;
}

public int getWidth(){
return this.width;
}

public int getHeight(){
return this.height;
}

public double getPerimeter(){
return 2 * this.height + 2 * this.width;
}

public double getArea(){
return width * height;
}

public String toString(){
return "width: " + this.width + ", height: " + this.height;
}
}

public class Square extends Rectangle{
public Square(int lengthOfSide){
super(lengthOfSide, lengthOfSide);
}

public int getSide(){
return getWidth();
}

public String toString(){
return "Length of Side: " + getSide();
}
}

public class Circle implements Shape
{
private int radius;

public Circle(int radius){
this.radius = radius;
}

public double getArea(){
return Math.PI * this.radius * this.radius;
}

public double getPerimeter(){
return 2 * Math.PI * this.radius;
}
}

==Delegation is Better==

===Example 1===

Delegation is better in this example because class Student doesnt know if it wants to use class Classroom or class Cafeteria's implementation of the f and g methods. During the running of the code class Student can change which class implementation of the functions it points to by calling toClassroom or toCafeteria. Students go between classrooms, libraries, and the cafeteria pretty often throughout a day, delegation allows for an easy change betewen these locations. Inheritance isnt able to handle this dynamically. Any implementation of the code would have to be either in the current class or its parent. It couldnt be in a sibling class. Example below is from link [11]. I have adapted it so that it is more clear to understand. SchoolLocation = I, A = Classroom, B = Cafeteria, C = Student;

interface SchoolLocation {
void f();
void g();
}

class Classroom implements School {
public void f() { System.out.println("A: doing f()"); }
public void g() { System.out.println("A: doing g()"); }
}

class Cafeteria implements School {
public void f() { System.out.println("B: doing f()"); }
public void g() { System.out.println("B: doing g()"); }
}

class Sudent implements School {
// delegation
SchoolLocation location = new Classroom();

public void f() { location.f(); }
public void g() { location.g(); }

// normal attributes
void toClassroom() { location = new Classroom(); }
void toCafeteria() { location = new Cafeteria(); }
}

===Example 2===

Below is the link to a great example of how to use delegation for a real world scenario. It isnt code but is in the form of diagrams.

http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Exampleofdelegation.html

http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Addingcomplexity.html

http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Crossingboundaries.html

==References==

# http://searchsmb.techtarget.com/sDefinition/0,,sid44_gci212351,00.html
# http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html
# http://www.tek-tips.com/viewthread.cfm?qid=372254
# http://www.python.org/ftp/python/doc/delegation.ps
# http://www.softwarefederation.com/csci4448/courseNotes/05_ObjectOrientedDesign.pdf
# http://www.javaworld.com/javaworld/javaqa/2001-09/01-qa-0914-delegate.html
# http://www.javacoffeebreak.com/java102/Account.java
# http://www.javacoffeebreak.com/java104/java104.html
# http://www.cs.utexas.edu/~scottm/cs305j/codingSamples.htm
# http://www.tanguay.info/web/codeExample.php?id=492
# http://en.wikipedia.org/wiki/Delegation_pattern
# http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Exampleofdelegation.html

CSC/ECE 517 Fall 2007/wiki2 10 c4

2007-10-23T03:30:01Z

Lwillia: /* Example 2 */

==Introduction==

===Problem===

Inheritance vs. delegation. Follow the debate on inheritance vs. delegation. Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

===Inheritance===

Inheritance is the process of one class having access to another class's attributes. Inheritance occurs when a class, also called the superclass, is created with generalized methods and attributes, and then another class is created as a subclass to the first class. The subclass provides provides detailed methods and attributes and automatically has access to methods and data members of the superclass. These subclasses can also override the generalized methods of the super class. Sometimes subclasses inherit from more than one super class; the occurrance of this is naturally called multiple inheritance.[1]

===Delegation===

Delegation is the process of assigning the implementation of a method, within a class, to another method. Generally, the implementation responsibility is forwarded to the parent class. If the parent class can not handle the implementation responsibility, it forwards it to its parent and so on and so on.
This forwarding allows a class to dynamically change by changing the parent class relations. Delegation is also called dynamic inheritance.[2]

==Inheritance vs Delegation==

Inheritance and delegation are used in different situations in object oriented programming. Although they can be used simultaneously, its rarely done due to the difficulty in it. Most of the time people use them interchangeably but are doing so incorrectly.

===When to use Inheritance===

* Inheritance is used when two objects are of the same type but one of the objects needs to handle somethings differently. The second object would inherit from the first and simply rewrite the code needed in the second object.[3]

* Inheritance is used in is-a relationships between objects. [3]

* Inheritance is used to sub categorize objects.[3]

* Inheritance should be restricted to objects of the same type.[3]

* When the base class is to general but the functionality is still needed.

=== When to use Delegation===

* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally.[3]

* Delegation is used in has-a relationships where the type of object that is included may change during runtime.

* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known right away. [6]

* When code execution within objects needs to be determined dynamically.

Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

==Inheritance is Better==

===Example 1===

Inheritance is better in this example because any specific account type will require the basic attributes of an account. An interest bearing account also "is a" account. Delegation would not be great in this case because allowing for methods to be determined dynamically opens up opportunities for hacker and calculation issues. Example below is from link [7] and link [8].

public class Account {
protected double balance; // Constructor to initialise balance

public Account( double amount ) {
balance = amount;
}
// Overloaded constructor for empty balance
public Account() {
balance = 0.0;
}
public void deposit( double amount ) {
balance += amount;
}
public double withdraw( double amount ) {
// See if amount can be withdrawn
if (balance >= amount) {
balance -= amount; return amount;
} else
// Withdrawal not allowed return 0.0;
}
public double getbalance() {
return balance;
}
}

class InterestBearingAccount extends Account{
private static double default_interest = 7.95;
private double interest_rate;

// Overloaded constructor accepting balance and an interest rate
public InterestBearingAccount( double amount, double interest){
balance = amount;
interest_rate = interest;
}
// Overloaded constructor accepting balance with a default interest rate
public InterestBearingAccount( double amount ){
balance = amount;
interest_rate = default_interest;
}
// Overloaded constructor with empty balance and a default interest rate
public InterestBearingAccount(){
balance = 0.0;
interest_rate = default_interest;
}

public void add_monthly_interest(){
// Add interest to our account
balance = balance +
(balance * interest_rate / 100) / 12;
}
}

===Example 2===

Here is another example where inheritance is better than delegation. The generalized shape interface is used as a basis for all of the subclasses.
Notice that each subclass is designed to personal specifications for the object. Here there would be no need for any of the code to dynamically change. Example below is from link [9].

public interface Shape{
public double getArea();
public double getPerimeter();
}

public class Rectangle implements Shape
{
private int width;
private int height;

public Rectangle(){
this(1,1);
}

public Rectangle(int width, int height){
this.width = width;
this.height = height;
}

public int getWidth(){
return this.width;
}

public int getHeight(){
return this.height;
}

public double getPerimeter(){
return 2 * this.height + 2 * this.width;
}

public double getArea(){
return width * height;
}

public String toString(){
return "width: " + this.width + ", height: " + this.height;
}
}

public class Square extends Rectangle{
public Square(int lengthOfSide){
super(lengthOfSide, lengthOfSide);
}

public int getSide(){
return getWidth();
}

public String toString(){
return "Length of Side: " + getSide();
}
}

public class Circle implements Shape
{
private int radius;

public Circle(int radius){
this.radius = radius;
}

public double getArea(){
return Math.PI * this.radius * this.radius;
}

public double getPerimeter(){
return 2 * Math.PI * this.radius;
}
}

==Delegation is Better==

===Example 1===

Delegation is better in this example because class c doesnt know if it wants to use class A or class B's implementation of the f and g methods. During the running of the code class c can change which class implementation of the functions it points to by calling toA or toB. Inheritance isnt able to handle this dynamically. Any implementation of the code would have to be either in the current class or its parent. It couldnt be in a sibling class. Example below is from link [11].

interface I {
void f();
void g();
}

class A implements I {
public void f() { System.out.println("A: doing f()"); }
public void g() { System.out.println("A: doing g()"); }
}

class B implements I {
public void f() { System.out.println("B: doing f()"); }
public void g() { System.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

public void f() { i.f(); }
public void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

===Example 2===

Below is the link to a great example of how to use delegation for a real world scenario. It isnt code but is in the form of diagrams.

http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Exampleofdelegation.html

http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Addingcomplexity.html

http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Crossingboundaries.html

==References==

# http://searchsmb.techtarget.com/sDefinition/0,,sid44_gci212351,00.html
# http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html
# http://www.tek-tips.com/viewthread.cfm?qid=372254
# http://www.python.org/ftp/python/doc/delegation.ps
# http://www.softwarefederation.com/csci4448/courseNotes/05_ObjectOrientedDesign.pdf
# http://www.javaworld.com/javaworld/javaqa/2001-09/01-qa-0914-delegate.html
# http://www.javacoffeebreak.com/java102/Account.java
# http://www.javacoffeebreak.com/java104/java104.html
# http://www.cs.utexas.edu/~scottm/cs305j/codingSamples.htm
# http://www.tanguay.info/web/codeExample.php?id=492
# http://en.wikipedia.org/wiki/Delegation_pattern
# http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Exampleofdelegation.html

CSC/ECE 517 Fall 2007/wiki2 10 c4

2007-10-23T03:29:47Z

Lwillia: /* Example 2 */

==Introduction==

===Problem===

Inheritance vs. delegation. Follow the debate on inheritance vs. delegation. Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

===Inheritance===

Inheritance is the process of one class having access to another class's attributes. Inheritance occurs when a class, also called the superclass, is created with generalized methods and attributes, and then another class is created as a subclass to the first class. The subclass provides provides detailed methods and attributes and automatically has access to methods and data members of the superclass. These subclasses can also override the generalized methods of the super class. Sometimes subclasses inherit from more than one super class; the occurrance of this is naturally called multiple inheritance.[1]

===Delegation===

Delegation is the process of assigning the implementation of a method, within a class, to another method. Generally, the implementation responsibility is forwarded to the parent class. If the parent class can not handle the implementation responsibility, it forwards it to its parent and so on and so on.
This forwarding allows a class to dynamically change by changing the parent class relations. Delegation is also called dynamic inheritance.[2]

==Inheritance vs Delegation==

Inheritance and delegation are used in different situations in object oriented programming. Although they can be used simultaneously, its rarely done due to the difficulty in it. Most of the time people use them interchangeably but are doing so incorrectly.

===When to use Inheritance===

* Inheritance is used when two objects are of the same type but one of the objects needs to handle somethings differently. The second object would inherit from the first and simply rewrite the code needed in the second object.[3]

* Inheritance is used in is-a relationships between objects. [3]

* Inheritance is used to sub categorize objects.[3]

* Inheritance should be restricted to objects of the same type.[3]

* When the base class is to general but the functionality is still needed.

=== When to use Delegation===

* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally.[3]

* Delegation is used in has-a relationships where the type of object that is included may change during runtime.

* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known right away. [6]

* When code execution within objects needs to be determined dynamically.

Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

==Inheritance is Better==

===Example 1===

Inheritance is better in this example because any specific account type will require the basic attributes of an account. An interest bearing account also "is a" account. Delegation would not be great in this case because allowing for methods to be determined dynamically opens up opportunities for hacker and calculation issues. Example below is from link [7] and link [8].

public class Account {
protected double balance; // Constructor to initialise balance

public Account( double amount ) {
balance = amount;
}
// Overloaded constructor for empty balance
public Account() {
balance = 0.0;
}
public void deposit( double amount ) {
balance += amount;
}
public double withdraw( double amount ) {
// See if amount can be withdrawn
if (balance >= amount) {
balance -= amount; return amount;
} else
// Withdrawal not allowed return 0.0;
}
public double getbalance() {
return balance;
}
}

class InterestBearingAccount extends Account{
private static double default_interest = 7.95;
private double interest_rate;

// Overloaded constructor accepting balance and an interest rate
public InterestBearingAccount( double amount, double interest){
balance = amount;
interest_rate = interest;
}
// Overloaded constructor accepting balance with a default interest rate
public InterestBearingAccount( double amount ){
balance = amount;
interest_rate = default_interest;
}
// Overloaded constructor with empty balance and a default interest rate
public InterestBearingAccount(){
balance = 0.0;
interest_rate = default_interest;
}

public void add_monthly_interest(){
// Add interest to our account
balance = balance +
(balance * interest_rate / 100) / 12;
}
}

===Example 2===

Here is another example where inheritance is better than delegation. The generalized shape interface is used as a basis for all of the subclasses.
Notice that each subclass is designed to personal specifications for the object. Here there would be no need for any of the code to dynamically change. Example below is from link [9].

public interface Shape{
public double getArea();
public double getPerimeter();
}

public class Rectangle implements Shape
{
private int width;
private int height;

public Rectangle(){
this(1,1);
}

public Rectangle(int width, int height){
this.width = width;
this.height = height;
}

public int getWidth(){
return this.width;
}

public int getHeight(){
return this.height;
}

public double getPerimeter(){
return 2 * this.height + 2 * this.width;
}

public double getArea(){
return width * height;
}

public String toString(){
return "width: " + this.width + ", height: " + this.height;
}
}

public class Square extends Rectangle{
public Square(int lengthOfSide){
super(lengthOfSide, lengthOfSide);
}

public int getSide(){
return getWidth();
}

public String toString(){
return "Length of Side: " + getSide();
}
}

public class Circle implements Shape
{
private int radius;

public Circle(int radius){
this.radius = radius;
}

public double getArea(){
return Math.PI * this.radius * this.radius;
}

public double getPerimeter(){
return 2 * Math.PI * this.radius;
}
}

==Delegation is Better==

===Example 1===

Delegation is better in this example because class c doesnt know if it wants to use class A or class B's implementation of the f and g methods. During the running of the code class c can change which class implementation of the functions it points to by calling toA or toB. Inheritance isnt able to handle this dynamically. Any implementation of the code would have to be either in the current class or its parent. It couldnt be in a sibling class. Example below is from link [11].

interface I {
void f();
void g();
}

class A implements I {
public void f() { System.out.println("A: doing f()"); }
public void g() { System.out.println("A: doing g()"); }
}

class B implements I {
public void f() { System.out.println("B: doing f()"); }
public void g() { System.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

public void f() { i.f(); }
public void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

===Example 2===

Below is the link to a great example of how to use delegation for a real world scenario. It isnt code but is in the form of diagrams.

http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Exampleofdelegation.html

http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Addingcomplexity.html
http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Crossingboundaries.html

==References==

# http://searchsmb.techtarget.com/sDefinition/0,,sid44_gci212351,00.html
# http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html
# http://www.tek-tips.com/viewthread.cfm?qid=372254
# http://www.python.org/ftp/python/doc/delegation.ps
# http://www.softwarefederation.com/csci4448/courseNotes/05_ObjectOrientedDesign.pdf
# http://www.javaworld.com/javaworld/javaqa/2001-09/01-qa-0914-delegate.html
# http://www.javacoffeebreak.com/java102/Account.java
# http://www.javacoffeebreak.com/java104/java104.html
# http://www.cs.utexas.edu/~scottm/cs305j/codingSamples.htm
# http://www.tanguay.info/web/codeExample.php?id=492
# http://en.wikipedia.org/wiki/Delegation_pattern
# http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Exampleofdelegation.html

CSC/ECE 517 Fall 2007/wiki2 10 c4

2007-10-23T03:29:29Z

Lwillia: /* Example 2 */

==Introduction==

===Problem===

Inheritance vs. delegation. Follow the debate on inheritance vs. delegation. Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

===Inheritance===

Inheritance is the process of one class having access to another class's attributes. Inheritance occurs when a class, also called the superclass, is created with generalized methods and attributes, and then another class is created as a subclass to the first class. The subclass provides provides detailed methods and attributes and automatically has access to methods and data members of the superclass. These subclasses can also override the generalized methods of the super class. Sometimes subclasses inherit from more than one super class; the occurrance of this is naturally called multiple inheritance.[1]

===Delegation===

Delegation is the process of assigning the implementation of a method, within a class, to another method. Generally, the implementation responsibility is forwarded to the parent class. If the parent class can not handle the implementation responsibility, it forwards it to its parent and so on and so on.
This forwarding allows a class to dynamically change by changing the parent class relations. Delegation is also called dynamic inheritance.[2]

==Inheritance vs Delegation==

Inheritance and delegation are used in different situations in object oriented programming. Although they can be used simultaneously, its rarely done due to the difficulty in it. Most of the time people use them interchangeably but are doing so incorrectly.

===When to use Inheritance===

* Inheritance is used when two objects are of the same type but one of the objects needs to handle somethings differently. The second object would inherit from the first and simply rewrite the code needed in the second object.[3]

* Inheritance is used in is-a relationships between objects. [3]

* Inheritance is used to sub categorize objects.[3]

* Inheritance should be restricted to objects of the same type.[3]

* When the base class is to general but the functionality is still needed.

=== When to use Delegation===

* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally.[3]

* Delegation is used in has-a relationships where the type of object that is included may change during runtime.

* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known right away. [6]

* When code execution within objects needs to be determined dynamically.

Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

==Inheritance is Better==

===Example 1===

Inheritance is better in this example because any specific account type will require the basic attributes of an account. An interest bearing account also "is a" account. Delegation would not be great in this case because allowing for methods to be determined dynamically opens up opportunities for hacker and calculation issues. Example below is from link [7] and link [8].

public class Account {
protected double balance; // Constructor to initialise balance

public Account( double amount ) {
balance = amount;
}
// Overloaded constructor for empty balance
public Account() {
balance = 0.0;
}
public void deposit( double amount ) {
balance += amount;
}
public double withdraw( double amount ) {
// See if amount can be withdrawn
if (balance >= amount) {
balance -= amount; return amount;
} else
// Withdrawal not allowed return 0.0;
}
public double getbalance() {
return balance;
}
}

class InterestBearingAccount extends Account{
private static double default_interest = 7.95;
private double interest_rate;

// Overloaded constructor accepting balance and an interest rate
public InterestBearingAccount( double amount, double interest){
balance = amount;
interest_rate = interest;
}
// Overloaded constructor accepting balance with a default interest rate
public InterestBearingAccount( double amount ){
balance = amount;
interest_rate = default_interest;
}
// Overloaded constructor with empty balance and a default interest rate
public InterestBearingAccount(){
balance = 0.0;
interest_rate = default_interest;
}

public void add_monthly_interest(){
// Add interest to our account
balance = balance +
(balance * interest_rate / 100) / 12;
}
}

===Example 2===

Here is another example where inheritance is better than delegation. The generalized shape interface is used as a basis for all of the subclasses.
Notice that each subclass is designed to personal specifications for the object. Here there would be no need for any of the code to dynamically change. Example below is from link [9].

public interface Shape{
public double getArea();
public double getPerimeter();
}

public class Rectangle implements Shape
{
private int width;
private int height;

public Rectangle(){
this(1,1);
}

public Rectangle(int width, int height){
this.width = width;
this.height = height;
}

public int getWidth(){
return this.width;
}

public int getHeight(){
return this.height;
}

public double getPerimeter(){
return 2 * this.height + 2 * this.width;
}

public double getArea(){
return width * height;
}

public String toString(){
return "width: " + this.width + ", height: " + this.height;
}
}

public class Square extends Rectangle{
public Square(int lengthOfSide){
super(lengthOfSide, lengthOfSide);
}

public int getSide(){
return getWidth();
}

public String toString(){
return "Length of Side: " + getSide();
}
}

public class Circle implements Shape
{
private int radius;

public Circle(int radius){
this.radius = radius;
}

public double getArea(){
return Math.PI * this.radius * this.radius;
}

public double getPerimeter(){
return 2 * Math.PI * this.radius;
}
}

==Delegation is Better==

===Example 1===

Delegation is better in this example because class c doesnt know if it wants to use class A or class B's implementation of the f and g methods. During the running of the code class c can change which class implementation of the functions it points to by calling toA or toB. Inheritance isnt able to handle this dynamically. Any implementation of the code would have to be either in the current class or its parent. It couldnt be in a sibling class. Example below is from link [11].

interface I {
void f();
void g();
}

class A implements I {
public void f() { System.out.println("A: doing f()"); }
public void g() { System.out.println("A: doing g()"); }
}

class B implements I {
public void f() { System.out.println("B: doing f()"); }
public void g() { System.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

public void f() { i.f(); }
public void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

===Example 2===

Below is the link to a great example of how to use delegation for a real world scenario. It isnt code but is in the form of diagrams.

http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Exampleofdelegation.html
http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Addingcomplexity.html
http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Crossingboundaries.html

==References==

# http://searchsmb.techtarget.com/sDefinition/0,,sid44_gci212351,00.html
# http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html
# http://www.tek-tips.com/viewthread.cfm?qid=372254
# http://www.python.org/ftp/python/doc/delegation.ps
# http://www.softwarefederation.com/csci4448/courseNotes/05_ObjectOrientedDesign.pdf
# http://www.javaworld.com/javaworld/javaqa/2001-09/01-qa-0914-delegate.html
# http://www.javacoffeebreak.com/java102/Account.java
# http://www.javacoffeebreak.com/java104/java104.html
# http://www.cs.utexas.edu/~scottm/cs305j/codingSamples.htm
# http://www.tanguay.info/web/codeExample.php?id=492
# http://en.wikipedia.org/wiki/Delegation_pattern
# http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Exampleofdelegation.html

CSC/ECE 517 Fall 2007/wiki2 10 c4

2007-10-23T03:26:33Z

Lwillia: /* References */

==Introduction==

===Problem===

Inheritance vs. delegation. Follow the debate on inheritance vs. delegation. Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

===Inheritance===

Inheritance is the process of one class having access to another class's attributes. Inheritance occurs when a class, also called the superclass, is created with generalized methods and attributes, and then another class is created as a subclass to the first class. The subclass provides provides detailed methods and attributes and automatically has access to methods and data members of the superclass. These subclasses can also override the generalized methods of the super class. Sometimes subclasses inherit from more than one super class; the occurrance of this is naturally called multiple inheritance.[1]

===Delegation===

Delegation is the process of assigning the implementation of a method, within a class, to another method. Generally, the implementation responsibility is forwarded to the parent class. If the parent class can not handle the implementation responsibility, it forwards it to its parent and so on and so on.
This forwarding allows a class to dynamically change by changing the parent class relations. Delegation is also called dynamic inheritance.[2]

==Inheritance vs Delegation==

Inheritance and delegation are used in different situations in object oriented programming. Although they can be used simultaneously, its rarely done due to the difficulty in it. Most of the time people use them interchangeably but are doing so incorrectly.

===When to use Inheritance===

* Inheritance is used when two objects are of the same type but one of the objects needs to handle somethings differently. The second object would inherit from the first and simply rewrite the code needed in the second object.[3]

* Inheritance is used in is-a relationships between objects. [3]

* Inheritance is used to sub categorize objects.[3]

* Inheritance should be restricted to objects of the same type.[3]

* When the base class is to general but the functionality is still needed.

=== When to use Delegation===

* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally.[3]

* Delegation is used in has-a relationships where the type of object that is included may change during runtime.

* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known right away. [6]

* When code execution within objects needs to be determined dynamically.

Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

==Inheritance is Better==

===Example 1===

Inheritance is better in this example because any specific account type will require the basic attributes of an account. An interest bearing account also "is a" account. Delegation would not be great in this case because allowing for methods to be determined dynamically opens up opportunities for hacker and calculation issues. Example below is from link [7] and link [8].

public class Account {
protected double balance; // Constructor to initialise balance

public Account( double amount ) {
balance = amount;
}
// Overloaded constructor for empty balance
public Account() {
balance = 0.0;
}
public void deposit( double amount ) {
balance += amount;
}
public double withdraw( double amount ) {
// See if amount can be withdrawn
if (balance >= amount) {
balance -= amount; return amount;
} else
// Withdrawal not allowed return 0.0;
}
public double getbalance() {
return balance;
}
}

class InterestBearingAccount extends Account{
private static double default_interest = 7.95;
private double interest_rate;

// Overloaded constructor accepting balance and an interest rate
public InterestBearingAccount( double amount, double interest){
balance = amount;
interest_rate = interest;
}
// Overloaded constructor accepting balance with a default interest rate
public InterestBearingAccount( double amount ){
balance = amount;
interest_rate = default_interest;
}
// Overloaded constructor with empty balance and a default interest rate
public InterestBearingAccount(){
balance = 0.0;
interest_rate = default_interest;
}

public void add_monthly_interest(){
// Add interest to our account
balance = balance +
(balance * interest_rate / 100) / 12;
}
}

===Example 2===

Here is another example where inheritance is better than delegation. The generalized shape interface is used as a basis for all of the subclasses.
Notice that each subclass is designed to personal specifications for the object. Here there would be no need for any of the code to dynamically change. Example below is from link [9].

public interface Shape{
public double getArea();
public double getPerimeter();
}

public class Rectangle implements Shape
{
private int width;
private int height;

public Rectangle(){
this(1,1);
}

public Rectangle(int width, int height){
this.width = width;
this.height = height;
}

public int getWidth(){
return this.width;
}

public int getHeight(){
return this.height;
}

public double getPerimeter(){
return 2 * this.height + 2 * this.width;
}

public double getArea(){
return width * height;
}

public String toString(){
return "width: " + this.width + ", height: " + this.height;
}
}

public class Square extends Rectangle{
public Square(int lengthOfSide){
super(lengthOfSide, lengthOfSide);
}

public int getSide(){
return getWidth();
}

public String toString(){
return "Length of Side: " + getSide();
}
}

public class Circle implements Shape
{
private int radius;

public Circle(int radius){
this.radius = radius;
}

public double getArea(){
return Math.PI * this.radius * this.radius;
}

public double getPerimeter(){
return 2 * Math.PI * this.radius;
}
}

==Delegation is Better==

===Example 1===

Delegation is better in this example because class c doesnt know if it wants to use class A or class B's implementation of the f and g methods. During the running of the code class c can change which class implementation of the functions it points to by calling toA or toB. Inheritance isnt able to handle this dynamically. Any implementation of the code would have to be either in the current class or its parent. It couldnt be in a sibling class. Example below is from link [11].

interface I {
void f();
void g();
}

class A implements I {
public void f() { System.out.println("A: doing f()"); }
public void g() { System.out.println("A: doing g()"); }
}

class B implements I {
public void f() { System.out.println("B: doing f()"); }
public void g() { System.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

public void f() { i.f(); }
public void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

===Example 2===

==References==

# http://searchsmb.techtarget.com/sDefinition/0,,sid44_gci212351,00.html
# http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html
# http://www.tek-tips.com/viewthread.cfm?qid=372254
# http://www.python.org/ftp/python/doc/delegation.ps
# http://www.softwarefederation.com/csci4448/courseNotes/05_ObjectOrientedDesign.pdf
# http://www.javaworld.com/javaworld/javaqa/2001-09/01-qa-0914-delegate.html
# http://www.javacoffeebreak.com/java102/Account.java
# http://www.javacoffeebreak.com/java104/java104.html
# http://www.cs.utexas.edu/~scottm/cs305j/codingSamples.htm
# http://www.tanguay.info/web/codeExample.php?id=492
# http://en.wikipedia.org/wiki/Delegation_pattern
# http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class7/Exampleofdelegation.html

CSC/ECE 517 Fall 2007/wiki2 10 c4

2007-10-23T03:19:02Z

Lwillia: /* Example 1 */

==Introduction==

===Problem===

Inheritance vs. delegation. Follow the debate on inheritance vs. delegation. Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

===Inheritance===

Inheritance is the process of one class having access to another class's attributes. Inheritance occurs when a class, also called the superclass, is created with generalized methods and attributes, and then another class is created as a subclass to the first class. The subclass provides provides detailed methods and attributes and automatically has access to methods and data members of the superclass. These subclasses can also override the generalized methods of the super class. Sometimes subclasses inherit from more than one super class; the occurrance of this is naturally called multiple inheritance.[1]

===Delegation===

Delegation is the process of assigning the implementation of a method, within a class, to another method. Generally, the implementation responsibility is forwarded to the parent class. If the parent class can not handle the implementation responsibility, it forwards it to its parent and so on and so on.
This forwarding allows a class to dynamically change by changing the parent class relations. Delegation is also called dynamic inheritance.[2]

==Inheritance vs Delegation==

Inheritance and delegation are used in different situations in object oriented programming. Although they can be used simultaneously, its rarely done due to the difficulty in it. Most of the time people use them interchangeably but are doing so incorrectly.

===When to use Inheritance===

* Inheritance is used when two objects are of the same type but one of the objects needs to handle somethings differently. The second object would inherit from the first and simply rewrite the code needed in the second object.[3]

* Inheritance is used in is-a relationships between objects. [3]

* Inheritance is used to sub categorize objects.[3]

* Inheritance should be restricted to objects of the same type.[3]

* When the base class is to general but the functionality is still needed.

=== When to use Delegation===

* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally.[3]

* Delegation is used in has-a relationships where the type of object that is included may change during runtime.

* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known right away. [6]

* When code execution within objects needs to be determined dynamically.

Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

==Inheritance is Better==

===Example 1===

Inheritance is better in this example because any specific account type will require the basic attributes of an account. An interest bearing account also "is a" account. Delegation would not be great in this case because allowing for methods to be determined dynamically opens up opportunities for hacker and calculation issues. Example below is from link [7] and link [8].

public class Account {
protected double balance; // Constructor to initialise balance

public Account( double amount ) {
balance = amount;
}
// Overloaded constructor for empty balance
public Account() {
balance = 0.0;
}
public void deposit( double amount ) {
balance += amount;
}
public double withdraw( double amount ) {
// See if amount can be withdrawn
if (balance >= amount) {
balance -= amount; return amount;
} else
// Withdrawal not allowed return 0.0;
}
public double getbalance() {
return balance;
}
}

class InterestBearingAccount extends Account{
private static double default_interest = 7.95;
private double interest_rate;

// Overloaded constructor accepting balance and an interest rate
public InterestBearingAccount( double amount, double interest){
balance = amount;
interest_rate = interest;
}
// Overloaded constructor accepting balance with a default interest rate
public InterestBearingAccount( double amount ){
balance = amount;
interest_rate = default_interest;
}
// Overloaded constructor with empty balance and a default interest rate
public InterestBearingAccount(){
balance = 0.0;
interest_rate = default_interest;
}

public void add_monthly_interest(){
// Add interest to our account
balance = balance +
(balance * interest_rate / 100) / 12;
}
}

===Example 2===

Here is another example where inheritance is better than delegation. The generalized shape interface is used as a basis for all of the subclasses.
Notice that each subclass is designed to personal specifications for the object. Here there would be no need for any of the code to dynamically change. Example below is from link [9].

public interface Shape{
public double getArea();
public double getPerimeter();
}

public class Rectangle implements Shape
{
private int width;
private int height;

public Rectangle(){
this(1,1);
}

public Rectangle(int width, int height){
this.width = width;
this.height = height;
}

public int getWidth(){
return this.width;
}

public int getHeight(){
return this.height;
}

public double getPerimeter(){
return 2 * this.height + 2 * this.width;
}

public double getArea(){
return width * height;
}

public String toString(){
return "width: " + this.width + ", height: " + this.height;
}
}

public class Square extends Rectangle{
public Square(int lengthOfSide){
super(lengthOfSide, lengthOfSide);
}

public int getSide(){
return getWidth();
}

public String toString(){
return "Length of Side: " + getSide();
}
}

public class Circle implements Shape
{
private int radius;

public Circle(int radius){
this.radius = radius;
}

public double getArea(){
return Math.PI * this.radius * this.radius;
}

public double getPerimeter(){
return 2 * Math.PI * this.radius;
}
}

==Delegation is Better==

===Example 1===

Delegation is better in this example because class c doesnt know if it wants to use class A or class B's implementation of the f and g methods. During the running of the code class c can change which class implementation of the functions it points to by calling toA or toB. Inheritance isnt able to handle this dynamically. Any implementation of the code would have to be either in the current class or its parent. It couldnt be in a sibling class. Example below is from link [11].

interface I {
void f();
void g();
}

class A implements I {
public void f() { System.out.println("A: doing f()"); }
public void g() { System.out.println("A: doing g()"); }
}

class B implements I {
public void f() { System.out.println("B: doing f()"); }
public void g() { System.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

public void f() { i.f(); }
public void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

===Example 2===

==References==

# http://searchsmb.techtarget.com/sDefinition/0,,sid44_gci212351,00.html
# http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html
# http://www.tek-tips.com/viewthread.cfm?qid=372254
# http://www.python.org/ftp/python/doc/delegation.ps
# http://www.softwarefederation.com/csci4448/courseNotes/05_ObjectOrientedDesign.pdf
# http://www.javaworld.com/javaworld/javaqa/2001-09/01-qa-0914-delegate.html
# http://www.javacoffeebreak.com/java102/Account.java
# http://www.javacoffeebreak.com/java104/java104.html
# http://www.cs.utexas.edu/~scottm/cs305j/codingSamples.htm
# http://www.tanguay.info/web/codeExample.php?id=492
# http://en.wikipedia.org/wiki/Delegation_pattern

CSC/ECE 517 Fall 2007/wiki2 10 c4

2007-10-23T03:18:43Z

Lwillia: /* References */

==Introduction==

===Problem===

Inheritance vs. delegation. Follow the debate on inheritance vs. delegation. Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

===Inheritance===

Inheritance is the process of one class having access to another class's attributes. Inheritance occurs when a class, also called the superclass, is created with generalized methods and attributes, and then another class is created as a subclass to the first class. The subclass provides provides detailed methods and attributes and automatically has access to methods and data members of the superclass. These subclasses can also override the generalized methods of the super class. Sometimes subclasses inherit from more than one super class; the occurrance of this is naturally called multiple inheritance.[1]

===Delegation===

Delegation is the process of assigning the implementation of a method, within a class, to another method. Generally, the implementation responsibility is forwarded to the parent class. If the parent class can not handle the implementation responsibility, it forwards it to its parent and so on and so on.
This forwarding allows a class to dynamically change by changing the parent class relations. Delegation is also called dynamic inheritance.[2]

==Inheritance vs Delegation==

Inheritance and delegation are used in different situations in object oriented programming. Although they can be used simultaneously, its rarely done due to the difficulty in it. Most of the time people use them interchangeably but are doing so incorrectly.

===When to use Inheritance===

* Inheritance is used when two objects are of the same type but one of the objects needs to handle somethings differently. The second object would inherit from the first and simply rewrite the code needed in the second object.[3]

* Inheritance is used in is-a relationships between objects. [3]

* Inheritance is used to sub categorize objects.[3]

* Inheritance should be restricted to objects of the same type.[3]

* When the base class is to general but the functionality is still needed.

=== When to use Delegation===

* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally.[3]

* Delegation is used in has-a relationships where the type of object that is included may change during runtime.

* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known right away. [6]

* When code execution within objects needs to be determined dynamically.

Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

==Inheritance is Better==

===Example 1===

Inheritance is better in this example because any specific account type will require the basic attributes of an account. An interest bearing account also "is a" account. Delegation would not be great in this case because allowing for methods to be determined dynamically opens up opportunities for hacker and calculation issues. Example below is from link [7] and link [8].

public class Account {
protected double balance; // Constructor to initialise balance

public Account( double amount ) {
balance = amount;
}
// Overloaded constructor for empty balance
public Account() {
balance = 0.0;
}
public void deposit( double amount ) {
balance += amount;
}
public double withdraw( double amount ) {
// See if amount can be withdrawn
if (balance >= amount) {
balance -= amount; return amount;
} else
// Withdrawal not allowed return 0.0;
}
public double getbalance() {
return balance;
}
}

class InterestBearingAccount extends Account{
private static double default_interest = 7.95;
private double interest_rate;

// Overloaded constructor accepting balance and an interest rate
public InterestBearingAccount( double amount, double interest){
balance = amount;
interest_rate = interest;
}
// Overloaded constructor accepting balance with a default interest rate
public InterestBearingAccount( double amount ){
balance = amount;
interest_rate = default_interest;
}
// Overloaded constructor with empty balance and a default interest rate
public InterestBearingAccount(){
balance = 0.0;
interest_rate = default_interest;
}

public void add_monthly_interest(){
// Add interest to our account
balance = balance +
(balance * interest_rate / 100) / 12;
}
}

===Example 2===

Here is another example where inheritance is better than delegation. The generalized shape interface is used as a basis for all of the subclasses.
Notice that each subclass is designed to personal specifications for the object. Here there would be no need for any of the code to dynamically change. Example below is from link [9].

public interface Shape{
public double getArea();
public double getPerimeter();
}

public class Rectangle implements Shape
{
private int width;
private int height;

public Rectangle(){
this(1,1);
}

public Rectangle(int width, int height){
this.width = width;
this.height = height;
}

public int getWidth(){
return this.width;
}

public int getHeight(){
return this.height;
}

public double getPerimeter(){
return 2 * this.height + 2 * this.width;
}

public double getArea(){
return width * height;
}

public String toString(){
return "width: " + this.width + ", height: " + this.height;
}
}

public class Square extends Rectangle{
public Square(int lengthOfSide){
super(lengthOfSide, lengthOfSide);
}

public int getSide(){
return getWidth();
}

public String toString(){
return "Length of Side: " + getSide();
}
}

public class Circle implements Shape
{
private int radius;

public Circle(int radius){
this.radius = radius;
}

public double getArea(){
return Math.PI * this.radius * this.radius;
}

public double getPerimeter(){
return 2 * Math.PI * this.radius;
}
}

==Delegation is Better==

===Example 1===

Delegation is better in this example because class c doesnt know if it wants to use class A or class B's implementation of the f and g methods. During the running of the code class c can change which class implementation of the functions it points to by calling toA or toB. Inheritance isnt able to handle this dynamically. Any implementation of the code would have to be either in the current class or its parent. It couldnt be in a sibling class.

interface I {
void f();
void g();
}

class A implements I {
public void f() { System.out.println("A: doing f()"); }
public void g() { System.out.println("A: doing g()"); }
}

class B implements I {
public void f() { System.out.println("B: doing f()"); }
public void g() { System.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

public void f() { i.f(); }
public void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

===Example 2===

==References==

# http://searchsmb.techtarget.com/sDefinition/0,,sid44_gci212351,00.html
# http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html
# http://www.tek-tips.com/viewthread.cfm?qid=372254
# http://www.python.org/ftp/python/doc/delegation.ps
# http://www.softwarefederation.com/csci4448/courseNotes/05_ObjectOrientedDesign.pdf
# http://www.javaworld.com/javaworld/javaqa/2001-09/01-qa-0914-delegate.html
# http://www.javacoffeebreak.com/java102/Account.java
# http://www.javacoffeebreak.com/java104/java104.html
# http://www.cs.utexas.edu/~scottm/cs305j/codingSamples.htm
# http://www.tanguay.info/web/codeExample.php?id=492
# http://en.wikipedia.org/wiki/Delegation_pattern

CSC/ECE 517 Fall 2007/wiki2 10 c4

2007-10-23T03:18:17Z

Lwillia: /* Example 1 */

==Introduction==

===Problem===

Inheritance vs. delegation. Follow the debate on inheritance vs. delegation. Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

===Inheritance===

Inheritance is the process of one class having access to another class's attributes. Inheritance occurs when a class, also called the superclass, is created with generalized methods and attributes, and then another class is created as a subclass to the first class. The subclass provides provides detailed methods and attributes and automatically has access to methods and data members of the superclass. These subclasses can also override the generalized methods of the super class. Sometimes subclasses inherit from more than one super class; the occurrance of this is naturally called multiple inheritance.[1]

===Delegation===

Delegation is the process of assigning the implementation of a method, within a class, to another method. Generally, the implementation responsibility is forwarded to the parent class. If the parent class can not handle the implementation responsibility, it forwards it to its parent and so on and so on.
This forwarding allows a class to dynamically change by changing the parent class relations. Delegation is also called dynamic inheritance.[2]

==Inheritance vs Delegation==

Inheritance and delegation are used in different situations in object oriented programming. Although they can be used simultaneously, its rarely done due to the difficulty in it. Most of the time people use them interchangeably but are doing so incorrectly.

===When to use Inheritance===

* Inheritance is used when two objects are of the same type but one of the objects needs to handle somethings differently. The second object would inherit from the first and simply rewrite the code needed in the second object.[3]

* Inheritance is used in is-a relationships between objects. [3]

* Inheritance is used to sub categorize objects.[3]

* Inheritance should be restricted to objects of the same type.[3]

* When the base class is to general but the functionality is still needed.

=== When to use Delegation===

* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally.[3]

* Delegation is used in has-a relationships where the type of object that is included may change during runtime.

* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known right away. [6]

* When code execution within objects needs to be determined dynamically.

Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

==Inheritance is Better==

===Example 1===

Inheritance is better in this example because any specific account type will require the basic attributes of an account. An interest bearing account also "is a" account. Delegation would not be great in this case because allowing for methods to be determined dynamically opens up opportunities for hacker and calculation issues. Example below is from link [7] and link [8].

public class Account {
protected double balance; // Constructor to initialise balance

public Account( double amount ) {
balance = amount;
}
// Overloaded constructor for empty balance
public Account() {
balance = 0.0;
}
public void deposit( double amount ) {
balance += amount;
}
public double withdraw( double amount ) {
// See if amount can be withdrawn
if (balance >= amount) {
balance -= amount; return amount;
} else
// Withdrawal not allowed return 0.0;
}
public double getbalance() {
return balance;
}
}

class InterestBearingAccount extends Account{
private static double default_interest = 7.95;
private double interest_rate;

// Overloaded constructor accepting balance and an interest rate
public InterestBearingAccount( double amount, double interest){
balance = amount;
interest_rate = interest;
}
// Overloaded constructor accepting balance with a default interest rate
public InterestBearingAccount( double amount ){
balance = amount;
interest_rate = default_interest;
}
// Overloaded constructor with empty balance and a default interest rate
public InterestBearingAccount(){
balance = 0.0;
interest_rate = default_interest;
}

public void add_monthly_interest(){
// Add interest to our account
balance = balance +
(balance * interest_rate / 100) / 12;
}
}

===Example 2===

Here is another example where inheritance is better than delegation. The generalized shape interface is used as a basis for all of the subclasses.
Notice that each subclass is designed to personal specifications for the object. Here there would be no need for any of the code to dynamically change. Example below is from link [9].

public interface Shape{
public double getArea();
public double getPerimeter();
}

public class Rectangle implements Shape
{
private int width;
private int height;

public Rectangle(){
this(1,1);
}

public Rectangle(int width, int height){
this.width = width;
this.height = height;
}

public int getWidth(){
return this.width;
}

public int getHeight(){
return this.height;
}

public double getPerimeter(){
return 2 * this.height + 2 * this.width;
}

public double getArea(){
return width * height;
}

public String toString(){
return "width: " + this.width + ", height: " + this.height;
}
}

public class Square extends Rectangle{
public Square(int lengthOfSide){
super(lengthOfSide, lengthOfSide);
}

public int getSide(){
return getWidth();
}

public String toString(){
return "Length of Side: " + getSide();
}
}

public class Circle implements Shape
{
private int radius;

public Circle(int radius){
this.radius = radius;
}

public double getArea(){
return Math.PI * this.radius * this.radius;
}

public double getPerimeter(){
return 2 * Math.PI * this.radius;
}
}

==Delegation is Better==

===Example 1===

Delegation is better in this example because class c doesnt know if it wants to use class A or class B's implementation of the f and g methods. During the running of the code class c can change which class implementation of the functions it points to by calling toA or toB. Inheritance isnt able to handle this dynamically. Any implementation of the code would have to be either in the current class or its parent. It couldnt be in a sibling class.

interface I {
void f();
void g();
}

class A implements I {
public void f() { System.out.println("A: doing f()"); }
public void g() { System.out.println("A: doing g()"); }
}

class B implements I {
public void f() { System.out.println("B: doing f()"); }
public void g() { System.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

public void f() { i.f(); }
public void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

===Example 2===

==References==

# http://searchsmb.techtarget.com/sDefinition/0,,sid44_gci212351,00.html
# http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html
# http://www.tek-tips.com/viewthread.cfm?qid=372254
# http://www.python.org/ftp/python/doc/delegation.ps
# http://www.softwarefederation.com/csci4448/courseNotes/05_ObjectOrientedDesign.pdf
# http://www.javaworld.com/javaworld/javaqa/2001-09/01-qa-0914-delegate.html
# http://www.javacoffeebreak.com/java102/Account.java
# http://www.javacoffeebreak.com/java104/java104.html
# http://www.cs.utexas.edu/~scottm/cs305j/codingSamples.htm
# http://www.tanguay.info/web/codeExample.php?id=492

CSC/ECE 517 Fall 2007/wiki2 10 c4

2007-10-23T03:12:35Z

Lwillia: /* Example 1 */

==Introduction==

===Problem===

Inheritance vs. delegation. Follow the debate on inheritance vs. delegation. Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

===Inheritance===

Inheritance is the process of one class having access to another class's attributes. Inheritance occurs when a class, also called the superclass, is created with generalized methods and attributes, and then another class is created as a subclass to the first class. The subclass provides provides detailed methods and attributes and automatically has access to methods and data members of the superclass. These subclasses can also override the generalized methods of the super class. Sometimes subclasses inherit from more than one super class; the occurrance of this is naturally called multiple inheritance.[1]

===Delegation===

Delegation is the process of assigning the implementation of a method, within a class, to another method. Generally, the implementation responsibility is forwarded to the parent class. If the parent class can not handle the implementation responsibility, it forwards it to its parent and so on and so on.
This forwarding allows a class to dynamically change by changing the parent class relations. Delegation is also called dynamic inheritance.[2]

==Inheritance vs Delegation==

Inheritance and delegation are used in different situations in object oriented programming. Although they can be used simultaneously, its rarely done due to the difficulty in it. Most of the time people use them interchangeably but are doing so incorrectly.

===When to use Inheritance===

* Inheritance is used when two objects are of the same type but one of the objects needs to handle somethings differently. The second object would inherit from the first and simply rewrite the code needed in the second object.[3]

* Inheritance is used in is-a relationships between objects. [3]

* Inheritance is used to sub categorize objects.[3]

* Inheritance should be restricted to objects of the same type.[3]

* When the base class is to general but the functionality is still needed.

=== When to use Delegation===

* Delegation is used when two objects aren't of the same type but one has methods and attributes that the other wants to use internally.[3]

* Delegation is used in has-a relationships where the type of object that is included may change during runtime.

* Delegation is used when methods implementation needs to be handled by some other class within the parent tree. The class that will handle the method isn't known right away. [6]

* When code execution within objects needs to be determined dynamically.

Construct (or, better, cite) examples that show cases where inheritance is better, and cases where delegation is better. Attempt to characterize the situations in which you should employ one or the other.

==Inheritance is Better==

===Example 1===

Inheritance is better in this example because any specific account type will require the basic attributes of an account. An interest bearing account also "is a" account. Delegation would not be great in this case because allowing for methods to be determined dynamically opens up opportunities for hacker and calculation issues. Example below is from link [7] and link [8].

public class Account {
protected double balance; // Constructor to initialise balance

public Account( double amount ) {
balance = amount;
}
// Overloaded constructor for empty balance
public Account() {
balance = 0.0;
}
public void deposit( double amount ) {
balance += amount;
}
public double withdraw( double amount ) {
// See if amount can be withdrawn
if (balance >= amount) {
balance -= amount; return amount;
} else
// Withdrawal not allowed return 0.0;
}
public double getbalance() {
return balance;
}
}

class InterestBearingAccount extends Account{
private static double default_interest = 7.95;
private double interest_rate;

// Overloaded constructor accepting balance and an interest rate
public InterestBearingAccount( double amount, double interest){
balance = amount;
interest_rate = interest;
}
// Overloaded constructor accepting balance with a default interest rate
public InterestBearingAccount( double amount ){
balance = amount;
interest_rate = default_interest;
}
// Overloaded constructor with empty balance and a default interest rate
public InterestBearingAccount(){
balance = 0.0;
interest_rate = default_interest;
}

public void add_monthly_interest(){
// Add interest to our account
balance = balance +
(balance * interest_rate / 100) / 12;
}
}

===Example 2===

Here is another example where inheritance is better than delegation. The generalized shape interface is used as a basis for all of the subclasses.
Notice that each subclass is designed to personal specifications for the object. Here there would be no need for any of the code to dynamically change. Example below is from link [9].

public interface Shape{
public double getArea();
public double getPerimeter();
}

public class Rectangle implements Shape
{
private int width;
private int height;

public Rectangle(){
this(1,1);
}

public Rectangle(int width, int height){
this.width = width;
this.height = height;
}

public int getWidth(){
return this.width;
}

public int getHeight(){
return this.height;
}

public double getPerimeter(){
return 2 * this.height + 2 * this.width;
}

public double getArea(){
return width * height;
}

public String toString(){
return "width: " + this.width + ", height: " + this.height;
}
}

public class Square extends Rectangle{
public Square(int lengthOfSide){
super(lengthOfSide, lengthOfSide);
}

public int getSide(){
return getWidth();
}

public String toString(){
return "Length of Side: " + getSide();
}
}

public class Circle implements Shape
{
private int radius;

public Circle(int radius){
this.radius = radius;
}

public double getArea(){
return Math.PI * this.radius * this.radius;
}

public double getPerimeter(){
return 2 * Math.PI * this.radius;
}
}

==Delegation is Better==

===Example 1===

interface I {
void f();
void g();
}

class A implements I {
public void f() { System.out.println("A: doing f()"); }
public void g() { System.out.println("A: doing g()"); }
}

class B implements I {
public void f() { System.out.println("B: doing f()"); }
public void g() { System.out.println("B: doing g()"); }
}

class C implements I {
// delegation
I i = new A();

public void f() { i.f(); }
public void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}

===Example 2===

==References==

# http://searchsmb.techtarget.com/sDefinition/0,,sid44_gci212351,00.html
# http://www.ccs.neu.edu/research/demeter/papers/context-journal/node3.html
# http://www.tek-tips.com/viewthread.cfm?qid=372254
# http://www.python.org/ftp/python/doc/delegation.ps
# http://www.softwarefederation.com/csci4448/courseNotes/05_ObjectOrientedDesign.pdf
# http://www.javaworld.com/javaworld/javaqa/2001-09/01-qa-0914-delegate.html
# http://www.javacoffeebreak.com/java102/Account.java
# http://www.javacoffeebreak.com/java104/java104.html
# http://www.cs.utexas.edu/~scottm/cs305j/codingSamples.htm
# http://www.tanguay.info/web/codeExample.php?id=492